root/trunk/enki/EnkiParser.d

//Generated by Enki v1.2

/+
    Copyright (c) 2006 Eric Anderton

    Permission is hereby granted, free of charge, to any person
    obtaining a copy of this software and associated documentation
    files (the "Software"), to deal in the Software without
    restriction, including without limitation the rights to use,
    copy, modify, merge, publish, distribute, sublicense, and/or
    sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following
    conditions:

    The above copyright notice and this permission notice shall be
    included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
    OTHER DEALINGS IN THE SOFTWARE.
+/

module enki.EnkiParser;
version(build) pragma(export_version,EnkiUTF8);

debug private import tango.io.Stdout;
private import enki.types;
private import enki.EnkiBackend;
private import enki.Rule;
private import enki.Expression;
private import enki.Directive;



class EnkiParser : BaseEnkiParser{

    /*
    
WS
    ::=  ws [ (  SlashSlashComment |  SlashStarComment)  WS];

    */
    public ResultT!(bool) parse_WS(){
        debug Stdout.formatln("parse_WS()");
        uint start1 = position;
        //no declarations
        
        
        {//Expression
            uint start2 = position;
            if(!(parse_ws().success)){
                goto mismatch4;
            }
            {//OptionalExpr
                {//Expression
                    uint start4 = position;
                    {//Expression
                        uint start5 = position;
                        if((parse_SlashSlashComment().success) || (parse_SlashStarComment().success)){
                            clearErrors();
                        }else{
                            setError("Expected SlashSlashComment or SlashStarComment.");
                            position = start5;
                            goto mismatch6;
                        }
                    }
                    if(!(parse_WS().success)){
                        goto mismatch6;
                    }
                    goto match5;
                mismatch6:
                    {/*do nothing*/}
                    position = start4;
                    {/*do nothing*/}
                match5:
                    clearErrors();
                    {/*do nothing*/}
                }
            }
            goto match3;
        mismatch4:
            setError("Expected ws.");
            position = start2;
            goto mismatch2;
        match3:
            clearErrors();
            goto match1;
        }
    match1:
        debug Stdout.formatln("parse_WS() PASS");
        return ResultT!(bool)(true);
    mismatch2:
        position = start1;
        return ResultT!(bool)();
    }

    /*
    
Syntax
    = void createSyntax(SyntaxLine[] lines)
    ::=  WS { (  Rule:~lines |  Comment:~lines |  Directive:~lines)  WS} eoi;

    */
    public ResultT!(String) parse_Syntax(){
        debug Stdout.formatln("parse_Syntax()");
        uint start6 = position;
        SyntaxLine[] bind_lines;
        
        
        {//Expression
            uint start7 = position;
            if(!(parse_WS().success)){
                goto mismatch10;
            }
            {//ZeroOrMoreExpr
                uint start8 = position;
                uint termPos9;
            loop11:
                termPos9 = position;
                if(parse_eoi().success){
                    goto loopend12;
                }else{
                    goto exprStart13;
                }
            exprStart13:
                {//Expression
                    uint start10 = position;
                    {//Expression
                        uint start11 = position;
                        if((parse_Rule().assignCat!(SyntaxLine[])(bind_lines)) || (parse_Comment().assignCat!(SyntaxLine[])(bind_lines)) || (parse_Directive().assignCat!(SyntaxLine[])(bind_lines))){
                            clearErrors();
                        }else{
                            setError("Expected Rule, Comment or Directive.");
                            position = start11;
                            goto mismatch15;
                        }
                    }
                    if(!(parse_WS().success)){
                        goto mismatch15;
                    }
                    goto match14;
                mismatch15:
                    {/*do nothing*/}
                    position = start10;
                    goto loopend12;
                match14:
                    clearErrors();
                    goto loop11;
                }
            loopend12:
                {/*do nothing*/}
            }
            goto match9;
        mismatch10:
            setError("Expected WS.");
            position = start7;
            goto mismatch8;
        match9:
            clearErrors();
            goto match7;
        }
    match7:
        debug Stdout.formatln("parse_Syntax() PASS");
        createSyntax(bind_lines);
        return ResultT!(String)(sliceData(start6,position));
    mismatch8:
        position = start6;
        return ResultT!(String)();
    }

