Changeset 231

Show
Ignore:
Timestamp:
08/04/06 10:28:21 (2 years ago)
Author:
pragma
Message:

Updated for Unicode support, parser library, plus BCS' patches and reccomenations.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/enki/BaseParser.d

    r203 r231  
    3636private import std.stdio; 
    3737private import std.regexp; 
     38private import std.utf; 
    3839 
    3940alias ResultT!(bool) ResultBool; 
    …… 
    7172         
    7273    /** error handling **/ 
    73     protected void setError(char[] text){ 
     74    protected void setError(String text){ 
    7475        debug writefln("[%d] Error: %s",pos,text); 
    7576        ErrorData data; 
    …… 
    7980    } 
    8081     
    81     protected void setError(char[] text,int pos){ 
     82    protected void setError(String text,int pos){ 
    8283        ErrorData data; 
    8384        data.pos = pos; 
    …… 
    101102                } 
    102103            } 
    103             result ~= std.string.format("(%d,%d) %s\n",line,err.pos-startOfLine+1,err.text); 
     104            result ~= transcodeToString(std.string.format("(%d,%d) %s\n",line,err.pos-startOfLine+1,err.text)); 
    104105        } 
    105106        return result; 
    …… 
    123124    } 
    124125         
    125     public ResultString terminal(ubyte start){ 
    126         if(pos >= data.length || data[pos] != cast(char)start){ 
     126    public ResultString terminal(uint ch){ 
     127        if(pos >= data.length || data[pos] != cast(dchar)ch){ 
    127128            //TODO: find an error message for this 
    128129            //setError("Expected char"); 
    …… 
    134135     
    135136    public ResultString regexp(String str){ 
     137        assert(false,"Regular Expressions are not supported."); 
     138        /* 
    136139        if (auto m = std.regexp.search(data[pos..$],str)) 
    137140        { 
    …… 
    142145            } 
    143146        } 
    144         return ResultString(); 
     147        return ResultString();*/ 
    145148    } 
    146149     
    147150    public ResultString range(uint start,uint end){ 
    148         assert(false,"32bit/dchar ranges not supported"); 
    149     } 
    150      
    151     public ResultString range(short start,short end){ 
    152         assert(false,"16bit/wchar ranges not supported"); 
    153     } 
    154      
    155     public ResultString range(ubyte start,ubyte end){ 
    156         if(pos >= data.length || !(data[pos] >= cast(char)start && data[pos] <= cast(char)end)){ 
     151        if(pos >= data.length || !(data[pos] >= cast(dchar)start && data[pos] <= cast(dchar)end)){ 
    157152            //TODO: find an error message for this 
    158153            //setError("Expected range"); 
    …… 
    160155        } 
    161156        pos++; 
    162         return ResultString(data[pos-1..pos]);   
     157        return ResultString(data[pos-1..pos]);      
    163158    } 
    164159     
    …… 
    291286     
    292287    public ResultBool parse_err(){ 
    293         throw new Exception(getErrorReport()); 
     288        throw new Exception(toUTF8(getErrorReport())); 
    294289        return ResultBool(false); 
    295290    } 

  • trunk/enki/CodeGenerator.d

    r203 r231  
    5353     
    5454    public void render(CodeGenerator generator,Statement passterm,Statement failterm){ 
     55        generator.emit("{/*do nothing*/}"); // statisfy presence of statment for labels 
    5556    } 
    5657     
    …… 
    7071     
    7172    public void render(CodeGenerator generator,Statement passterm,Statement failterm){ 
    72         generator.emit(name ~ ": ;"); 
     73        generator.emit(name ~ ":"); 
    7374    } 
    7475} 

  • trunk/enki/Directive.d

    r203 r231  
    11/+ 
    2     Copyright (c) 2006 Eric Anderton 
     2    Copyright (c) 2006 Eric Anderton, BCS 
    33 
    44    Permission is hereby granted, free of charge, to any person 
    …… 
    3838    public String toBNF(){ 
    3939        // do nothing 
     40        return ""; 
    4041    } 
    4142     
    4243    public String toString(){ 
    4344        // do nothing 
     45        return ""; 
    4446    } 
    4547 

  • trunk/enki/EnkiParser.d

    r203 r231  
    1111 
    1212/+ 
    13     Copyright (c) 2006 Eric Anderton 
     13    Copyright (c) 2006 Eric Anderton, BCS 
    1414 
    1515    Permission is hereby granted, free of charge, to any person 
    …… 
    4343    public ResultT!(String) parse_Syntax(){ 
    4444        debug writefln("parse_Syntax()"); 
    45         uint start = position; 
     45        uint start1 = position; 
    4646        SyntaxLine[] bind_lines; 
    4747         
    4848         
    4949        {//Expression 
    50             uint start = position; 
     50            uint start2 = position; 
    5151            if(!(parse_ws().success)){ 
    5252                goto mismatch4; 
    5353            } 
    5454            {//ZeroOrMoreExpr 
    55                 uint start = position; 
     55                uint start3 = position; 
    5656                uint termPos; 
    57             loop5: ; 
     57            loop5: 
    5858                termPos = position; 
    5959                if(parse_eoi().success){ 
    …… 
    6161                } 
    6262                {//Expression 
    63                     uint start = position; 
     63                    uint start4 = position; 
    6464                    {//Expression 
    65                         uint start = position; 
     65                        uint start5 = position; 
    6666                        if((parse_Rule().assignCat!(SyntaxLine[])(bind_lines)) || (parse_Comment().assignCat!(SyntaxLine[])(bind_lines)) || (parse_Directive().assignCat!(SyntaxLine[])(bind_lines))){ 
    6767                            clearErrors(); 
    6868                        }else{ 
    6969                            setError("Expected Rule, Comment or Directive."); 
    70                             position = start; 
     70                            position = start5; 
    7171                            goto mismatch8; 
    7272                        } 
    …… 
    7676                    } 
    7777                    goto match7; 
    78                 mismatch8: ; 
    79                     position = start; 
     78                mismatch8: 
     79                    {/*do nothing*/} 
     80                    position = start4; 
    8081                    goto mismatch4; 
    81                 match7: ; 
     82                match7: 
    8283                    clearErrors(); 
    8384                    goto loop5; 
    8485                } 
    85             loopend6: ; 
     86            loopend6: 
     87                {/*do nothing*/} 
    8688            } 
    8789            goto match3; 
    88         mismatch4: ; 
     90        mismatch4: 
    8991            setError("Expected Whitespace."); 
    90             position = start; 
     92            position = start2; 
    9193            goto mismatch2; 
    92         match3: ; 
     94        match3: 
    9395            clearErrors(); 
    9496            goto match1; 
    9597        } 
    96     match1: ; 
     98    match1: 
    9799        debug writefln("parse_Syntax() PASS"); 
    98100        createSyntax(bind_lines); 
    99         return ResultT!(String)(sliceData(start,position)); 
    100     mismatch2: ; 
    101         position = start; 
     101        return ResultT!(String)(sliceData(start1,position)); 
     102    mismatch2: 
     103        position = start1; 
    102104        return ResultT!(String)(); 
    103105    } 
    …… 
    112114    public ResultT!(Rule) parse_Rule(){ 
    113115        debug writefln("parse_Rule()"); 
    114         uint start = position; 
     116        uint start6 = position; 
    115117        String bind_name; 
    116118        RulePredicate bind_pred; 
    …… 
    120122         
    121123        {//Expression 
    122             uint start = position; 
     124            uint start7 = position; 
    123125            if(!(parse_ws().success)){ 
    124126                goto mismatch12; 
    …… 
    132134            {//OptionalExpr 
    133135                {//Expression 
    134                     uint start = position; 
     136                    uint start9 = position; 
    135137                    if((parse_RuleDecl().assign!(RuleDecl)(bind_decl) && parse_ws().success)){ 
    136138                        clearErrors(); 
    137139                    }else{ 
    138                         position = start; 
     140                        position = start9; 
    139141                    } 
    140142                } 
    …… 
    142144            {//OptionalExpr 
    143145                {//Expression 
    144                     uint start = position; 
     146                    uint start11 = position; 
    145147                    if((parse_RulePredicate().assign!(RulePredicate)(bind_pred))){ 
    146148                        clearErrors(); 
    147149                    }else{ 
    148                         position = start; 
     150                        position = start11; 
    149151                    } 
    150152                } 
    …… 
    169171            } 
    170172            goto match11; 
    171         mismatch12: ; 
     173        mismatch12: 
    172174            setError("Expected Whitespace."); 
    173             position = start; 
     175            position = start7; 
    174176            goto mismatch10; 
    175         match11: ; 
     177        match11: 
    176178            clearErrors(); 
    177179            goto match9; 
    178180        } 
    179     match9: ; 
     181    match9: 
    180182        debug writefln("parse_Rule() PASS"); 
    181183        ResultT!(Rule) passed = ResultT!(Rule)(new Rule(bind_name,bind_pred,bind_expr,bind_decl)); 
    182184        return passed; 
    183     mismatch10: ; 
    184         position = start; 
     185    mismatch10: 
     186        position = start6; 
    185187        ResultT!(Rule) failed = ResultT!(Rule)(); 
    186188        return failed; 
    …… 
    196198    public ResultT!(RuleDecl) parse_RuleDecl(){ 
    197199        debug writefln("parse_RuleDecl()"); 
    198         uint start = position; 
     200        uint start12 = position; 
    199201        Param[] bind_params; 
    200202         
    201203         
    202204        {//Expression 
    203             uint start = position; 
     205            uint start13 = position; 
    204206            if((parse_ParamsExpr().assign!(Param[])(bind_params))){ 
    205207                clearErrors(); 
    …… 
    207209            }else{ 
    208210                setError("Expected ParamsExpr."); 
    209                 position = start; 
     211                position = start13; 
    210212                goto mismatch14; 
    211213            } 
    212214        } 
    213     match13: ; 
     215    match13: 
    214216        debug writefln("parse_RuleDecl() PASS"); 
    215217        ResultT!(RuleDecl) passed = ResultT!(RuleDecl)(new RuleDecl(bind_params)); 
    216218        return passed; 
    217     mismatch14: ; 
    218         position = start; 
     219    mismatch14: 
     220        position = start12; 
    219221        ResultT!(RuleDecl) failed = ResultT!(RuleDecl)(); 
    220222        return failed; 
    …… 
    230232    public ResultT!(RulePredicate) parse_RulePredicate(){ 
    231233        debug writefln("parse_RulePredicate()"); 
    232         uint start = position; 
     234        uint start14 = position; 
    233235        RulePredicate bind_pred; 
    234236         
    235237         
    236238        {//Expression 
    237             uint start = position; 
     239            uint start15 = position; 
    238240            if(!(terminal("=").success)){ 
    239241                goto mismatch18; 
    …… 
    243245            } 
    244246            {//Expression 
    245                 uint start = position; 
     247                uint start16 = position; 
    246248                if((parse_ClassPredicate().assign!(RulePredicate)(bind_pred)) || (parse_FunctionPredicate().assign!(RulePredicate)(bind_pred)) || (parse_BindingPredicate().assign!(RulePredicate)(bind_pred))){ 
    247249                    clearErrors(); 
    248250                }else{ 
    249251                    setError("Expected ClassPredicate, FunctionPredicate or BindingPredicate."); 
    250                     position = start; 
     252                    position = start16; 
    251253                    goto mismatch18; 
    252254                } 
    253255            } 
    254256            goto match17; 
    255         mismatch18: ; 
    256             position = start; 
     257        mismatch18: 
     258            {/*do nothing*/} 
     259            position = start15; 
    257260            goto mismatch16; 
    258         match17: ; 
     261        match17: 
    259262            clearErrors(); 
    260263            goto match15; 
    261264        } 
    262     match15: ; 
     265    match15: 
    263266        debug writefln("parse_RulePredicate() PASS"); 
    264267        return ResultT!(RulePredicate)(bind_pred); 
    265     mismatch16: ; 
    266         position = start; 
     268    mismatch16: 
     269        position = start14; 
    267270        return ResultT!(RulePredicate)(); 
    268271    } 
    …… 
    277280    public ResultT!(ClassPredicate) parse_ClassPredicate(){ 
    278281        debug writefln("parse_ClassPredicate()"); 
    279         uint start = position; 
     282        uint start17 = position; 
    280283        String bind_name; 
    281284        Param[] bind_params; 
    …… 
    283286         
    284287        {//Expression 
    285             uint start = position; 
     288            uint start18 = position; 
    286289            if((terminal("new").success && parse_ws().success && parse_Identifier().assign!(String)(bind_name) && parse_ws().success && parse_ParamsExpr().assign!(Param[])(bind_params))){ 
    287290                clearErrors(); 
    288291                goto match19; 
    289292            }else{ 
    290                 position = start; 
     293                position = start18; 
    291294                goto mismatch20; 
    292295            } 
    293296        } 
    294     match19: ; 
     297    match19: 
    295298        debug writefln("parse_ClassPredicate() PASS"); 
    296299        ResultT!(ClassPredicate) passed = ResultT!(ClassPredicate)(new ClassPredicate(bind_name,bind_params)); 
    297300        return passed; 
    298     mismatch20: ; 
    299         position = start; 
     301    mismatch20: 
     302        position = start17; 
    300303        ResultT!(ClassPredicate) failed = ResultT!(ClassPredicate)(); 
    301304        return failed; 
    …… 
    311314    public ResultT!(FunctionPredicate) parse_FunctionPredicate(){ 
    312315        debug writefln("parse_FunctionPredicate()"); 
    313         uint start = position; 
     316        uint start19 = position; 
    314317        Param bind_decl; 
    315318        Param[] bind_params; 
    …… 
    317320         
    318321        {//Expression 
    319             uint start = position; 
     322            uint start20 = position; 
    320323            if((parse_ExplicitParam().assign!(Param)(bind_decl) && parse_ws().success && parse_ParamsExpr().assign!(Param[])(bind_params))){ 
    321324                clearErrors(); 
    …… 
    323326            }else{ 
    324327                setError("Expected ExplicitParam."); 
    325                 position = start; 
     328                position = start20; 
    326329                goto mismatch22; 
    327330            } 
    328331        } 
    329     match21: ; 
     332    match21: 
    330333        debug writefln("parse_FunctionPredicate() PASS"); 
    331334        ResultT!(FunctionPredicate) passed = ResultT!(FunctionPredicate)(new FunctionPredicate(bind_decl,bind_params)); 
    332335        return passed; 
    333     mismatch22: ; 
    334         position = start; 
     336    mismatch22: 
     337        position = start19; 
    335338        ResultT!(FunctionPredicate) failed = ResultT!(FunctionPredicate)(); 
    336339        return failed; 
    …… 
    346349    public ResultT!(BindingPredicate) parse_BindingPredicate(){ 
    347350        debug writefln("parse_BindingPredicate()"); 
    348         uint start = position; 
     351        uint start21 = position; 
    349352        Param bind_param; 
    350353         
    351354         
    352355        {//Expression 
    353             uint start = position; 
     356            uint start22 = position; 
    354357            if((parse_Param().assign!(Param)(bind_param))){ 
    355358                clearErrors(); 
    …… 
    357360            }else{ 
    358361                setError("Expected Param."); 
    359                 position = start; 
     362                position = start22; 
    360363                goto mismatch24; 
    361364            } 
    362365        } 
    363     match23: ; 
     366    match23: 
    364367        debug writefln("parse_BindingPredicate() PASS"); 
    365368        ResultT!(BindingPredicate) passed = ResultT!(BindingPredicate)(new BindingPredicate(bind_param)); 
    366369        return passed; 
    367     mismatch24: ; 
    368         position = start; 
     370    mismatch24: 
     371        position = start21; 
    369372        ResultT!(BindingPredicate) failed = ResultT!(BindingPredicate)(); 
    370373        return failed; 
    …… 
    380383    public ResultT!(Param[]) parse_ParamsExpr(){ 
    381384        debug writefln("parse_ParamsExpr()"); 
    382         uint start = position; 
     385        uint start23 = position; 
    383386        Param[] bind_params; 
    384387         
    385388         
    386389        {//Expression 
    387             uint start = position; 
     390            uint start24 = position; 
    388391            if(!(terminal("(").success)){ 
    389392                goto mismatch28; 
    …… 
    394397            {//OptionalExpr 
    395398                {//Expression 
    396                     uint start = position; 
     399                    uint start26 = position; 
    397400                    if(!(parse_Param().assignCat!(Param[])(bind_params))){ 
    398401                        goto mismatch30; 
    …… 
    403406                    {//ZeroOrMoreExpr 
    404407                        uint termPos; 
    405                     loop31: ; 
     408                    loop31: 
    406409                        termPos = position; 
    407410                        {//Expression 
    408                             uint start = position; 
     411                            uint start28 = position; 
    409412                            if((terminal(",").success && parse_ws().success && parse_Param().assignCat!(Param[])(bind_params) && parse_ws().success)){ 
    410413                                clearErrors(); 
    411414                                goto loop31; 
    412415                            }else{ 
    413                                 position = start; 
     416                                position = start28; 
    414417                                goto loopend32; 
    415418                            } 
    416419                        } 
    417                     loopend32: ; 
     420                    loopend32: 
     421                        {/*do nothing*/} 
    418422                    } 
    419423                    goto match29; 
    420                 mismatch30: ; 
    421                     position = start; 
    422                 match29: ; 
     424                mismatch30: 
     425                    {/*do nothing*/} 
     426                    position = start26; 
     427                    {/*do nothing*/} 
     428                match29: 
    423429                    clearErrors(); 
     430                    {/*do nothing*/} 
    424431                } 
    425432            } 
    …… 
    428435            } 
    429436            goto match27; 
    430         mismatch28: ; 
    431             position = start; 
     437        mismatch28: 
     438            {/*do nothing*/} 
     439            position = start24; 
    432440            goto mismatch26; 
    433         match27: ; 
     441        match27: 
    434442            clearErrors(); 
    435443            goto match25; 
    436444        } 
    437     match25: ; 
     445    match25: 
    438446        debug writefln("parse_ParamsExpr() PASS"); 
    439447        return ResultT!(Param[])(bind_params); 
    440     mismatch26: ; 
    441         position = start; 
     448    mismatch26: 
     449        position = start23; 
    442450        return ResultT!(Param[])(); 
    443451    } 
    …… 
    452460    public ResultT!(Param) parse_Param(){ 
    453461        debug writefln("parse_Param()"); 
    454         uint start = position; 
     462        uint start29 = position; 
    455463        Param bind_param; 
    456464         
    457465         
    458466        {//Expression 
    459             uint start = position; 
     467            uint start30 = position; 
    460468            if((parse_ExplicitParam().assign!(Param)(bind_param)) || (parse_WeakParam().assign!(Param)(bind_param))){ 
    461469                clearErrors(); 
    …… 
    463471            }else{ 
    464472                setError("Expected ExplicitParam or WeakParam."); 
    465                 position = start; 
     473                position = start30; 
    466474                goto mismatch34; 
    467475            } 
    468476        } 
    469     match33: ; 
     477    match33: 
    470478        debug writefln("parse_Param() PASS"); 
    471479        return ResultT!(Param)(bind_param); 
    472     mismatch34: ; 
    473         position = start; 
     480    mismatch34: 
     481        position = start29; 
    474482        return ResultT!(Param)(); 
    475483    } 
    …… 
    484492    public ResultT!(Param) parse_WeakParam(){ 
    485493        debug writefln("parse_WeakParam()"); 
    486         uint start = position; 
     494        uint start31 = position; 
    487495        String bind_name; 
    488496         
    489497         
    490498        {//Expression 
    491             uint start = position; 
     499            uint start32 = position; 
    492500            if((parse_Identifier().assign!(String)(bind_name))){ 
    493501                clearErrors(); 
    …… 
    495503            }else{ 
    496504                setError("Expected Identifier."); 
    497                 position = start; 
     505                position = start32; 
    498506                goto mismatch36; 
    499507            } 
    500508        } 
    501     match35: ; 
     509    match35: 
    502510        debug writefln("parse_WeakParam() PASS"); 
    503511        ResultT!(Param) passed = ResultT!(Param)(new Param(bind_name)); 
    504512        return passed; 
    505     mismatch36: ; 
    506         position = start; 
     513    mismatch36: 
     514        position = start31; 
    507515        ResultT!(Param) failed = ResultT!(Param)(); 
    508516        return failed; 
    …… 
    513521ExplicitParam 
    514522    = new Param(bool isArray,String type,String name) 
    515     ::=  Identifier:type  ws [ "[]":isArray  ws]  Identifier:name ; 
     523    ::=  Identifier:type  ws [ "[]":isArray  Brackets ws]  Identifier:name ; 
    516524 
    517525    */ 
    518526    public ResultT!(Param) parse_ExplicitParam(){ 
    519527        debug writefln("parse_ExplicitParam()"); 
    520         uint start = position; 
     528        uint start33 = position; 
    521529        bool bind_isArray; 
    522530        String bind_type; 
    …… 
    525533         
    526534        {//Expression 
    527             uint start = position; 
     535            uint start34 = position; 
    528536            if(!(parse_Identifier().assign!(String)(bind_type))){ 
    529537                goto mismatch40; 
    …… 
    534542            {//OptionalExpr 
    535543                {//Expression 
    536                     uint start = position; 
    537                     if((terminal("[]").assign!(bool)(bind_isArray) && parse_ws().success)){ 
     544                    uint start36 = position; 
     545                    if((terminal("[]").assign!(bool)(bind_isArray) && parse_Brackets().success && parse_ws().success)){ 
    538546                        clearErrors(); 
    539547                    }else{ 
    540                         position = start; 
     548                        position = start36; 
    541549                    } 
    542550                } 
    …… 
    546554            } 
    547555            goto match39; 
    548         mismatch40: ; 
     556        mismatch40: 
    549557            setError("Expected Identifier."); 
    550             position = start; 
     558            position = start34; 
    551559            goto mismatch38; 
    552         match39: ; 
     560        match39: 
    553561            clearErrors(); 
    554562            goto match37; 
    555563        } 
    556     match37: ; 
     564    match37: 
    557565        debug writefln("parse_ExplicitParam() PASS"); 
    558566        ResultT!(Param) passed = ResultT!(Param)(new Param(bind_isArray,bind_type,bind_name)); 
    559567        return passed; 
    560     mismatch38: ; 
    561         position = start; 
     568    mismatch38: 
     569        position = start33; 
    562570        ResultT!(Param) failed = ResultT!(Param)(); 
    563571        return failed; 
     572    } 
     573 
     574    /* 
     575     
     576Brackets 
     577    ::=  [ "[]" Brackets] ; 
     578 
     579    */ 
     580    public ResultT!(bool) parse_Brackets(){ 
     581        debug writefln("parse_Brackets()"); 
     582        uint start37 = position; 
     583        //no declarations 
     584         
     585         
     586        {//Expression 
     587            uint start38 = position; 
     588            {//OptionalExpr 
     589                {//Expression 
     590                    uint start40 = position; 
     591                    if((terminal("[]").success && parse_Brackets().success)){ 
     592                        clearErrors(); 
     593                    }else{ 
     594                        position = start40; 
     595                    } 
     596                } 
     597            } 
     598            goto match43; 
     599        mismatch44: 
     600            {/*do nothing*/} 
     601            position = start38; 
     602            goto mismatch42; 
     603        match43: 
     604            clearErrors(); 
     605            goto match41; 
     606        } 
     607    match41: 
     608        debug writefln("parse_Brackets() PASS"); 
     609        return ResultT!(bool)(true); 
     610    mismatch42: 
     611        position = start37; 
     612        return ResultT!(bool)(); 
    564613    } 
    565614 
    …… 
    573622    public ResultT!(Expression) parse_Expression(){ 
    574623        debug writefln("parse_Expression()"); 
    575         uint start = position; 
     624        uint start41 = position; 
    576625        Term[] bind_terms; 
    577626         
    578627         
    579628        {//Expression 
    580             uint start = position; 
     629            uint start42 = position; 
    581630            if(!(parse_Term().assignCat!(Term[])(bind_terms))){ 
    582                 goto mismatch44; 
    583             } 
    584             if(!(parse_ws().success)){ 
    585                 goto mismatch44; 
     631                goto mismatch48; 
     632            } 
     633            if(!(parse_ws().success)){ 
     634                goto mismatch48; 
    586635            } 
    587636            {//ZeroOrMoreExpr 
    588637                uint termPos; 
    589             loop45: ; 
     638            loop49: 
    590639                termPos = position; 
    591640                {//Expression 
    592                     uint start = position; 
     641                    uint start44 = position; 
    593642                    if((terminal("|").success && parse_ws().success && parse_Term().assignCat!(Term[])(bind_terms) && parse_ws().success)){ 
    594643                        clearErrors(); 
    595                         goto loop45; 
     644                        goto loop49; 
    596645                    }else{ 
    597                         position = start; 
    598                         goto loopend46; 
    599                     } 
    600                 } 
    601             loopend46: ; 
    602             } 
    603             goto match43; 
    604         mismatch44: ; 
     646                        position = start44; 
     647                        goto loopend50; 
     648                    } 
     649                } 
     650            loopend50: 
     651                {/*do nothing*/} 
     652            } 
     653            goto match47; 
     654        mismatch48: 
    605655            setError("Expected Term."); 
    606             position = start; 
    607             goto mismatch42; 
    608         match43: ; 
    609             clearErrors(); 
    610             goto match41; 
    611         } 
    612     match41: ; 
     656            position = start42; 
     657            goto mismatch46; 
     658        match47: 
     659            clearErrors(); 
     660            goto match45; 
     661        } 
     662    match45: 
    613663        debug writefln("parse_Expression() PASS"); 
    614664        ResultT!(Expression) passed = ResultT!(Expression)(new Expression(bind_terms)); 
    615665        return passed; 
    616     mismatch42: ; 
    617         position = start; 
     666    mismatch46: 
     667        position = start41; 
    618668        ResultT!(Expression) failed = ResultT!(Expression)(); 
    619669        return failed; 
    …… 
    629679    public ResultT!(SubExpression[]) parse_Term(){ 
    630680        debug writefln("parse_Term()"); 
    631         uint start = position; 
     681        uint start45 = position; 
    632682        SubExpression[] bind_factors; 
    633683         
    634684         
    635685        {//Expression 
    636             uint start = position; 
     686            uint start46 = position; 
    637687            if(!(parse_SubExpression().assignCat!(SubExpression[])(bind_factors))){ 
    638                 goto mismatch50; 
    639             } 
    640             if(!(parse_ws().success)){ 
    641                 goto mismatch50; 
     688                goto mismatch54; 
     689            } 
     690            if(!(parse_ws().success)){ 
     691                goto mismatch54; 
    642692            } 
    643693            {//ZeroOrMoreExpr 
    644694                uint termPos; 
    645             loop51: ; 
     695            loop55: 
    646696                termPos = position; 
    647697                {//Expression 
    648                     uint start = position; 
     698                    uint start48 = position; 
    649699                    if((parse_SubExpression().assignCat!(SubExpression[])(bind_factors) && parse_ws().success)){ 
    650700                        clearErrors(); 
    651                         goto loop51; 
     701                        goto loop55; 
    652702                    }else{ 
    653703                        setError("Expected SubExpression."); 
    654                         position = start; 
    655                         goto loopend52; 
    656                     } 
    657                 } 
    658             loopend52: ; 
    659             } 
    660             goto match49; 
    661         mismatch50: ; 
     704                        position = start48; 
     705                        goto loopend56; 
     706                    } 
     707                } 
     708            loopend56: 
     709                {/*do nothing*/} 
     710            } 
     711            goto match53; 
     712        mismatch54: 
    662713            setError("Expected SubExpression."); 
    663             position = start; 
    664             goto mismatch48; 
    665         match49: ; 
    666             clearErrors(); 
    667             goto match47; 
    668         } 
    669     match47: ; 
     714            position = start46; 
     715            goto mismatch52; 
     716        match53: 
     717            clearErrors(); 
     718            goto match51; 
     719        } 
     720    match51: 
    670721        debug writefln("parse_Term() PASS"); 
    671722        return ResultT!(SubExpression[])(bind_factors); 
    672     mismatch48: ; 
    673         position = start; 
     723    mismatch52: 
     724        position = start45; 
    674725        return ResultT!(SubExpression[])(); 
    675726    } 
    …… 
    684735    public ResultT!(SubExpression) parse_SubExpression(){ 
    685736        debug writefln("parse_SubExpression()"); 
    686         uint start = position; 
     737        uint start49 = position; 
    687738        SubExpression bind_expr; 
    688739         
    689740         
    690741        {//Expression 
    691             uint start = position; 
     742            uint start50 = position; 
    692743            if((parse_Production().assign!(SubExpression)(bind_expr)) || (parse_Substitution().assign!(SubExpression)(bind_expr)) || (parse_Terminal().assign!(SubExpression)(bind_expr)) || (parse_Range().assign!(SubExpression)(bind_expr)) || (parse_Regexp().assign!(SubExpression)(bind_expr)) || (parse_GroupExpr().assign!(SubExpression)(bind_expr)) || (parse_OptionalExpr().assign!(SubExpression)(bind_expr)) || (parse_ZeroOrMoreExpr().assign!(SubExpression)(bind_expr)) || (parse_NegateExpr().assign!(SubExpression)(bind_expr)) || (parse_TestExpr().assign!(SubExpression)(bind_expr)) || (parse_LiteralExpr().assign!(SubExpression)(bind_expr)) || (parse_CustomTerminal().assign!(SubExpression)(bind_expr))){ 
    693744                clearErrors(); 
    694                 goto match53; 
     745                goto match57; 
    695746            }else{ 
    696747