Ignore:
Timestamp:
07/19/13 00:31:12 (6 years ago)
Author:
gkronber
Message:

#2026 changed ATG to Coco/R syntax and use Coco/R (C#) to generate scanner and parser for GPDL

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/HeuristicLab.Problems.GPDL/HeuristicLab.Problems.GPDL/3.4/GPDef.atg

    r9430 r9724  
     1$namespace=HeuristicLab.Problems.GPDL
     2
     3using System.Text;
     4using System.Collections.Generic;
     5using IEnumerableConstraintNode = System.Collections.Generic.IEnumerable<ConstraintNode>;
     6
    17COMPILER GPDef
    2 SEM <<
    38  static StringBuilder srcText;
    49  public static HeuristicLab.Optimization.IProblem problem;
    5 >>
    6 
    7 
    8 CHARACTER SETS
     10  static string lastSrc;
     11 
     12CHARACTERS
    913  letter = 'A'..'Z' + 'a'..'z'.
    1014  digit = '0'..'9'.
    11   whiteSpace = CHR(9) + EOL IGNORE. /* ' ' ignored by default */
     15
     16TOKENS
     17  ident = letter {letter | digit}  .
    1218
    1319COMMENTS
    14   FROM '/*' TO '*/' NESTED.
    15 
    16 KEYWORDS
    17   'PROBLEM'. 'END'. 'EPS'.
    18   'LOCAL'. 'NONTERMINALS'. 'RULES'.
    19   'SEM'. 'MAXIMIZE'. 'MINIMIZE'. 'TERMINALS'. 'CONSTRAINTS'. 'INIT'. 'MUTATE'. 'CODE'.
    20   'IN'. 'SET'. 'RANGE'.
    21 
    22 TOKENS
    23   '='. '|'. '.'. '('. ')'. '['. ']'. '{'. '}'. '..'.
    24 
    25 TOKEN CLASSES
    26   ident<<out string identStr>> =
    27     letter {letter | digit}        LEX << identStr = tokenStr; >>
    28   .
    29 
    30 PRAGMAS
    31   source       = '<<' SEM << GPDefSem.srcText = new StringBuilder();
    32                              for (; ; ) {
    33                               switch (GPDefLex.curCh) {
    34                                 case Utils.EF:
    35                                   Errors.SemError(GPDefLex.curLine, GPDefLex.curCol, "end of file in source text");
    36                                   return;
    37                                 case '<':
    38                                   GPDefLex.NextCh();
    39                                   if (GPDefLex.curCh == '<') {
    40                                     GPDefSem.srcText.Append('<');
    41                                     Errors.Warning(GPDefLex.curLine, GPDefLex.curCol, "non closed source text before?");
    42                                     GPDefLex.NextCh();
    43                                   }
    44                                   GPDefSem.srcText.Append('<');
    45                                   break;
    46                                 case '>':
    47                                   GPDefLex.NextCh();
    48                                   if (GPDefLex.curCh == '>') {
    49                                     GPDefLex.curCh = ' ';          // force GPDefLex to get next character
    50                                     SourceReader.Handle(GPDefSem.srcText.ToString());
    51                                     return;
    52                                   }
    53                                   GPDefSem.srcText.Append('>');
    54                                   break;
    55                                 default:
    56                                   GPDefSem.srcText.Append(GPDefLex.curCh);
    57                                   GPDefLex.NextCh();
    58                                   break;
    59                               }
    60                             }
    61                             >> .
    62 NONTERMINALS
    63   GPDef.
    64   NonterminalDecl<<out NonTerminalNode ntNode>>.
    65   TerminalDecl<<out TerminalNode tNode>>.
    66   RuleDef<<out RuleNode rNode>>.
    67   SynExpr<<out RuleExprNode expr>>.
    68   SynTerm<<out RuleExprNode expr>>.
    69   SynFact<<out RuleExprNode expr>>.
    70   SemAction<<out RuleActionNode action>>.
    71   ConstraintDef<<out IEnumerable<ConstraintNode> constraints>>.
    72   ConstraintRule<<out ConstraintNode constraint>>.
    73   SetDefinition<<ConstraintNode constraint>>.
    74 
    75 RULES
    76   GPDef =                                                                         LOCAL <<
     20  FROM "/*" TO "*/" NESTED
     21
     22IGNORE '\t' + '\r' + '\n'
     23
     24
     25PRODUCTIONS
     26
     27  SourceCode<out string src> =                                                    (. src = ""; .)
     28   "<<"                                                                           (. int beg = la.pos; .)
     29   {ANY}                                                                          (. int end = la.pos; .)
     30   ">>"                                                                           (. if(end>beg) src = scanner.buffer.GetString(beg, end); .)
     31  .
     32
     33  GPDef =                                                                         (.
    7734                                                                                    string identStr = "";
    7835                                                                                    RuleNode ruleNode = null;
     
    8239                                                                                    TerminalNode tNode = null;
    8340                                                                                    problem = null;
    84                                                                                   >>
    85     'PROBLEM' ident<<out identStr>>                                               SEM << gpDef.Name = identStr; >>
    86     ['CODE' /* SourceText */                                                      SEM << SourceReader.WithNext((src) => gpDef.ClassCodeNode = new CodeNode{SrcCode = src});  >>
     41                                                                                    string src = "";
     42                                                                                  .)
     43    "PROBLEM" ident                                                               (. gpDef.Name = t.val; .)
     44    ["CODE" SourceCode<out src>                                                   (. gpDef.ClassCodeNode = new CodeNode{SrcCode = src}; .)
    8745    ]
    88     ['INIT' /* SourceText */                                                      SEM << SourceReader.WithNext((src) => gpDef.InitCodeNode = new CodeNode{SrcCode = src});  >>
     46    ["INIT" SourceCode<out src>                                                   (. gpDef.InitCodeNode = new CodeNode{SrcCode = src}; .)
    8947    ]
    9048
    91     'NONTERMINALS' { NonterminalDecl<<out ntNode>>                                SEM << gpDef.NonTerminals.Add(ntNode); >>
    92     }
    93     'TERMINALS' { TerminalDecl<<out tNode>>                                       SEM << gpDef.Terminals.Add(tNode); >>
    94     }
    95     'RULES' { RuleDef<<out ruleNode>>                                                SEM << gpDef.Rules.Add(ruleNode); >>
    96     }
    97                                                                                   SEM << fitnessFunNode = new FitnessFunctionNode();
     49    "NONTERMINALS" { NonterminalDecl<out ntNode>                                  (. gpDef.NonTerminals.Add(ntNode); .)
     50    }
     51    "TERMINALS" { TerminalDecl<out tNode>                                         (. gpDef.Terminals.Add(tNode); .)
     52    }
     53    "RULES" { RuleDef<out ruleNode>                                               (. gpDef.Rules.Add(ruleNode); .)
     54    }
     55                                                                                  (. fitnessFunNode = new FitnessFunctionNode();
    9856                                                                                         gpDef.FitnessFunctionNode = fitnessFunNode;
    99                                                                                   >>
    100     ('MAXIMIZE'                                                                   SEM << fitnessFunNode.Maximization = true; >>
    101     | 'MINIMIZE'                                                                  SEM << fitnessFunNode.Maximization = false; >>
     57                                                                                  .)
     58    ("MAXIMIZE"                                                                   (. fitnessFunNode.Maximization = true; .)
     59    | "MINIMIZE"                                                                  (. fitnessFunNode.Maximization = false; .)
    10260    )
    103      /* SourceText */                                                             SEM << SourceReader.WithNext((src) => fitnessFunNode.SrcCode = src);  >>
    104     'END' ident<<out identStr>> '.'                                               SEM <<
    105                                                                                     SourceReader.Handle(GPDefSem.srcText.ToString()); // flush the source reader
     61     SourceCode<out src>                                                          (. fitnessFunNode.SrcCode = src; .)
     62    "END" ident                                                                   (.
     63                                                                                    // SourceReader.Handle(GPDefSem.srcText.ToString()); // flush the source reader
    10664                                                                                    var gen = new ProblemGenerator();
    10765                                                                                    problem = gen.GenerateFromAst(gpDef);
    108                                                                                   >>
    109   .
    110 
    111 
    112   /******************************************************/
    113   SemAction<<out RuleActionNode action>> =                                        LOCAL << RuleActionNode myAction = null; action = null; >>
    114     'SEM' /* SourceText */                                                        SEM <<
     66                                                                                  .)
     67    '.'
     68  .
     69
     70
     71  /******************************************************/
     72  SemAction<out RuleActionNode action> =                                          (. RuleActionNode myAction = null; action = null; string src = ""; .)
     73    "SEM" SourceCode<out src>                                                     (.
    11574                                                                                    myAction = new RuleActionNode();
    116                                                                                     SourceReader.WithNext((src) => {myAction.SrcCode = src;});
     75                                                                                    myAction.SrcCode = src;
    11776                                                                                    action = myAction;
    118                                                                                   >>
    119   .
    120 
    121   /******************************************************/
    122   NonterminalDecl<<out NonTerminalNode ntNode>> =                                 LOCAL << string identStr = ""; ntNode = null;>>
    123     ident<<out identStr>> /* FormalAttrList */                                    SEM <<
     77                                                                                  .)
     78  .
     79
     80  /******************************************************/
     81  NonterminalDecl<out NonTerminalNode ntNode> =                                   (. string identStr = ""; ntNode = null; string src = ""; .)
     82    ident                                                                         (. identStr = t.val; .)
     83    SourceCode<out src>                                                           (.
    12484                                                                                    var myNtNode = new NonTerminalNode();
    12585                                                                                    ntNode = myNtNode;
    12686                                                                                    myNtNode.Ident = identStr;
    127                                                                                     SourceReader.WithNext((src) => {myNtNode.FormalParameters = src;});
    128                                                                                   >>
     87                                                                                    myNtNode.FormalParameters = src;
     88                                                                                  .)
    12989    '.'
    13090  .
    13191
    13292  /******************************************************/
    133   TerminalDecl<<out TerminalNode tNode>> =                                        LOCAL <<
     93  TerminalDecl<out TerminalNode tNode> =                                          (.
    13494                                                                                    string identStr = "";
    13595                                                                                    tNode = null;
    13696                                                                                    TerminalNode myTNode = null;
    137                                                                                     IEnumerable<ConstraintNode> constraints = null;
    138                                                                                   >>
    139   ident<<out identStr>> /* FormalAttrList */                                      SEM <<
     97                                                                                    IEnumerableConstraintNode constraints = null;
     98                                                                                    string src = "";
     99                                                                                  .)
     100  ident                                                                           (. identStr = t.val; .)
     101  SourceCode<out src>                                                             (.
    140102                                                                                         myTNode = new TerminalNode();
    141103                                                                                         tNode = myTNode;
    142104                                                                                         myTNode.Ident = identStr;
    143                                                                                          SourceReader.WithNext((src) => {
    144                                                                                            myTNode.FormalParameters = src;
    145                                                                                            myTNode.FieldDefinitions = SourceReader.ExtractFormalParameters(src);
    146                                                                                          });
    147 
    148                                                                                   >>
    149   [ 'CONSTRAINTS' ConstraintDef<<out constraints>>                                SEM << myTNode.Constraints = constraints; >>
     105                                                                                         myTNode.FormalParameters = src;
     106                                                                                         myTNode.FieldDefinitions = SourceReader.ExtractFormalParameters(src);
     107                                                                                  .)
     108  [ "CONSTRAINTS" ConstraintDef<out constraints>                                  (. myTNode.Constraints = constraints; .)
    150109  ]
    151110  '.'
     
    154113
    155114  /******************************************************/
    156   ConstraintDef<<out IEnumerable<ConstraintNode> constraints>>  =             LOCAL <<
     115  ConstraintDef<out IEnumerableConstraintNode constraints>  =                   (.
    157116                                                                                    List<ConstraintNode> constraintsList = new List<ConstraintNode>();
    158117                                                                                    ConstraintNode n = null;
    159118                                                                                    constraints = null;
    160                                                                                   >>
    161     { ConstraintRule<<out n>>                                                     SEM << constraintsList.Add(n); >>
    162     }
    163                                                                                   SEM << constraints = constraintsList; >>
    164   .
    165 
    166   /******************************************************/
    167   ConstraintRule<<out ConstraintNode constraint>> =                               LOCAL <<
     119                                                                                  .)
     120    { ConstraintRule<out n>                                                       (. constraintsList.Add(n); .)
     121    }
     122                                                                                  (. constraints = constraintsList; .)
     123  .
     124
     125  /******************************************************/
     126  ConstraintRule<out ConstraintNode constraint> =                                 (.
    168127                                                                                    string identStr = null;
    169128                                                                                    constraint = null;
    170                                                                                   >>
    171     ident<<out identStr>>                                                         SEM << constraint = new ConstraintNode(identStr); >>
    172     'IN' SetDefinition<<constraint>>                                              SEM << SourceReader.Handle(GPDefSem.srcText.ToString()); // flush the source reader  >>
    173   .
    174 
    175   /******************************************************/
    176   SetDefinition<<ConstraintNode constraint>> =
    177     'SET'                                                                        SEM << constraint.Type = ConstraintNodeType.Set; >>
    178     /* SourceText */                                                              SEM << SourceReader.WithNext((src) => {constraint.SetExpression = src;}); >>
    179     |
    180     'RANGE'                                                                       SEM << constraint.Type = ConstraintNodeType.Range; >>
    181     /* SourceText */                                                              SEM << SourceReader.WithNext((src) => {constraint.RangeMinExpression = src;}); >>
    182     '..' /* SourceText */                                                         SEM << SourceReader.Handle(GPDefSem.srcText.ToString()); // flush the source reader
    183                                                                                          SourceReader.WithNext((src) => {constraint.RangeMaxExpression = src;}); >>   
    184   .
    185 
    186   /******************************************************/
    187   RuleDef<<out RuleNode rule>> =                                                  LOCAL <<
     129                                                                                  .)
     130    ident                                                                         (. constraint = new ConstraintNode(t.val); .)
     131    "IN" SetDefinition<constraint>                                                // (. SourceReader.Handle(GPDefSem.srcText.ToString()); .) // flush the source reader
     132  .
     133
     134  /******************************************************/
     135  SetDefinition<ConstraintNode constraint> =                                      (. string src = ""; .)
     136    ("SET"                                                                        (. constraint.Type = ConstraintNodeType.Set; .)
     137     SourceCode<out src>                                                          (. constraint.SetExpression = src; .)
     138     |
     139     "RANGE"                                                                      (. constraint.Type = ConstraintNodeType.Range; .)
     140     SourceCode<out src>                                                          (. constraint.RangeMinExpression = src; .)
     141     ".." SourceCode<out src>                                                     (. // SourceReader.Handle(GPDefSem.srcText.ToString()); // flush the source reader
     142                                                                                    constraint.RangeMaxExpression = src; .)
     143    )
     144  .
     145
     146  /******************************************************/
     147  RuleDef<out RuleNode rule> =                                                    (.
    188148                                                                                    RuleExprNode expr = null;
    189149                                                                                    string identStr = null;
    190150                                                                                    RuleNode myRule = null;
    191151                                                                                    rule = null;
    192                                                                                   >>
    193   ident<<out identStr>> /* FormalAttrList */ '='                                  SEM <<
     152                                                                                   string src = "";
     153                                                                                  .)
     154  ident                                                                           (. identStr = t.val; .)
     155  SourceCode<out src> '='                                                         (.
    194156                                                                                      myRule = new RuleNode();
    195157                                                                                      rule = myRule;
    196158                                                                                      myRule.NtSymbol = identStr;
    197                                                                                   >>
    198   ['LOCAL' /* SourceText */                                                       SEM <<
    199                                                                                     SourceReader.WithNext((src) => {myRule.LocalCode = src;});
    200                                                                                   >>
     159                                                                                  .)
     160  ["LOCAL" SourceCode<out src>                                                    (.
     161                                                                                    myRule.LocalCode = src;
     162                                                                                  .)
    201163  ]
    202   SynExpr<<out expr>> '.'                                                        SEM <<
     164  SynExpr<out expr> '.'                                                          (.
    203165                                                                                    myRule.RuleExpr = expr;
    204                                                                                  >>
    205   .
    206 
    207   /******************************************************/
    208   SynExpr<<out RuleExprNode expr >> =                                             LOCAL <<
     166                                                                                 .)
     167  .
     168
     169  /******************************************************/
     170  SynExpr<out RuleExprNode expr > =                                               (.
    209171                                                                                    expr = null;
    210172                                                                                    AlternativesNode alt = null;
    211                                                                                   >>
    212   SynTerm<<out expr>>                                                             SEM <<
     173                                                                                  .)
     174  SynTerm<out expr>                                                               (.
    213175                                                                                    alt = new AlternativesNode();
    214176                                                                                    alt.Add(expr);
    215                                                                                    >>
     177                                                                                  .)
    216178  {
    217     '|' SynTerm<<out expr>>                                                       SEM << alt.Add(expr); expr = alt; >>
     179    '|' SynTerm<out expr>                                                         (. alt.Add(expr); expr = alt; .)
    218180  }
    219181  .
    220182
    221183  /******************************************************/
    222   SynTerm<<out RuleExprNode expr>> =                                             LOCAL << SequenceNode seq = null; expr = null; >>
    223   SynFact<<out expr>>                                                            SEM <<
     184  SynTerm<out RuleExprNode expr> =                                               (. SequenceNode seq = null; expr = null; .)
     185  SynFact<out expr>                                                              (.
    224186                                                                                   seq = new SequenceNode();
    225187                                                                                   seq.Add(expr);
    226                                                                                  >>
     188                                                                                 .)
    227189  {
    228     SynFact<<out expr>>                                                          SEM << seq.Add(expr); expr = seq; >>
     190    SynFact<out expr>                                                            (. seq.Add(expr); expr = seq; .)
    229191  }
    230192  .
    231193
    232194  /******************************************************/
    233   SynFact<<out RuleExprNode expr>> =                                             LOCAL <<
     195  SynFact<out RuleExprNode expr> =                                               (.
    234196                                                                                   string identStr = "";
    235197                                                                                   RuleActionNode action = null;
    236198                                                                                   expr = null;
    237                                                                                  >>
    238     ident<<out identStr>> /* ActualAttrList */                                   SEM <<
     199                                                                                   string src = "";
     200                                                                                 .)
     201    (ident                                                                        (. identStr = t.val; .)
     202     SourceCode<out src>                                                          (.
    239203                                                                                    var callNode = new CallSymbolNode{Ident = identStr};
    240                                                                                     SourceReader.WithNext((src) => {callNode.ActualParameter = src;});
     204                                                                                    callNode.ActualParameter = src;
    241205                                                                                    expr = callNode;
    242                                                                                   >>
    243 --    | 'EPS'
    244 --    | '(' SynExpr<<ref rules, mBuilder>> ')'
    245 --    | '[' SynExpr<<ref rules, mBuilder>> ']'
    246 --    | '{' SynExpr<<ref rules, mBuilder>> '}'
    247     | SemAction<<out action>>                                                    SEM << expr = action; >>
     206                                                                                 .)
     207// not implemented   | "EPS"
     208// not implemented   | '(' SynExpr<ref rules, mBuilder> ')'
     209// not implemented   | '[' SynExpr<ref rules, mBuilder> ']'
     210// not implemented   | '{' SynExpr<ref rules, mBuilder> '}'
     211     | SemAction<out action>                                                      (. expr = action; .)
     212    )
    248213  .
    249214
Note: See TracChangeset for help on using the changeset viewer.