    /*
    
Rule
    = new Rule(String name,RulePredicate pred,Expression expr,RuleDecl decl)
    ::=  Identifier:name  WS [  RuleDecl:decl  WS] [  RulePredicate:pred]  WS  "::="  WS  Expression:expr  WS  ";";

    */
    public ResultT!(Rule) parse_Rule(){
        debug Stdout.formatln("parse_Rule()");
        uint start12 = position;
        String bind_name;
        RulePredicate bind_pred;
        Expression bind_expr;
        RuleDecl bind_decl;
        
        
        {//Expression
            uint start13 = position;
            if(!(parse_Identifier().assign!(String)(bind_name))){
                goto mismatch19;
            }
            if(!(parse_WS().success)){
                goto mismatch19;
            }
            {//OptionalExpr
                {//Expression
                    uint start15 = position;
                    if((parse_RuleDecl().assign!(RuleDecl)(bind_decl) && parse_WS().success)){
                        clearErrors();
                    }else{
                        position = start15;
                    }
                }
            }
            {//OptionalExpr
                {//Expression
                    uint start17 = position;
                    if((parse_RulePredicate().assign!(RulePredicate)(bind_pred))){
                        clearErrors();
                    }else{
                        position = start17;
                    }
                }
            }
            if(!(parse_WS().success)){
                goto mismatch19;
            }
            if(!(terminal("::=").success)){
                goto mismatch19;
            }
            if(!(parse_WS().success)){
                goto mismatch19;
            }
            if(!(parse_Expression().assign!(Expression)(bind_expr))){
                goto mismatch19;
            }
            if(!(parse_WS().success)){
                goto mismatch19;
            }
            if(!(terminal(";").success)){
                goto mismatch19;
            }
            goto match18;
        mismatch19:
            setError("Expected Identifier.");
            position = start13;
            goto mismatch17;
        match18:
            clearErrors();
            goto match16;
        }
    match16:
        debug Stdout.formatln("parse_Rule() PASS");
        ResultT!(Rule) passed = ResultT!(Rule)(new Rule(bind_name,bind_pred,bind_expr,bind_decl));
        return passed;
    mismatch17:
        position = start12;
        ResultT!(Rule) failed = ResultT!(Rule)();
        return failed;
    }

    /*
    
RuleDecl
    = new RuleDecl(Param[] params)
    ::=  ParamsExpr:params;

    */
    public ResultT!(RuleDecl) parse_RuleDecl(){
        debug Stdout.formatln("parse_RuleDecl()");
        uint start18 = position;
        Param[] bind_params;
        
        
        {//Expression
            uint start19 = position;
            if((parse_ParamsExpr().assign!(Param[])(bind_params))){
                clearErrors();
                goto match20;
            }else{
                setError("Expected ParamsExpr.");
                position = start19;
                goto mismatch21;
            }
        }
    match20:
        debug Stdout.formatln("parse_RuleDecl() PASS");
        ResultT!(RuleDecl) passed = ResultT!(RuleDecl)(new RuleDecl(bind_params));
        return passed;
    mismatch21:
        position = start18;
        ResultT!(RuleDecl) failed = ResultT!(RuleDecl)();
        return failed;
    }

    /*
    
RulePredicate
    = RulePredicate pred
    ::=  "="  WS (  ClassPredicate:pred |  FunctionPredicate:pred |  BindingPredicate:pred);

    */
    public ResultT!(RulePredicate) parse_RulePredicate(){
        debug Stdout.formatln("parse_RulePredicate()");
        uint start20 = position;
        RulePredicate bind_pred;
        
        
        {//Expression
            uint start21 = position;
            if(!(terminal("=").success)){
                goto mismatch25;
            }
            if(!(parse_WS().success)){
                goto mismatch25;
            }
            {//Expression
                uint start22 = position;
                if((parse_ClassPredicate().assign!(RulePredicate)(bind_pred)) || (parse_FunctionPredicate().assign!(RulePredicate)(bind_pred)) || (parse_BindingPredicate().assign!(RulePredicate)(bind_pred))){
                    clearErrors();
                }else{
                    setError("Expected ClassPredicate, FunctionPredicate or BindingPredicate.");
                    position = start22;
                    goto mismatch25;
                }
            }
            goto match24;
        mismatch25:
            {/*do nothing*/}
            position = start21;
            goto mismatch23;
        match24:
            clearErrors();
            goto match22;
        }
    match22:
        debug Stdout.formatln("parse_RulePredicate() PASS");
        return ResultT!(RulePredicate)(bind_pred);
    mismatch23:
        position = start20;
        return ResultT!(RulePredicate)();
    }

