Ignore:
Timestamp:
Aug 3, 2011, 2:17:28 AM (8 years ago)
Author:
shermer
Message:

v0.6.4

wide-ranging changes to more-fully implement structures and their fields:

Symbol tables now are constructed at nodes with scopes.
Symbol tables are used to collect the field information for structs.
StructAnalyzer? now visits struct children in the visitor, and it also checks struct.field expressions for validity.

Parser will now parse "new<struct> instance" statements and construct proper AST for struct.field expressions (called "compoundIdentifier").

Added a rudimentary StructInstanceType? to handle structure instances.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/src/parser/Pebble.g

    r1248 r1261  
    147147                                                 $secondTree = $a.secondTree; }
    148148        | e=expandStatement {$asTree = $e.asTree;}
    149         ;
    150        
     149        | n=newStatement        {$asTree = $n.asTree;}
     150        ;
     151
     152newStatement returns [AST asTree]
     153        :       'new' '<' type=Identifier '>' name=Identifier {
     154                        $asTree = new DeclarationASTN();
     155                        $asTree.addChild(VariableASTB.make($name.text));
     156                        $asTree.setType(new StructInstanceType($type.text));
     157                }
     158        ;
    151159expandStatement returns [AST asTree]
    152160        :       'expand' i=Identifier {
     
    228236       
    229237assignTarget returns [AST decl, AST variable;]
    230         : t=variableType? i=Identifier {
    231                         if(t!=null) {
    232                                 $decl = new DeclarationASTN();
    233                                 $decl.setType($t.type);
    234                                 $decl.addChild( VariableASTB.make($i.text) );
    235                         }
    236                         else {
    237                                 $decl = null;
    238                         }
     238        : t=variableType i=Identifier {
     239                        $decl = new DeclarationASTN();
     240                        $decl.setType($t.type);
     241                        $decl.addChild( VariableASTB.make($i.text) );
     242
    239243                        $variable = VariableASTB.make($i.text);
     244                }
     245        | c=compoundVariable {
     246                        $decl = null;
     247                        $variable = $c.asTree;
     248                }
     249        ;
     250       
     251        // wrong associativity, but it doesn't (currently) nest so there's no problem.
     252compoundVariable returns [AST asTree]
     253        : s=Identifier ('.' f=Identifier)? {
     254                        $asTree = VariableASTB.make($s.text);
     255                        if($f!=null) {
     256                                AST field = VariableASTB.make($f.text);
     257                                $asTree = StructFieldASTB.make($asTree, field);
     258                        }
    240259                }
    241260        ;
     
    432451                        }
    433452      }
    434     | i = Identifier {
    435                         $asTree = VariableASTB.make($i.text);
    436       }
     453    | v = compoundVariable {
     454                        $asTree = $v.asTree;
     455        }
     456//    | i = Identifier {
     457//                      $asTree = VariableASTB.make($i.text);
     458//      }
    437459    | n = IntegerConstant {
    438460                int value = Integer.parseInt($n.text);
     
    483505                        seqData.add(SequenceTokenData.singleCharacterClassData((char)(util.StringUtils.escapeValue($esc.text))));
    484506                     }
    485 //                |  dot = ColonedIdentifier {
    486 //                              // System.out.println("seq dotted: " + $dot.text);
    487 //                      seqData.add(trimDots($dot.text));
     507//                |  col = ColonedIdentifier {
     508//                              // System.out.println("seq coloned: " + $col.text);
     509//                      seqData.add(trimColons($col.text));
    488510//                       }
    489511                  |  cc = CharClassFrag {
     
    521543                          }
    522544//                      | col=ColonedIdentifier {
    523 //                              // System.out.println("CC dot: " + $dot.text);
     545//                              // System.out.println("CC colon: " + $col.text);
    524546//                              charClassData.addStream(trimDots($col.text));
    525547//                        }
     
    543565//                                      clean it up!
    544566//              '$' included for array indexing.
    545         :       ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|'0'..'9'|'_'|'.'|'$')*
     567        :       ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|'0'..'9'|'_'|'$')*
    546568        ;
    547569fragment
Note: See TracChangeset for help on using the changeset viewer.