with

    System;


package body Packrat.Parsers is


    function "<"
           (Left, Right : in Elem_Array_Holders.Holder)
        return Boolean
    is
        use Traits;
    begin
        return Left.Element < Right.Element;
    end "<";


    function "<"
           (Left, Right : in Token_Array_Holders.Holder)
        return Boolean
    is
        use Traits.Tokens;
    begin
        return Left.Element < Right.Element;
    end "<";


    function "<"
           (Left, Right : in Combo_Key)
        return Boolean is
    begin
        if Left.Start = Right.Start then
            return Left.Func < Right.Func;
        else
            return Left.Start < Right.Start;
        end if;
    end "<";


    function "<"
           (Left, Right : in Combo_Result_Part)
        return Boolean
    is
        use type Elem_Array_Holders.Holder;
    begin
        if Left.Finish = Right.Finish then
            if Left.Value = Right.Value then
                return Left.Tokens < Right.Tokens;
            else
                return Left.Value < Right.Value;
            end if;
        else
            return Left.Finish < Right.Finish;
        end if;
    end "<";


    function "<"
           (Left, Right : in Combinator)
        return Boolean
    is
        use type System.Address;
    begin
        return Left.all'Address < Right.all'Address;
    end "<";





    function Root
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Component_Result
    is
    begin
        return (Status => Failure);
    end Root;





    procedure Parse
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Result  :    out Graphs.Parse_Graph)
    is
    begin
        null;
    end Parse;


    function Parse_Only
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context)
        return Graphs.Parse_Graph
    is
    begin
        return Graphs.Empty_Graph;
    end Parse_Only;


    function Parse_With
           (Input   : in     With_Input;
            Context : in out Parser_Context)
        return Graphs.Parse_Graph
    is
    begin
        return Graphs.Empty_Graph;
    end Parse_With;





    function Stamp
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Stamp;


    function Ignore
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Ignore;





    function Sequence
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Sequence;


    function Choice
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Choice;


    function Count
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Count;


    function Many
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Many;


    function Many_Until
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Many_Until;





    function Satisfy
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Satisfy;


    function Satisfy_With
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Satisfy_With;


    function Match
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Match;


    function Match_With
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Match_With;


    function Multimatch
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Multimatch;


    function Take
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Take;


    function Take_While
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Take_While;


    function Take_Until
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Take_Until;





    function Line_End
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Line_End;


    function Input_End
           (Input   : in     Traits.Element_Array;
            Context : in out Parser_Context;
            Start   : in     Positive)
        return Combinator_Result
    is
    begin
        return
           (Results  => Result_Sets.Empty_Set,
            Curtails => Curtail_Maps.Empty_Map,
            Status   => Failure);
    end Input_End;


end Packrat.Parsers;