    /*
    
ClassPredicate
    = new ClassPredicate(String name,Param[] params)
    ::=  "new"  WS  Identifier:name  WS  ParamsExpr:params;

    */
    public ResultT!(ClassPredicate) parse_ClassPredicate(){
        debug Stdout.formatln("parse_ClassPredicate()");
        uint start23 = position;
        String bind_name;
        Param[] bind_params;
        
        
        {//Expression
            uint start24 = position;
            if((terminal("new").success && parse_WS().success && parse_Identifier().assign!(String)(bind_name) && parse_WS().success && parse_ParamsExpr().assign!(Param[])(bind_params))){
                clearErrors();
                goto match26;
            }else{
                position = start24;
                goto mismatch27;
            }
        }
    match26:
        debug Stdout.formatln("parse_ClassPredicate() PASS");
        ResultT!(ClassPredicate) passed = ResultT!(ClassPredicate)(new ClassPredicate(bind_name,bind_params));
        return passed;
    mismatch27:
        position = start23;
        ResultT!(ClassPredicate) failed = ResultT!(ClassPredicate)();
        return failed;
    }

    /*
    
FunctionPredicate
    = new FunctionPredicate(Param decl,Param[] params)
    ::=  ExplicitParam:decl  WS  ParamsExpr:params;

    */
    public ResultT!(FunctionPredicate) parse_FunctionPredicate(){
        debug Stdout.formatln("parse_FunctionPredicate()");
        uint start25 = position;
        Param bind_decl;
        Param[] bind_params;
        
        
        {//Expression
            uint start26 = position;
            if((parse_ExplicitParam().assign!(Param)(bind_decl) && parse_WS().success && parse_ParamsExpr().assign!(Param[])(bind_params))){
                clearErrors();
                goto match28;
            }else{
                setError("Expected ExplicitParam.");
                position = start26;
                goto mismatch29;
            }
        }
    match28:
        debug Stdout.formatln("parse_FunctionPredicate() PASS");
        ResultT!(FunctionPredicate) passed = ResultT!(FunctionPredicate)(new FunctionPredicate(bind_decl,bind_params));
        return passed;
    mismatch29:
        position = start25;
        ResultT!(FunctionPredicate) failed = ResultT!(FunctionPredicate)();
        return failed;
    }

    /*
    
BindingPredicate
    = new BindingPredicate(Param param)
    ::=  Param:param;

    */
    public ResultT!(BindingPredicate) parse_BindingPredicate(){
        debug Stdout.formatln("parse_BindingPredicate()");
        uint start27 = position;
        Param bind_param;
        
        
        {//Expression
            uint start28 = position;
            if((parse_Param().assign!(Param)(bind_param))){
                clearErrors();
                goto match30;
            }else{
                setError("Expected Param.");
                position = start28;
                goto mismatch31;
            }
        }
    match30:
        debug Stdout.formatln("parse_BindingPredicate() PASS");
        ResultT!(BindingPredicate) passed = ResultT!(BindingPredicate)(new BindingPredicate(bind_param));
        return passed;
    mismatch31:
        position = start27;
        ResultT!(BindingPredicate) failed = ResultT!(BindingPredicate)();
        return failed;
    }

    /*
    
ParamsExpr
    = Param[] params
    ::=  "("  WS [  Param:~params  WS {  ","  WS  Param:~params  WS}]  ")";

    */
    public ResultT!(Param[]) parse_ParamsExpr(){
        debug Stdout.formatln("parse_ParamsExpr()");
        uint start29 = position;
        Param[] bind_params;
        
        
        {//Expression
            uint start30 = position;
            if(!(terminal("(").success)){
                goto mismatch35;
            }
            if(!(parse_WS().success)){
                goto mismatch35;
            }
            {//OptionalExpr
                {//Expression
                    uint start32 = position;
                    if(!(parse_Param().assignCat!(Param[])(bind_params))){
                        goto mismatch37;
                    }
                    if(!(parse_WS().success)){
                        goto mismatch37;
                    }
                    {//ZeroOrMoreExpr
                        uint termPos34;
                    loop38:
                        termPos34 = position;
                    exprStart40:
                        {//Expression
                            uint start35 = position;
                            if((terminal(",").success && parse_WS().success && parse_Param().assignCat!(Param[])(bind_params) && parse_WS().success)){
                                clearErrors();
                                goto loop38;
                            }else{
                                position = start35;
                                goto loopend39;
                            }
                        }
                    loopend39:
                        {/*do nothing*/}
                    }
                    goto match36;
                mismatch37:
                    {/*do nothing*/}
                    position = start32;
                    {/*do nothing*/}
                match36:
                    clearErrors();
                    {/*do nothing*/}
                }
            }
            if(!(terminal(")").success)){
                goto mismatch35;
            }
            goto match34;
        mismatch35:
            {/*do nothing*/}
            position = start30;
            goto mismatch33;
        match34:
            clearErrors();
            goto match32;
        }
    match32:
        debug Stdout.formatln("parse_ParamsExpr() PASS");
        return ResultT!(Param[])(bind_params);
    mismatch33:
        position = start29;
        return ResultT!(Param[])();
    }

    /*
    
Param
    = Param param
    ::=  ExplicitParam:param |  WeakParam:param;

    */
    public ResultT!(Param) parse_Param(){
        debug Stdout.formatln("parse_Param()");
        uint start36 = position;
        Param bind_param;
        
        
        {//Expression
            uint start37 = position;
            if((parse_ExplicitParam().assign!(Param)(bind_param)) || (parse_WeakParam().assign!(Param)(bind_param))){
                clearErrors();
                goto match41;
            }else{
                setError("Expected ExplicitParam or WeakParam.");
                position = start37;
                goto mismatch42;
            }
        }
    match41:
        debug Stdout.formatln("parse_Param() PASS");
        return ResultT!(Param)(bind_param);
    mismatch42:
        position = start36;
        return ResultT!(Param)();
    }

    /*
    
WeakParam
    = new Param(String name)
    ::=  Identifier:name;

    */
    public ResultT!(Param) parse_WeakParam(){
        debug Stdout.formatln("parse_WeakParam()");
        uint start38 = position;
        String bind_name;
        
        
        {//Expression
            uint start39 = position;
            if((parse_Identifier().assign!(String)(bind_name))){
                clearErrors();
                goto match43;
            }else{
                setError("Expected Identifier.");
                position = start39;
                goto mismatch44;
            }
        }
    match43:
        debug Stdout.formatln("parse_WeakParam() PASS");
        ResultT!(Param) passed = ResultT!(Param)(new Param(bind_name));
        return passed;
    mismatch44:
        position = start38;
        ResultT!(Param) failed = ResultT!(Param)();
        return failed;
    }

    /*
    
ExplicitParam
    = new Param(bool isArray,String type,String name)
    ::=  Identifier:type  WS [  "[]":isArray  Brackets  WS]  Identifier:name;

    */
    public ResultT!(Param) parse_ExplicitParam(){
        debug Stdout.formatln("parse_ExplicitParam()");
        uint start40 = position;
        bool bind_isArray;
        String bind_type;
        String bind_name;
        
        
        {//Expression
            uint start41 = position;
            if(!(parse_Identifier().assign!(String)(bind_type))){
                goto mismatch48;
            }
            if(!(parse_WS().success)){
                goto mismatch48;
            }
            {//OptionalExpr
                {//Expression
                    uint start43 = position;
                    if((terminal("[]").assign!(bool)(bind_isArray) && parse_Brackets().success && parse_WS().success)){
                        clearErrors();
                    }else{
                        position = start43;
                    }
                }
            }
            if(!(parse_Identifier().assign!(String)(bind_name))){
                goto mismatch48;
            }
            goto match47;
        mismatch48:
            setError("Expected Identifier.");
            position = start41;
            goto mismatch46;
        match47:
            clearErrors();
            goto match45;
        }
    match45:
        debug Stdout.formatln("parse_ExplicitParam() PASS");
        ResultT!(Param) passed = ResultT!(Param)(new Param(bind_isArray,bind_type,bind_name));
        return passed;
    mismatch46:
        position = start40;
        ResultT!(Param) failed = ResultT!(Param)();
        return failed;
    }

    /*
    
Brackets
    ::= [  "[]"  Brackets];

    */
    public