Changeset 2607


Ignore:
Timestamp:
Nov 4, 2012, 7:27:47 PM (6 years ago)
Author:
ksherdy
Message:

Updated grammar. Initial code generation visitor code. Additional work required.

Location:
proto/pablo
Files:
5 added
1 deleted
17 edited
3 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/scatter/pablo.scatter

    r2467 r2607  
    7373
    7474grammar {
    75         program         -> (declarations | functionDef ) *;
     75        program         -> ( declarations | functionDef ) *;
    7676
    7777        //
     
    8282        // d e c l a r a t i o n s
    8383        //
    84         declarations                    #-> (typeDecl | typeDef) TERMINATOR ;
     84        declarations                    -> (typeDecl | typeDef) TERMINATOR ;
    8585
    8686        typeDecl                                ->  type ;
     
    9494        // f u n c t i o n   d e f i n i t i o n s                                                             
    9595        //
    96         functionDef             -> FUNCTION type functionName LROUND (parameter (COMMA parameter)*)? RROUND blockStatement TERMINATOR?;                         
     96        functionDef             -> FUNCTION type functionName LROUND parameterList RROUND blockStatement TERMINATOR?;                           
    9797                                                                               
    98         returnType              #-> type ;
    99        
    100         typeList                -> type (COMMA type)*;
     98        returnType              #-> type ;      // Note: Not strictly required.
     99       
     100        parameterList   -> (parameter (COMMA parameter)*)?;
    101101                                                                                                               
    102102        functionName    #-> identifier ;
     
    131131        returnStatement                                         -> RETURN (expression)? TERMINATOR;
    132132       
    133         localVarDecl                                            -> VAR type localVarDeclList TERMINATOR;
    134        
    135         localVarDeclList                                        -> localVarDecl (COMMA localVarDecl)* ;
    136                
    137         localVarDecl                                            -> variableName (assignmentOperator expression) ? ;
     133        // localVarDeclList                                     -> localVarDecl (COMMA localVarDecl)* TERMINATOR;
     134               
     135        localVarDecl                                            -> VAR type variableName (assignmentOperator expression) ?;
    138136               
    139137        variableName                                            #-> identifier;
     
    187185        // s t r e a m
    188186
    189         type                    ->  streamType | structType | VOID | identifier ; // | tupleType;
     187        type                    #->  streamType | structType | void | identifier ; // | tupleType;
    190188       
    191189        streamType              ->      STREAM (LANGLE fieldWidth RANGLE)? ;   
     
    197195        // s t r u c t 
    198196               
    199         structType                              ->      STRUCT structName (LCURLY structTypeBody RCURLY)? ;             
     197        structType                              ->      STRUCT structName (structTypeBody)? ;           
    200198                                       
    201199        structName                              #->  identifier ;                               
    202200                                       
    203         structTypeBody                  ->      structMember TERMINATOR (structMember TERMINATOR)* ;
     201        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
    204202                                       
    205203        structMember                    ->      type structMemberName ;
     
    207205        structMemberName                #-> identifier ;
    208206       
     207        void                                    -> VOID ;
     208       
    209209        // t u p l e
    210210       
  • proto/pablo/input/test/pablo/decl/decl1.pablo

    r2364 r2607  
    44        stream b3;
    55        stream b4;
    6 };
     6};
     7
     8function void Foo() {
     9
     10}
  • proto/pablo/input/test/pablo/funcDef/funcDef1.pablo

    r2368 r2607  
    1 function void Lex() {};
     1struct Lex {
     2        stream b;
     3};
     4
     5struct Lex {
     6        stream b;
     7        stream<1> d;
     8};
     9
     10function struct Lex ClassifyBytes(stream<1> a, stream b) {
     11
     12        var stream<1> a = 1;
     13        var stream<1> b = "One";
     14        var stream<1> c = 0 ^ (a | b) & c | 1;
     15        var stream d &= 1;
     16
     17};
  • proto/pablo/runConfigurations/pabloCompiler.launch

    r2541 r2607  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="compiler.PabloCompiler"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pablo/input/test/pablo/visitors/CarryIntro/carryIntro.pablo"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pablo/input/test/pablo/funcDef/funcDef1.pablo"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pablo"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pablo/src/ast/ASTTransformer.java

    r2465 r2607  
    2222        public ASTNode visit(CompoundVariableNode node);
    2323
     24        public ASTNode visit(DeclarationsNode node);
     25
    2426        public ASTNode visit(DeclaratorListNode node);
    2527
     
    4042        public ASTNode visit(IntegerConstantNode node);
    4143
    42         public ASTNode visit(LocalVarDeclListNode node);
    43 
    4444        public ASTNode visit(LocalVarDeclNode node);
    4545
     46        public ASTNode visit(ParameterListNode node);
     47
    4648        public ASTNode visit(ParameterNode node);
    4749
     
    6466        public ASTNode visit(TypeDefNode node);
    6567
    66         public ASTNode visit(TypeListNode node);
    67 
    68         public ASTNode visit(TypeNode node);
    69 
    7068        public ASTNode visit(UnaryOperatorNode node);
     69
     70        public ASTNode visit(VoidNode node);
    7171
    7272        public ASTNode visit(WhileStatementNode node);
     
    103103                }
    104104
     105                public ASTNode visit(DeclarationsNode node) {
     106                        return defaultVisit(node);
     107                }
     108
    105109                public ASTNode visit(DeclaratorListNode node) {
    106110                        return defaultVisit(node);
     
    139143                }
    140144
    141                 public ASTNode visit(LocalVarDeclListNode node) {
    142                         return defaultVisit(node);
    143                 }
    144 
    145145                public ASTNode visit(LocalVarDeclNode node) {
    146146                        return defaultVisit(node);
    147147                }
    148148
     149                public ASTNode visit(ParameterListNode node) {
     150                        return defaultVisit(node);
     151                }
     152
    149153                public ASTNode visit(ParameterNode node) {
    150154                        return defaultVisit(node);
     
    187191                }
    188192
    189                 public ASTNode visit(TypeListNode node) {
    190                         return defaultVisit(node);
    191                 }
    192 
    193                 public ASTNode visit(TypeNode node) {
    194                         return defaultVisit(node);
    195                 }
    196 
    197193                public ASTNode visit(UnaryOperatorNode node) {
     194                        return defaultVisit(node);
     195                }
     196
     197                public ASTNode visit(VoidNode node) {
    198198                        return defaultVisit(node);
    199199                }
  • proto/pablo/src/ast/ASTVisitor.java

    r2465 r2607  
    2929        public T visitLeave(CompoundVariableNode node, List<T> childResults);
    3030
     31        public void visitEnter(DeclarationsNode node);
     32        public T visitLeave(DeclarationsNode node, List<T> childResults);
     33
    3134        public void visitEnter(DeclaratorListNode node);
    3235        public T visitLeave(DeclaratorListNode node, List<T> childResults);
     
    5659        public T visitLeave(IntegerConstantNode node, List<T> childResults);
    5760
    58         public void visitEnter(LocalVarDeclListNode node);
    59         public T visitLeave(LocalVarDeclListNode node, List<T> childResults);
    60 
    6161        public void visitEnter(LocalVarDeclNode node);
    6262        public T visitLeave(LocalVarDeclNode node, List<T> childResults);
    6363
     64        public void visitEnter(ParameterListNode node);
     65        public T visitLeave(ParameterListNode node, List<T> childResults);
     66
    6467        public void visitEnter(ParameterNode node);
    6568        public T visitLeave(ParameterNode node, List<T> childResults);
     
    9295        public T visitLeave(TypeDefNode node, List<T> childResults);
    9396
    94         public void visitEnter(TypeListNode node);
    95         public T visitLeave(TypeListNode node, List<T> childResults);
    96 
    97         public void visitEnter(TypeNode node);
    98         public T visitLeave(TypeNode node, List<T> childResults);
    99 
    10097        public void visitEnter(UnaryOperatorNode node);
    10198        public T visitLeave(UnaryOperatorNode node, List<T> childResults);
     99
     100        public void visitEnter(VoidNode node);
     101        public T visitLeave(VoidNode node, List<T> childResults);
    102102
    103103        public void visitEnter(WhileStatementNode node);
     
    163163                }
    164164
     165                public void visitEnter(DeclarationsNode node) {
     166                        defaultVisitEnter(node);
     167                }
     168                public T visitLeave(DeclarationsNode node, List<T> childResults) {
     169                        return defaultVisitLeave(node);
     170                }
     171
    165172                public void visitEnter(DeclaratorListNode node) {
    166173                        defaultVisitEnter(node);
     
    226233                }
    227234
    228                 public void visitEnter(LocalVarDeclListNode node) {
    229                         defaultVisitEnter(node);
    230                 }
    231                 public T visitLeave(LocalVarDeclListNode node, List<T> childResults) {
    232                         return defaultVisitLeave(node);
    233                 }
    234 
    235235                public void visitEnter(LocalVarDeclNode node) {
    236236                        defaultVisitEnter(node);
     
    240240                }
    241241
     242                public void visitEnter(ParameterListNode node) {
     243                        defaultVisitEnter(node);
     244                }
     245                public T visitLeave(ParameterListNode node, List<T> childResults) {
     246                        return defaultVisitLeave(node);
     247                }
     248
    242249                public void visitEnter(ParameterNode node) {
    243250                        defaultVisitEnter(node);
     
    310317                }
    311318
    312                 public void visitEnter(TypeListNode node) {
    313                         defaultVisitEnter(node);
    314                 }
    315                 public T visitLeave(TypeListNode node, List<T> childResults) {
    316                         return defaultVisitLeave(node);
    317                 }
    318 
    319                 public void visitEnter(TypeNode node) {
    320                         defaultVisitEnter(node);
    321                 }
    322                 public T visitLeave(TypeNode node, List<T> childResults) {
    323                         return defaultVisitLeave(node);
    324                 }
    325 
    326319                public void visitEnter(UnaryOperatorNode node) {
    327320                        defaultVisitEnter(node);
    328321                }
    329322                public T visitLeave(UnaryOperatorNode node, List<T> childResults) {
     323                        return defaultVisitLeave(node);
     324                }
     325
     326                public void visitEnter(VoidNode node) {
     327                        defaultVisitEnter(node);
     328                }
     329                public T visitLeave(VoidNode node, List<T> childResults) {
    330330                        return defaultVisitLeave(node);
    331331                }
  • proto/pablo/src/ast/SimpleVisitor.java

    r2601 r2607  
    2323        public void visit(CompoundVariableNode node);
    2424
     25        public void visit(DeclarationsNode node);
     26
    2527        public void visit(DeclaratorListNode node);
    2628
     
    4143        public void visit(IntegerConstantNode node);
    4244
    43         public void visit(LocalVarDeclListNode node);
    44 
    4545        public void visit(LocalVarDeclNode node);
    4646
     47        public void visit(ParameterListNode node);
     48
    4749        public void visit(ParameterNode node);
    4850
     
    6567        public void visit(TypeDefNode node);
    6668
    67         public void visit(TypeListNode node);
    68 
    69         public void visit(TypeNode node);
    70 
    7169        public void visit(UnaryOperatorNode node);
     70
     71        public void visit(VoidNode node);
    7272
    7373        public void visit(WhileStatementNode node);
     
    104104                }
    105105
     106                public void visit(DeclarationsNode node) {
     107                        defaultVisit(node);
     108                }
     109
    106110                public void visit(DeclaratorListNode node) {
    107111                        defaultVisit(node);
     
    140144                }
    141145
    142                 public void visit(LocalVarDeclListNode node) {
    143                         defaultVisit(node);
    144                 }
    145 
    146146                public void visit(LocalVarDeclNode node) {
    147147                        defaultVisit(node);
    148148                }
    149149
     150                public void visit(ParameterListNode node) {
     151                        defaultVisit(node);
     152                }
     153
    150154                public void visit(ParameterNode node) {
    151155                        defaultVisit(node);
     
    188192                }
    189193
    190                 public void visit(TypeListNode node) {
    191                         defaultVisit(node);
    192                 }
    193 
    194                 public void visit(TypeNode node) {
    195                         defaultVisit(node);
    196                 }
    197 
    198194                public void visit(UnaryOperatorNode node) {
     195                        defaultVisit(node);
     196                }
     197
     198                public void visit(VoidNode node) {
    199199                        defaultVisit(node);
    200200                }
  • proto/pablo/src/ast/VoidVisitor.java

    r2465 r2607  
    2727        public void visitLeave(CompoundVariableNode node);
    2828
     29        public void visitEnter(DeclarationsNode node);
     30        public void visitLeave(DeclarationsNode node);
     31
    2932        public void visitEnter(DeclaratorListNode node);
    3033        public void visitLeave(DeclaratorListNode node);
     
    5457        public void visitLeave(IntegerConstantNode node);
    5558
    56         public void visitEnter(LocalVarDeclListNode node);
    57         public void visitLeave(LocalVarDeclListNode node);
    58 
    5959        public void visitEnter(LocalVarDeclNode node);
    6060        public void visitLeave(LocalVarDeclNode node);
    6161
     62        public void visitEnter(ParameterListNode node);
     63        public void visitLeave(ParameterListNode node);
     64
    6265        public void visitEnter(ParameterNode node);
    6366        public void visitLeave(ParameterNode node);
     
    9093        public void visitLeave(TypeDefNode node);
    9194
    92         public void visitEnter(TypeListNode node);
    93         public void visitLeave(TypeListNode node);
    94 
    95         public void visitEnter(TypeNode node);
    96         public void visitLeave(TypeNode node);
    97 
    9895        public void visitEnter(UnaryOperatorNode node);
    9996        public void visitLeave(UnaryOperatorNode node);
     97
     98        public void visitEnter(VoidNode node);
     99        public void visitLeave(VoidNode node);
    100100
    101101        public void visitEnter(WhileStatementNode node);
     
    160160                }
    161161
     162                public void visitEnter(DeclarationsNode node) {
     163                        defaultVisitEnter(node);
     164                }
     165                public void visitLeave(DeclarationsNode node) {
     166                        defaultVisitLeave(node);
     167                }
     168
    162169                public void visitEnter(DeclaratorListNode node) {
    163170                        defaultVisitEnter(node);
     
    223230                }
    224231
    225                 public void visitEnter(LocalVarDeclListNode node) {
    226                         defaultVisitEnter(node);
    227                 }
    228                 public void visitLeave(LocalVarDeclListNode node) {
    229                         defaultVisitLeave(node);
    230                 }
    231 
    232232                public void visitEnter(LocalVarDeclNode node) {
    233233                        defaultVisitEnter(node);
     
    237237                }
    238238
     239                public void visitEnter(ParameterListNode node) {
     240                        defaultVisitEnter(node);
     241                }
     242                public void visitLeave(ParameterListNode node) {
     243                        defaultVisitLeave(node);
     244                }
     245
    239246                public void visitEnter(ParameterNode node) {
    240247                        defaultVisitEnter(node);
     
    307314                }
    308315
    309                 public void visitEnter(TypeListNode node) {
    310                         defaultVisitEnter(node);
    311                 }
    312                 public void visitLeave(TypeListNode node) {
    313                         defaultVisitLeave(node);
    314                 }
    315 
    316                 public void visitEnter(TypeNode node) {
    317                         defaultVisitEnter(node);
    318                 }
    319                 public void visitLeave(TypeNode node) {
    320                         defaultVisitLeave(node);
    321                 }
    322 
    323316                public void visitEnter(UnaryOperatorNode node) {
    324317                        defaultVisitEnter(node);
    325318                }
    326319                public void visitLeave(UnaryOperatorNode node) {
     320                        defaultVisitLeave(node);
     321                }
     322
     323                public void visitEnter(VoidNode node) {
     324                        defaultVisitEnter(node);
     325                }
     326                public void visitLeave(VoidNode node) {
    327327                        defaultVisitLeave(node);
    328328                }
  • proto/pablo/src/compiler/PabloCompiler.java

    r2579 r2607  
    5050                // Quick-and-dirty. Java Map. Proceed in a similar manner as the existing Python compiler.
    5151               
    52                 StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
    53                 Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
     52//              StreamFunctionVisitor streamFunctionVisitor = new StreamFunctionVisitor(syntaxTree);
     53//              Map<String, ASTNode> streamFunctionMap = streamFunctionVisitor.makeStreamFunctionMap();
    5454               
    55                 for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
     55//              for (Map.Entry<String, ASTNode> entry : streamFunctionMap.entrySet()) {
    5656                       
    5757//                  AdvanceCombiner advanceCombiner = new AdvanceCombiner(entry.getValue());
     
    7171//                      augmentedAssignmentRemoval.transform();
    7272
    73                         CarryIntro carryIntro = new CarryIntro(entry.getValue());
    74                         carryIntro.transform(true, false);                     
    75                 }
     73//                      CarryIntro carryIntro = new CarryIntro(entry.getValue());
     74//                      carryIntro.transform(true, false);                     
     75//              }
    7676
    77                 System.out.print(syntaxTree);           
     77                System.out.print(syntaxTree);
     78               
     79                CodeGenerator cPPCodeGenerator = new CPPCodeGenerator(syntaxTree);
     80                String code = cPPCodeGenerator.getCode();
     81                System.out.print(code);
    7882               
    7983//              ASTNode decoratedTree = SemanticAnalyzer.analyze(syntaxTree);
  • proto/pablo/src/compiler/ast/Accessors.java

    r2598 r2607  
    33import java.util.List;
    44
    5 import ast.ASTNode;
    6 import ast.AssignmentNode;
    7 import ast.BinaryOperatorNode;
    8 import ast.BlockStatementNode;
    9 import ast.CompoundVariableNode;
    10 import ast.FunctionDefNode;
    11 import ast.FunctionInvocationNode;
    12 import ast.IdentifierNode;
    13 import ast.IfStatementNode;
    14 import ast.UnaryOperatorNode;
    15 import ast.WhileStatementNode;
     5import ast.*;
    166
    177public class Accessors {
     
    3626                return node.child(1);
    3727        }       
     28
     29        ////////////////////////////////////////////////////////////////////////////
     30        // Assignment Operators
     31        ////////////////////////////////////////////////////////////////////////////                           
     32        public static String assignmentOperator(AssignmentOperatorNode node) {
     33                return node.getToken().getLexeme();
     34        }       
    3835       
    3936        ////////////////////////////////////////////////////////////////////////////
    4037        // Unary Operators
    4138        ////////////////////////////////////////////////////////////////////////////                   
    42         public static ASTNode Operand(UnaryOperatorNode node) {
     39        public static ASTNode operand(UnaryOperatorNode node) {
    4340                return node.child(0);
    4441        }
     
    5552        }               
    5653
     54        public static String operator(BinaryOperatorNode node) {
     55                return node.getToken().getLexeme();
     56        }               
     57       
     58        ////////////////////////////////////////////////////////////////////////////
     59        // Integer Constant
     60        ////////////////////////////////////////////////////////////////////////////           
     61        public static String integerConstant(IntegerConstantNode node) {
     62                return node.getToken().getLexeme();
     63        }                       
     64
     65        ////////////////////////////////////////////////////////////////////////////
     66        // String Constant
     67        ////////////////////////////////////////////////////////////////////////////           
     68        public static String stringConstant(StringConstantNode node) {
     69                return node.getToken().getLexeme();
     70        }                       
     71       
    5772        ////////////////////////////////////////////////////////////////////////////
    5873        // IfStatementNode helpers
     
    8297        public static IdentifierNode functionName(FunctionDefNode node) {
    8398                return (IdentifierNode) node.child(1);
     99        }
     100       
     101        public static boolean hasParameters(FunctionDefNode node) {
     102                if (node.nChildren() > 2) {
     103                        ASTNode child = node.child(2);
     104                        assert child instanceof ParameterListNode;
     105                        if(child.nChildren() > 0) {
     106                                        return true;
     107                        }
     108                }
     109                return false;
    84110        }
    85111       
     
    139165        }
    140166
     167        ////////////////////////////////////////////////////////////////////////////
     168        // StructTypeNode helper
     169        ////////////////////////////////////////////////////////////////////////////
     170        public static String structName(StructTypeNode node) {
     171        String name = new String();
     172        name = Accessors.identifierLexeme(node.child(0));
     173        return name;
     174        }
     175
     176        public static StructTypeBodyNode structBody(StructTypeNode node) {
     177                ASTNode child = node.child(1);
     178                assert child instanceof StructTypeBodyNode;
     179        return (StructTypeBodyNode) child;
     180        }       
     181       
     182        public static boolean hasStructBody(StructTypeNode node) {
     183                if (node.nChildren() > 1) {
     184                        ASTNode child = node.child(1);
     185                        assert child instanceof StructTypeBodyNode;
     186                        return true;
     187                }
     188                return false;
     189        }       
     190       
     191        ////////////////////////////////////////////////////////////////////////////
     192        // StructMemberNode helper
     193        ////////////////////////////////////////////////////////////////////////////
     194        public static String structMemberName(StructMemberNode node) {
     195        String name = new String();
     196        name = Accessors.identifierLexeme(node.child(1));
     197        return name;
     198        }       
     199       
     200        ////////////////////////////////////////////////////////////////////////////
     201        // StructMemberNode helpers
     202        ////////////////////////////////////////////////////////////////////////////
     203        public static String streamTypeName(StreamTypeNode node) {
     204                String name = new String();
     205                name = node.getToken().getLexeme();
     206                return name;
     207        }       
     208
     209        ////////////////////////////////////////////////////////////////////////////
     210        // StructMemberNode helpers
     211        ////////////////////////////////////////////////////////////////////////////
     212        public static boolean hasFieldWidth(StreamTypeNode node) {             
     213                if(1 == node.nChildren()) {
     214                        assert node.child(0) instanceof FieldWidthNode;
     215                        return true;
     216                }
     217                return false;
     218        }
     219
     220        ////////////////////////////////////////////////////////////////////////////
     221        //
     222        ////////////////////////////////////////////////////////////////////////////
     223        public static String fieldWidthValue(FieldWidthNode node) {             
     224                return node.getToken().getLexeme();
     225        }       
     226
     227        ////////////////////////////////////////////////////////////////////////////
     228        //
     229        ////////////////////////////////////////////////////////////////////////////   
     230        public static String voidValue(VoidNode node) {         
     231                return node.getToken().getLexeme();
     232        }       
     233       
     234       
    141235}
  • proto/pablo/src/compiler/codeGeneration/Application.java

    r2598 r2607  
    55import compiler.templating.FileTemplate;
    66
    7 public class CodeGenerator {
     7public class Application {
    88        private static final String TEMPLATE_DIRECTORY = "./src/codeGeneration/templates";
    99
     
    1111    private static final String APPLICATIONS_DIRECTORY     = "applications";
    1212
    13         public final static String generatedCodeWarning = "// DO NOT MODIFY\n//\n// This code is generated by the pablo compiler\n// Any modifications will be lost the next time the compiler is run.\n//\n";
     13        public final static String generatedCodeWarning = "// DO NOT MODIFY\n//\n// Pablo generated code.\n// Modifications will be lost with subsequent compiler runs.\n//\n";
    1414       
    1515        private String outputDirectory;
     
    1919        // construction
    2020       
    21         public CodeGenerator(String outputDirectory, String basePackage, ASTNode root) {
     21        public Application(String outputDirectory, String basePackage, ASTNode root) {
    2222                this.root = root;
    2323               
     
    3434        public void generate() {
    3535//              generateLoggingPackage();
    36             generateCPlusPlusApplication();
    37                
     36            generateCPPApplication();
    3837                printCompletionMessage();
    3938        }
     39       
    4040        public void printCompletionMessage() {
    4141                System.out.println("Code generation complete.");
     
    4646//              logging.generate();
    4747//      }
    48         private void generateCPlusPlusApplication() {
    49             CPlusPlusApplicationGenerator generator = new CPlusPlusApplicationGenerator(root, outputDirectory, APPLICATIONS_DIRECTORY);
     48       
     49        private void generateCPPApplication() {
     50            ApplicationGenerator generator = new ApplicationGenerator(root, outputDirectory, APPLICATIONS_DIRECTORY);
    5051            generator.generate();
    5152        }
  • proto/pablo/src/compiler/codeGeneration/ApplicationGenerator.java

    r2598 r2607  
    33import ast.ASTNode;
    44
    5 public class CPlusPlusApplicationGenerator {
     5// TODO - Refactor to Abstract Factory to allow the generation of C / C++ / ... pablo applications.
     6
     7public class ApplicationGenerator {
    68        ASTNode root;
    79        private String outputDirectory;
    810        private String srcDirectory;
    911       
    10         public CPlusPlusApplicationGenerator(ASTNode root, String outputDirectory, String parserDirectory) {
     12        public ApplicationGenerator(ASTNode root, String outputDirectory, String parserDirectory) {
    1113                this.root = root;
    1214                this.outputDirectory = outputDirectory;
     
    1719                OutputCodeFolder parser = new OutputCodeFolder(outputDirectory, srcDirectory);
    1820
    19                 parser.generateFile(new CPlusPlusContentGenerator(this.root, srcDirectory), "Parser.java"); // "Parser.java"
     21//              parser.generateFile(new TemplateContentsGenerator(this.root, srcDirectory), "Parser.java"); // "Parser.java"
    2022//              parser.copyTemplate("ReverseAccessibleArrayList");
    2123//              parser.copyTemplate("RevList");
  • proto/pablo/src/compiler/codeGeneration/CarryQ.java

    r2602 r2607  
    33public enum CarryQ {
    44               
    5         CARRYTEST("CarryTest",2),
    6         GETCARRYIN("get_carry_in",1),
    7         GETPENDING64("get_pending64",1),
    8         CARRYCOMBINE("CarryCombine",3),
    9         CARRYQADJUST("CarryQ_Adjust",1),
    10         CARRYFLIP("carry_flip",1),
    11         CARRYDEQUEUEENQUEUE("CarryDequeueEnqueue",2),
    12         VALUEOF("cq[%d]",1);
     5        CARRYTEST(2, "CarryTest"),
     6        GETCARRYIN(1, "get_carry_in"),
     7        GETPENDING64(1, "get_pending64"),
     8        CARRYCOMBINE(3, "CarryCombine"),
     9        CARRYQADJUST(2, "CarryQ_Adjust"),
     10        CARRYFLIP(2, "carry_flip"),
     11        CARRYDEQUEUEENQUEUE(2, "CarryDequeueEnqueue"),
     12        VALUEOF(1, "cq[%d]");
    1313                       
    1414        private final String cPPName;
     
    1717        public static String CarryQ_PACKAGE_NAME = "CarryQ";
    1818       
    19         CarryQ(String cName, int argCount) {
    20                 this.cPPName = cName;
     19        CarryQ(int argCount, String cPPName ) {
    2120                this.argCount = argCount;
     21                this.cPPName = cPPName;
    2222        }
    2323       
  • proto/pablo/src/compiler/codeGeneration/CodeStore.java

    r2421 r2607  
    55
    66public class CodeStore {
     7       
    78        private class CodeLine {
    89                public final String line;
     
    1415                }
    1516        }
    16         private static final char NEWLINE = '\n';
    17         private static final char INDENT  = '\t';
     17       
     18        public static final char NEWLINE = '\n';
     19        public static final char INDENT  = '\t';
    1820        List<CodeLine> code = new ArrayList<CodeLine>();
    1921        private String resultVariableName = "codeStoreNoVariable";
     
    2325                code.add(codeLine);
    2426        }
     27       
    2528        public void addLine(String line) {
    2629                addLine(line, 0);
    2730        }
     31       
    2832        public void addFormattedLine(String format, Object...args ) {
    2933                String line = String.format(format, args);
    3034                addLine(line);
    3135        }
     36       
    3237        public void indentedFormattedLine(String format, Object...args ) {
    3338                String line = String.format(format, args);
    3439                indentedLine(line);
    3540        }
     41       
    3642        public void indentedLine(String line) {
    3743                addLine(line, 1);
    3844        }
     45       
    3946        public void dedentedLine(String line) {
    4047                addLine(line, -1);
    4148        }
     49       
    4250        public void setResultVariableName(String name) {
    4351                this.resultVariableName  = name;
    4452        }
     53       
    4554        public String getResultVariableName() {
    4655                return resultVariableName;
    4756        }
     57       
    4858        public void addAll(CodeStore other, int relativeIndent) {
     59                if(other == null) { // TODO - Not sure about this.
     60                        return;
     61                }
     62               
    4963                if(other.code.isEmpty()) {
    5064                        return;
     
    7387                return builder.toString();
    7488        }
    75 
     89       
    7690        private void addIndentation(int indent, StringBuilder builder) {
    7791                for(int i=0; i<indent; i++) {
  • proto/pablo/src/compiler/codeGeneration/OutputCodeFolder.java

    r2421 r2607  
    4949                return template;
    5050        }
     51/*     
    5152        public void generateFile(ContentsGenerator contents, String filename) {
    5253                generateContents(contents, folderName + filename);
     
    5556                generateFile(new CopyGenerator(templateName), filename);
    5657        }       
    57        
     58*/     
    5859        /**
    5960         *  Copies a warning-only template from template subfolder to output subfolder,
     
    6263         * @param baseName      base name (no extension) of file. (".template" is added for template, ".java" for output.)
    6364         */
     65/*
    6466        public void copyTemplate(String baseName) {
    6567                generateFile(new CopyGenerator(folderName + baseName + ".template"), baseName + ".java");
     
    7779                }
    7880        }       
     81*/     
    7982        void ensureOutputDirectoryExists(String directoryName) {
    8083                ensureDirectoryExists( outputFilename(directoryName) );
     
    100103        //////////////////////////////////////////////////////////////////////////////////
    101104        // template copy generator
     105/*     
    102106        static private class CopyGenerator implements ContentsGenerator {
    103107                private String templateName;
     
    111115                }       
    112116        }
     117*/     
    113118}
  • proto/pablo/src/compiler/codeGeneration/TemplateContentsGenerator.java

    r2598 r2607  
    22
    33import java.io.PrintStream;
     4import java.util.List;
     5
     6import compiler.visitors.*;
     7import compiler.codeGeneration.Application;
    48import compiler.templating.Template;
    59import ast.*;
    610
    7 //import semanticAnalyzer.XStarters;
    8 //import symbols.AttributeRegistry;
    9 //import symbols.NodeClass;
    10 //import symbols.NodeClassRegistry;
    11 //import symbols.Nonterminal;
    1211//import symbols.Symbol;
    1312//import symbols.SymbolTable;
    14 //import symbols.Terminal;
    15 //import templating.Template;
    1613
    17 public class CPlusPlusContentGenerator implements ContentsGenerator {
    18     private ASTNode astTree;
    19         private String outputDirectory;
    20 //      private SymbolTable symbolTable;
    21         private static Labeller labeller = new Labeller();
     14// Refactor to accept multiple code generation objects (C macros, C++ IDISA, ...).
     15
     16public class TemplateContentsGenerator {
     17   
     18        private ASTNode astTree;
     19    private Template template;
     20    private CodeGenerator codeGenerator;
     21//      private String outputDirectory;
    2222       
    23         public CPlusPlusContentGenerator(ASTNode root, String templateDirectory) {
    24                 this.outputDirectory = templateDirectory;
     23        public TemplateContentsGenerator(ASTNode astTree, Template template) {
     24                this.astTree = astTree;
     25                this.template = template;
    2526        }
    26         public void generate(PrintStream out, OutputCodeFolder folder) {
    27                 String someCode = generateCode();
     27
     28        public void generate() {
    2829               
    29                 Template template = folder.fileTemplate("parser", outputDirectory + "/pablo_dummy.template");
    30                 template.set("someLabel", someCode);
    31                 template.set("warningComment", CodeGenerator.generatedCodeWarning);
    32                 template.print(out);
     30//              String code = this.codeGenerator.getCode(this.astTree);
     31               
     32                // Template template = folder.fileTemplate("parser", outputDirectory + "/pablo_dummy.template");
     33               
     34                template.set("warning", Application.generatedCodeWarning);
     35//              template.set("label", code);
     36               
     37                //template.print(out);
    3338        }       
    3439       
    35         private String generateCode() {
    36                 ParserPrinter visitor = new ParserPrinter();
    37                 return visitor.getCode(this.astTree);
    38         }
    39        
    40         class ParserPrinter extends ASTVisitor.Default<CodeStore> {
    41 //              private boolean inAction = false;
    42 //              private boolean inRecognizers = false;
    43            
    44                 //////////////////////////////////////////////////////////////////
    45                 // generated code for each node is held in codeMap.
    46                 // each visiting method should call newCode to get a CodeStore
    47                 // and to put that CodeStore in the map.
    48        
    49         public String getCode(ASTNode grammar) {
    50             CodeStore codeStore = (CodeStore)grammar.accept(this);
    51             return codeStore.toStringIndented(1);
    52         }
    53            
    54            
    55 /*             
    56                 private CodeStore concatenatedChildrenCode(List<CodeStore> childResults) {
    57                         return concatenatedChildrenCode(new CodeStore(), childResults, false);
    58                 }
    59 
    60                 public CodeStore concatenatedChildrenCode(CodeStore code, List<CodeStore> childResults, boolean blankBetween) {
    61                         for(CodeStore childCode: childResults) {
    62                                 code.addAll(childCode, 0);
    63                                 if(blankBetween) {
    64                                         code.addLine(" ");
    65                                 }
    66                         }
    67                         return code;
    68                 }
    69 
    70                 public CodeStore visitLeave(GrammarSectionNode node, List<CodeStore> childResults) {
    71                         CodeStore code = new CodeStore();                       
    72 
    73                         Nonterminal startSymbol = node.getStartSymbol();
    74                         code.addLine("public ASTNode parse() {");
    75                         code.indentedLine("readToken();");
    76                         code.addLine("return " + startSymbol.getParseMethodName() + "();");
    77                         code.dedentedLine("}");
    78                        
    79                         return concatenatedChildrenCode(code, childResults, true);
    80                 }
    81                
    82                 public void visitEnter(TokenRecognizerSectionNode node) {
    83                         inRecognizers = true;
    84                 }
    85                 public CodeStore visitLeave(TokenRecognizerSectionNode node, List<CodeStore> childResults) {
    86                         inRecognizers = false;
    87                         return concatenatedChildrenCode(childResults);
    88                 }
    89                 public void visitEnter(ActionNode node) {
    90                         inAction = true;
    91                 }
    92                 public CodeStore visitLeave(ActionNode node, List<CodeStore> childResults) {
    93                         inAction = false;
    94                         return concatenatedChildrenCode(childResults);
    95                 }
    96 
    97 
    98                 public CodeStore visitLeave(NumberNode node, List<CodeStore> childResults) {
    99                         CodeStore code =  new CodeStore();
    100                         String variableName = labeller.newLabel();
    101 
    102                         int value = ((NumberNode)node).getValue();
    103                         code.addFormattedLine("int %s = %d;", variableName, value);
    104                        
    105                         code.setResultVariableName(variableName);
    106                         return code;
    107                 }
    108                 public CodeStore visitLeave(BooleanConstantNode node, List<CodeStore> childResults) {
    109                         CodeStore code =  new CodeStore();
    110                         String variableName = labeller.newLabel();
    111 
    112                         Boolean value = ((BooleanConstantNode)node).getValue();
    113                         code.addFormattedLine("boolean %s = %s;", variableName, value.toString());
    114                        
    115                         code.setResultVariableName(variableName);
    116                         return code;
    117                 }
    118                 public CodeStore visitLeave(BinaryOperatorNode node, List<CodeStore> childResults) {
    119                         CodeStore code =  new CodeStore();
    120                         String variableName = labeller.newLabel();
    121                        
    122                         CodeStore leftCode   = (CodeStore)childResults.get(0);
    123                         CodeStore rightCode  = (CodeStore)childResults.get(1);
    124                         String leftVariable  = leftCode.getResultVariableName();
    125                         String rightVariable = rightCode.getResultVariableName();
    126 
    127                         String resultType = "int";      //TODO: fix for other operations, etc.
    128                         String operator = node.getToken().getLexeme();
    129                        
    130                         code.addAll(leftCode, 0);
    131                         code.addAll(rightCode, 0);
    132                         code.addFormattedLine("%s %s = %s %s %s;", resultType, variableName, leftVariable, operator, rightVariable);
    133                        
    134                         code.setResultVariableName(variableName);
    135                         return code;
    136                 }
    137                 public CodeStore visitLeave(AssignmentNode node, List<CodeStore> childResults) {
    138                         CodeStore code =  new CodeStore();
    139                        
    140                         CodeStore leftCode   = (CodeStore)childResults.get(0);  // this code is just the receiver
    141                         CodeStore rightCode  = (CodeStore)childResults.get(1);
    142                         String receiver      = leftCode.getResultVariableName();
    143                         String value         = rightCode.getResultVariableName();
    144 
    145                         code.addLine("{");
    146                         code.addAll(leftCode, 1);
    147                         code.addAll(rightCode, 0);
    148                        
    149                         AttributeNode lhs = (AttributeNode)node.child(0);
    150                         String attributeName = lhs.attributeName();
    151                         String setter = callSetter(receiver, attributeName, value);
    152                         code.addFormattedLine("%s;", setter);
    153 
    154                         code.dedentedLine("}");
    155                        
    156                         // no variable for value
    157                         return code;
    158                 }
    159                 // produces code just for the attributeReference receiver; parent must handle getter/setter.
    160                 public CodeStore visitLeave(AttributeNode node, List<CodeStore> childResults) {
    161                         assert node.nChildren() == 2;
    162 
    163                         CodeStore code =  new CodeStore();
    164                         String variableName = labeller.newLabel();
    165                        
    166                         CodeStore receiverCode = (CodeStore) childResults.get(0);
    167                         String receiver = receiverCode.getResultVariableName();
    168                        
    169                         code.addAll(receiverCode, 0);
    170                        
    171                         String attributeName = node.attributeName();
    172                         String attributeType = attributeTypeFor(node);
    173                        
    174                         if(node.isTokenReference()) {
    175                                 String castReceiver = labeller.newLabel();
    176                                 String castType = "IntConstantToken";
    177                                 code.addFormattedLine("%s %s = (%s)%s;", castType, castReceiver, castType, receiver);
    178                                 receiver = castReceiver;
    179                         }
    180                         else {
    181                                 String castReceiver = labeller.newLabel();
    182                                 String castType = declaringNodeTypeFor(attributeName);
    183                                 code.addFormattedLine("%s %s = (%s)%s;", castType, castReceiver, castType, receiver);
    184                                 receiver = castReceiver;
    185                         }
    186                        
    187                         if(node.isAssignmentLHS()) {
    188                                 // let parent AssignmentNode call setter.
    189                                 code.setResultVariableName(receiver);
    190                         }
    191                         else {
    192                                 // call getter
    193                                 String getter = callGetter(receiver, attributeName);
    194                                 code.addFormattedLine("%s %s = %s;", attributeType, variableName, getter);
    195                                 code.setResultVariableName(variableName);
    196                         }
    197                        
    198                         return code;
    199                 }
    200                 private String attributeTypeFor(AttributeNode node) {
    201                         if(node.isTokenReference()) {
    202                                 return "int";           // hardwired for proof-of-concept
    203                         }
    204                         else {
    205                                 AttributeRegistry attributeRegistry = symbolTable.attributeRegistry();
    206                                 return attributeRegistry.getType(node.attributeName());
    207                         }
    208                 }
    209                 @SuppressWarnings("unused")
    210                 private boolean hasDeclaringNodeType(String attributeName) {
    211                         AttributeRegistry attributeRegistry = symbolTable.attributeRegistry();
    212                         return attributeRegistry.containsKey(attributeName);
    213                 }
    214                 private String declaringNodeTypeFor(String attributeName) {
    215                         AttributeRegistry attributeRegistry = symbolTable.attributeRegistry();
    216                         NodeClass definingNodeClass = attributeRegistry.get(attributeName);
    217                         return definingNodeClass.getName();
    218                 }
    219                
    220                 public CodeStore visitLeave(SymbolReferenceNode node, List<CodeStore> childResults) {
    221                         CodeStore code =  new CodeStore();
    222                         String variableName = labeller.newLabel();
    223 
    224                         if(node.isTokenReference()) {
    225                                 variableName = "previouslyRead";
    226                         }
    227                         else {
    228                                 String object = node.objectFor("result", "allChildren");
    229                                 code.addFormattedLine("ASTNode %s = %s;", variableName, object);
    230                         }
    231                        
    232                         code.setResultVariableName(variableName);
    233                         return code;
    234                 }
    235 
    236                
    237                 private String callGetter(String object, String attributeName) {
    238                         String methodName = "get" + NodeClassRegistry.capitalizeFirst(attributeName);
    239                         return object + "." + methodName + "()";
    240                 }
    241                 private String callSetter(String object, String attributeName, String value) {
    242                         String methodName = "set" + NodeClassRegistry.capitalizeFirst(attributeName);
    243                         return object + "." + methodName + "( " + value + " )";
    244                 }
    245                
    246                 public CodeStore visitLeave(AlternationNode node, List<CodeStore> childResults) {
    247                         CodeStore code = new CodeStore();
    248 
    249                         for(int i=0; i<node.nChildren(); i++) {
    250                                 ASTNode child = node.child(i);
    251                                 CodeStore childCode = (CodeStore) childResults.get(i);
    252                                 String condition = startCondition(child);
    253                                
    254                                 String statement = (i==0) ? "if" : "else if";
    255                                 code.addLine(statement + "( " + condition + " ) {");
    256                                 code.addAll(childCode, 1);
    257                                 code.addLine("}", -1);
    258                         }
    259                         return code;
    260                 }
    261                
    262                 public CodeStore visitLeave(ConcatenationNode node, List<CodeStore> childResults) {
    263                         return concatenatedChildrenCode(childResults);
    264                 }
    265                
    266                 public CodeStore visitLeave(LextantNode node, List<CodeStore> childResults) {
    267                         CodeStore code = new CodeStore();
    268                        
    269                         if(node.getToken().isLextant(Lextant.LEFTASSOC)) {
    270                                 code.addLine("result = rotateLeftIfPossible(result);");
    271                         }
    272                         else if (node.getToken().isLextant(Lextant.PROMOTE)) {
    273                                 code.addLine("result = promoteLastChild(result);");
    274                                 code.addLine("allowCompression = false;");
    275                         }
    276                        
    277                         return code;
    278                 }
    279                 public CodeStore visitLeave(EpsilonNode node, List<CodeStore> childResults) {
    280                         CodeStore code = new CodeStore();
    281                         code.addLine("// epsilon");
    282                         return code;
    283                 }
    284                
    285                 public CodeStore visitLeave(RepetitionNode node, List<CodeStore> childResults) {
    286                         CodeStore code = new CodeStore();
    287                        
    288                         assert node.nChildren() == 1;
    289                         ASTNode child = node.child(0);
    290                         CodeStore childCode = (CodeStore) childResults.get(0);
    291                        
    292                         switch(node.getCardinality()) {
    293                         case ONE:
    294                                 code.addAll(childCode, 0);
    295                                 break;
    296                         case ONE_OR_MORE:
    297                                 code.addLine("do {");
    298                                 code.addAll(childCode, 1);
    299                                 code.dedentedLine("} while( " + startCondition(child) +" );");
    300                                 break;
    301                         case ZERO_OR_MORE:
    302                                 code.addLine( "while( " + startCondition(child) +" ) {");
    303                                 code.addAll(childCode, 1);
    304                                 code.dedentedLine("}");
    305                                 break;
    306                         case ZERO_OR_ONE:
    307                                 code.addLine("if( " + startCondition(child) +" ) {");
    308                                 code.addAll(childCode, 1);
    309                                 code.dedentedLine("}");
    310                                 break;
    311                         }
    312                         return code;
    313                 }
    314                
    315                 public CodeStore visitLeave(ProductionNode node, List<CodeStore> childResults) {
    316                         CodeStore code = new CodeStore();
    317                         CodeStore bodyCode = (CodeStore) childResults.get(1);
    318                        
    319                         Nonterminal head = node.head();
    320                        
    321                         code.addLine("public ASTNode " + head.getParseMethodName() + "() {");
    322                         addGuard(code, head);
    323                         code.indentedLine("boolean allowCompression = true;");
    324                         code.addLine("ASTNode result = new " + head.getNodeClass().getName() + "(nowReading);");
    325                         code.addLine("result.setProductionTag(" + head.ordinal() + ");");
    326                         code.addLine("RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();");
    327                         code.addAll(bodyCode, 0);
    328                         addReturnLine(code, head);
    329                         code.dedentedLine("}");
    330                         return code;
    331                 }
    332 
    333                 private void addReturnLine(CodeStore code, Nonterminal head) {
    334                         code.addLine("if(allowCompression) {");
    335                         if(head.compressible()) {
    336                                 code.indentedLine("return compressIfPossible(result);");
    337                         }
    338                         else{
    339                                 code.indentedLine("return result;");
    340                         }
    341                         code.dedentedLine("}");
    342                         code.addLine("return result;");
    343                 }
    344                 // needed because scala seems to erase the parameter type on Terminal's
    345                 // implementation of Comparable<Terminal>
    346                 class TerminalComparator implements Comparator<Terminal> {
    347                         @Override
    348                         public int compare(Terminal o1, Terminal o2) {
    349                                 return o1.compareTo(o2);
    350                         }
    351                 }
    352 
    353                 private void addGuard(CodeStore code, Nonterminal head) {
    354                         if(head.isNullable()) {
    355                                 return;
    356                         }
    357                         Set<Terminal> starters = head.getTerminalStarters();
    358                         List<Terminal> sortedStarters = new ArrayList<Terminal>(starters);
    359                         Collections.sort(sortedStarters, new TerminalComparator());
    360                         String condition = Terminal.tokenSetCondition(starters, "nowReading");
    361                        
    362                         code.indentedLine("if( !(" + condition + ") ) {");
    363                         code.indentedLine("return syntaxErrorNode(\"" + head + " " + sortedStarters + "\");");
    364                         code.dedentedLine("}");
    365                         code.dedentedLine("");
    366                 }
    367 
    368                 private String startCondition(ASTNode branch) {
    369                         Set<Symbol> starters = XStarters.startingSymbols(branch);
    370                         Set<Terminal> terminals = terminalsOf(starters);
    371                        
    372                         if(terminals.isEmpty()) {
    373                                 return "true";
    374                         }
    375                        
    376                         return terminalTest(terminals);
    377                 }
    378 
    379                 //////////////////////////////////////////////////////////////////////////////////////
    380                 // ContextableSymbol
    381                 public void visitEnter(ContextableSymbolNode node) {
    382                         node.skipChildren();
    383                 }
    384                 public CodeStore visitLeave(ContextableSymbolNode node, List<CodeStore> childResults) {
    385                         CodeStore code = new CodeStore();
    386                         addContextPushOrPop(code, node);       
    387                         code.addAll(node.child(0).accept(this), 0);
    388                        
    389                         return code;
    390                 }
    391 
    392                 private void addContextPushOrPop(CodeStore code, ContextableSymbolNode node) {
    393                         if(node.nChildren()==2) {
    394                                 IdentifierNode contextName = (IdentifierNode)node.child(1);
    395                                 String newContextName = contextName.getIdentifier();
    396                                 code.addLine("lexController.pushTo(\"" + newContextName + "\");");
    397                         }
    398                         else {
    399                                 assert node.nChildren() == 1;
    400                                 code.addLine("lexController.pop();");
    401                         }
    402                 }
    403                 //////////////////////////////////////////////////////////////////////////////////////
    404                 // identifier visit is last because it is decomposed into several submethods.
    405                 //
    406                 public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) {
    407                         if(inAction || inRecognizers) {
    408                                 return null;
    409                         }
    410                         CodeStore code = new CodeStore();
    411                         Symbol symbol = node.getSymbol();
    412                        
    413                         if(symbol.isTerminal()) {
    414                                 visitTerminalIdentifier(code, node, (Terminal)symbol);
    415                         }
    416                         else {
    417                                 visitNonterminalIdentifier(node, code, (Nonterminal)symbol);
    418                         }
    419                         return code;
    420                 }
    421 
    422                 private void visitTerminalIdentifier(CodeStore code, IdentifierNode node, Terminal terminal) {
    423                         if(terminal.isClassType()) {
    424                                 addClassTerminalGuard(code, terminal);  // compensates for no "expect" taking classes.
    425                                 possiblyRaiseTerminalToken(node, code);
    426                                 possiblySwitchContexts(node, code);
    427                                 code.addLine("readToken();");
    428                         }
    429                         else {
    430                                 possiblyRaiseTerminalToken(node, code);
    431                                 possiblySwitchContexts(node, code);
    432                                 code.addLine("expect(" + terminal.lextantName() + ");");
    433                         }
    434                 }
    435 
    436                 private void addClassTerminalGuard(CodeStore code, Terminal terminal) {
    437                         String test = terminalTest(terminal);
    438                         code.addLine(     "if( !" + test + " ) {");
    439                         code.indentedLine("return syntaxErrorNode(" + quoted(terminal.getLexeme()) + ");");
    440                         code.dedentedLine("}");
    441                 }
    442                 private void possiblyRaiseTerminalToken(IdentifierNode node, CodeStore code) {
    443                         if(node.raiseToken()) {
    444                                 code.addLine("result.setToken(nowReading);");
    445                         }
    446                         if(!node.allowParentCompression()) {
    447                                 code.addLine("allowCompression = false;");
    448                         }
    449                 }
    450                 private void possiblySwitchContexts(IdentifierNode node, CodeStore code) {
    451                         if(node.isContextChange()) {
    452                                 if(node.newContext() == "") {
    453                                         code.addLine("lexController.pop();");
    454                                 }
    455                                 else {
    456                                         code.addLine("lexController.pushTo(\"" + node.newContext() +"\");");
    457                                 }
    458                         }
    459                 }
    460                
    461                 private void visitNonterminalIdentifier(IdentifierNode node,
    462                                 CodeStore code, Nonterminal nonterminal) {
    463                         code.addLine("{");
    464                         code.indentedLine("ASTNode child = " + nonterminal.getParseMethodName() + "();");
    465                         if(node.getOmit()) {
    466                                 code.addLine("// node omitted - no result.appendChild(child);");
    467                         }
    468                         else {
    469                                 code.addLine("result.appendChild(child);");
    470                         }
    471                         code.addLine("allChildren.add(child);");
    472                         if(node.raiseToken()) {
    473                                 code.addLine("result.setToken( child.getToken() );");
    474                         }
    475                         if(!node.allowParentCompression()) {
    476                                 code.addLine("allowCompression = false;");
    477                         }
    478                         code.dedentedLine("}");
    479                 }
    480                 /////////////////////////////////////////////////////////////////////////////
    481                 // utilities
    482                
    483                 private Set<Terminal> terminalsOf(Set<Symbol> starters) {
    484                         Set<Terminal> result = new HashSet<Terminal>();
    485                         for(Symbol symbol: starters) {
    486                                 if(symbol.isTerminal()) {
    487                                         result.add((Terminal)symbol);
    488                                 }
    489                         }
    490                         return result;
    491                 }
    492                 private String quoted(String string) {
    493                         return "\"" + string + "\"";
    494                 }
    495 
    496                 private String terminalTest(Symbol symbol) {
    497                         Terminal terminal = (Terminal) symbol;
    498                         return terminal.tokenCondition("nowReading");
    499                 }
    500                 private String terminalTest(Set<Terminal> terminals) {
    501                         return Terminal.tokenSetCondition(terminals, "nowReading");
    502                 }
    503 
    504 
    505                 /////////////////////////////////////////////////////////////////////////////
    506                 // errors
    507 
    508 */             
    509                
    510         }
    51140}
  • proto/pablo/src/compiler/templating/FileTemplate.java

    r2421 r2607  
    66
    77public class FileTemplate implements Template {
    8         // in the file, variables must start with VARIABLE_DELIMITER followed immediately by VARIABLE_START_CHAR. ("###@")
    9         // they must end with (optional) whitespace and (required) VARIABLE_DELIMITER. ("###")
     8        // Template variables begin with VARIABLE_DELIMITER and followed by VARIABLE_START_CHAR.
     9        // Template variables end with (optional) whitespace and (required) VARIABLE_DELIMITER.
    1010       
    11         private static final String VARIABLE_DELIMITER = "###";
     11        private static final String VARIABLE_DELIMITER = "%";
    1212        private static final char VARIABLE_START_CHAR = '@';
    1313        private MemoryTemplate template;
    1414
    1515        static String templateDirectory = ".";
     16       
    1617        public static void setTemplateDirectory(String directory) {
    1718                templateDirectory = directory;
    1819        }
     20       
    1921        private static String templateFilename(String filename) {
    2022                return templateDirectory + "/" + filename;
     
    4042                }
    4143        }
     44       
    4245        private boolean isAVariable(String piece) {
    4346                return !piece.isEmpty() && (piece.charAt(0) == VARIABLE_START_CHAR);
    4447        }
     48       
    4549        private String getVariableName(String piece) {
    4650                return piece.substring(1).trim();
     
    5963        }
    6064       
    61         ////////////////////////////////////////////////////////////////////
    6265        // The Template implementation just delegates to the MemoryTemplate
    6366       
     
    7578        }
    7679
    77 
    7880}
  • proto/pablo/src/compiler/visitors/AdvanceCombiner.java

    r2598 r2607  
    1010public class AdvanceCombiner {
    1111       
    12     private ASTNode ASTree;
     12    private ASTNode ASTTree;
    1313   
    14     public AdvanceCombiner(ASTNode ASTree) {
    15         this.ASTree = ASTree;
     14    public AdvanceCombiner(ASTNode astTree) {
     15        this.ASTTree = astTree;
    1616    }
    1717   
    1818    public void transform() {
    1919        AdvanceCombinerVisitor visitor = new AdvanceCombinerVisitor();
    20         ASTree.accept(visitor);
     20        ASTTree.accept(visitor);
    2121    }   
    2222   
  • proto/pablo/src/compiler/visitors/Bitwise2IDISA.java

    r2460 r2607  
    2727                               
    2828                                FunctionInvocationNode functionInvocationNode = Generators.makeFunctionInvocationNode(SIMD.NOT.idisaName(), op);
    29                                 functionInvocationNode.appendChild(Accessors.Operand(node));
     29                                functionInvocationNode.appendChild(Accessors.operand(node));
    3030                                node.updateSelf(functionInvocationNode);
    3131                        }
  • proto/pablo/src/parser/Parser.java

    r2462 r2607  
    7676       
    7777                boolean allowCompression = true;
    78                 ASTNode result = new ASTNode(nowReading);
     78                ASTNode result = new DeclarationsNode(nowReading);
    7979                result.setProductionTag(2);
    8080                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    9595                expect(Lextant.TERMINATOR);
    9696                if(allowCompression) {
    97                         return compressIfPossible(result);
     97                        return result;
    9898                }
    9999                return result;
     
    197197                }
    198198                expect(Lextant.LROUND);
     199                {
     200                        ASTNode child = parseParameterList();
     201                        result.appendChild(child);
     202                        allChildren.add(child);
     203                }
     204                expect(Lextant.RROUND);
     205                {
     206                        ASTNode child = parseBlockStatement();
     207                        result.appendChild(child);
     208                        allChildren.add(child);
     209                }
     210                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
     211                        expect(Lextant.TERMINATOR);
     212                }
     213                if(allowCompression) {
     214                        return result;
     215                }
     216                return result;
     217        }
     218         
     219        public ASTNode parseReturnType() {
     220                if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
     221                        return syntaxErrorNode("returnType² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     222                }
     223       
     224                boolean allowCompression = true;
     225                ASTNode result = new ASTNode(nowReading);
     226                result.setProductionTag(7);
     227                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     228                {
     229                        ASTNode child = parseType();
     230                        result.appendChild(child);
     231                        allChildren.add(child);
     232                }
     233                if(allowCompression) {
     234                        return compressIfPossible(result);
     235                }
     236                return result;
     237        }
     238         
     239        public ASTNode parseParameterList() {
     240                boolean allowCompression = true;
     241                ASTNode result = new ParameterListNode(nowReading);
     242                result.setProductionTag(8);
     243                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    199244                if( nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    200245                        {
     
    212257                        }
    213258                }
    214                 expect(Lextant.RROUND);
    215                 {
    216                         ASTNode child = parseBlockStatement();
    217                         result.appendChild(child);
    218                         allChildren.add(child);
    219                 }
    220                 if( nowReading.isLextant(Lextant.TERMINATOR) ) {
    221                         expect(Lextant.TERMINATOR);
    222                 }
    223                 if(allowCompression) {
    224                         return result;
    225                 }
    226                 return result;
    227         }
    228          
    229         public ASTNode parseReturnType() {
    230                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    231                         return syntaxErrorNode("returnType² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    232                 }
    233        
    234                 boolean allowCompression = true;
    235                 ASTNode result = new ASTNode(nowReading);
    236                 result.setProductionTag(7);
    237                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    238                 {
    239                         ASTNode child = parseType();
    240                         result.appendChild(child);
    241                         allChildren.add(child);
    242                 }
    243                 if(allowCompression) {
    244                         return compressIfPossible(result);
    245                 }
    246                 return result;
    247         }
    248          
    249         public ASTNode parseTypeList() {
    250                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    251                         return syntaxErrorNode("typeList² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    252                 }
    253        
    254                 boolean allowCompression = true;
    255                 ASTNode result = new TypeListNode(nowReading);
    256                 result.setProductionTag(8);
    257                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    258                 {
    259                         ASTNode child = parseType();
    260                         result.appendChild(child);
    261                         allChildren.add(child);
    262                 }
    263                 while( nowReading.isLextant(Lextant.COMMA) ) {
    264                         expect(Lextant.COMMA);
    265                         {
    266                                 ASTNode child = parseType();
    267                                 result.appendChild(child);
    268                                 allChildren.add(child);
    269                         }
    270                 }
    271259                if(allowCompression) {
    272260                        return result;
     
    401389                        }
    402390                }
    403                 else if( nowReading.isLextant(Lextant.VAR) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     391                else if( nowReading.isLextant(Lextant.VAR) ) {
    404392                        {
    405393                                ASTNode child = parseLocalVarDecl();
     
    618606         
    619607        public ASTNode parseLocalVarDecl() {
    620                 if( !(nowReading.isLextant(Lextant.VAR) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    621                         return syntaxErrorNode("localVarDecl² [IDENTIFIER¹, VAR¹]");
     608                if( !(nowReading.isLextant(Lextant.VAR)) ) {
     609                        return syntaxErrorNode("localVarDecl² [VAR¹]");
    622610                }
    623611       
     
    626614                result.setProductionTag(21);
    627615                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    628                 if( nowReading.isLextant(Lextant.VAR) ) {
    629                         expect(Lextant.VAR);
    630                         {
    631                                 ASTNode child = parseType();
    632                                 result.appendChild(child);
    633                                 allChildren.add(child);
    634                         }
    635                         {
    636                                 ASTNode child = parseLocalVarDeclList();
    637                                 result.appendChild(child);
    638                                 allChildren.add(child);
    639                         }
    640                         expect(Lextant.TERMINATOR);
    641                 }
    642                 else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    643                         {
    644                                 ASTNode child = parseVariableName();
    645                                 result.appendChild(child);
    646                                 allChildren.add(child);
    647                         }
    648                         if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    649                                 {
    650                                         ASTNode child = parseAssignmentOperator();
    651                                         result.appendChild(child);
    652                                         allChildren.add(child);
    653                                 }
    654                                 {
    655                                         ASTNode child = parseExpression();
    656                                         result.appendChild(child);
    657                                         allChildren.add(child);
    658                                 }
    659                         }
    660                 }
    661                 if(allowCompression) {
    662                         return result;
    663                 }
    664                 return result;
    665         }
    666          
    667         public ASTNode parseLocalVarDeclList() {
    668                 if( !(nowReading.isLextant(Lextant.VAR) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    669                         return syntaxErrorNode("localVarDeclList² [IDENTIFIER¹, VAR¹]");
    670                 }
    671        
    672                 boolean allowCompression = true;
    673                 ASTNode result = new LocalVarDeclListNode(nowReading);
    674                 result.setProductionTag(22);
    675                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    676                 {
    677                         ASTNode child = parseLocalVarDecl();
    678                         result.appendChild(child);
    679                         allChildren.add(child);
    680                 }
    681                 while( nowReading.isLextant(Lextant.COMMA) ) {
    682                         expect(Lextant.COMMA);
    683                         {
    684                                 ASTNode child = parseLocalVarDecl();
     616                expect(Lextant.VAR);
     617                {
     618                        ASTNode child = parseType();
     619                        result.appendChild(child);
     620                        allChildren.add(child);
     621                }
     622                {
     623                        ASTNode child = parseVariableName();
     624                        result.appendChild(child);
     625                        allChildren.add(child);
     626                }
     627                if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
     628                        {
     629                                ASTNode child = parseAssignmentOperator();
     630                                result.appendChild(child);
     631                                allChildren.add(child);
     632                        }
     633                        {
     634                                ASTNode child = parseExpression();
    685635                                result.appendChild(child);
    686636                                allChildren.add(child);
     
    700650                boolean allowCompression = true;
    701651                ASTNode result = new ASTNode(nowReading);
    702                 result.setProductionTag(23);
     652                result.setProductionTag(22);
    703653                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    704654                {
     
    720670                boolean allowCompression = true;
    721671                ASTNode result = new BinaryOperatorNode(nowReading);
    722                 result.setProductionTag(24);
     672                result.setProductionTag(23);
    723673                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    724674                {
     
    755705                boolean allowCompression = true;
    756706                ASTNode result = new BinaryOperatorNode(nowReading);
    757                 result.setProductionTag(25);
     707                result.setProductionTag(24);
    758708                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    759709                {
     
    784734                boolean allowCompression = true;
    785735                ASTNode result = new UnaryOperatorNode(nowReading);
    786                 result.setProductionTag(26);
     736                result.setProductionTag(25);
    787737                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    788738                if( nowReading.isLextant(Lextant.NOT) ) {
     
    810760                boolean allowCompression = true;
    811761                ASTNode result = new ASTNode(nowReading);
    812                 result.setProductionTag(27);
     762                result.setProductionTag(26);
    813763                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    814764                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    857807                boolean allowCompression = true;
    858808                ASTNode result = new FunctionInvocationNode(nowReading);
    859                 result.setProductionTag(28);
     809                result.setProductionTag(27);
    860810                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    861811                result.setToken(nowReading);
     
    890840                boolean allowCompression = true;
    891841                ASTNode result = new ASTNode(nowReading);
    892                 result.setProductionTag(29);
     842                result.setProductionTag(28);
    893843                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    894844                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    919869                boolean allowCompression = true;
    920870                ASTNode result = new ASTNode(nowReading);
    921                 result.setProductionTag(30);
     871                result.setProductionTag(29);
    922872                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    923873                if( nowReading.isLextant(Lextant.MINUS) ) {
     
    959909                boolean allowCompression = true;
    960910                ASTNode result = new IntegerConstantNode(nowReading);
    961                 result.setProductionTag(31);
     911                result.setProductionTag(30);
    962912                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    963913                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    985935                boolean allowCompression = true;
    986936                ASTNode result = new StringConstantNode(nowReading);
    987                 result.setProductionTag(32);
     937                result.setProductionTag(31);
    988938                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    989939                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    1012962                boolean allowCompression = true;
    1013963                ASTNode result = new CompoundVariableNode(nowReading);
    1014                 result.setProductionTag(33);
     964                result.setProductionTag(32);
    1015965                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1016966                {
     
    1041991                boolean allowCompression = true;
    1042992                ASTNode result = new IdentifierNode(nowReading);
    1043                 result.setProductionTag(34);
     993                result.setProductionTag(33);
    1044994                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1045995                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    10591009       
    10601010                boolean allowCompression = true;
    1061                 ASTNode result = new TypeNode(nowReading);
    1062                 result.setProductionTag(35);
     1011                ASTNode result = new ASTNode(nowReading);
     1012                result.setProductionTag(34);
    10631013                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10641014                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    10771027                }
    10781028                else if( nowReading.isLextant(Lextant.VOID) ) {
    1079                         expect(Lextant.VOID);
     1029                        {
     1030                                ASTNode child = parseVoid();
     1031                                result.appendChild(child);
     1032                                allChildren.add(child);
     1033                        }
    10801034                }
    10811035                else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    10871041                }
    10881042                if(allowCompression) {
    1089                         return result;
     1043                        return compressIfPossible(result);
    10901044                }
    10911045                return result;
     
    10991053                boolean allowCompression = true;
    11001054                ASTNode result = new StreamTypeNode(nowReading);
    1101                 result.setProductionTag(36);
     1055                result.setProductionTag(35);
    11021056                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11031057                expect(Lextant.STREAM);
     
    11241078                boolean allowCompression = true;
    11251079                ASTNode result = new FieldWidthNode(nowReading);
    1126                 result.setProductionTag(37);
     1080                result.setProductionTag(36);
    11271081                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11281082                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    11431097                boolean allowCompression = true;
    11441098                ASTNode result = new ASTNode(nowReading);
    1145                 result.setProductionTag(38);
     1099                result.setProductionTag(37);
    11461100                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11471101                {
     
    11631117                boolean allowCompression = true;
    11641118                ASTNode result = new StructTypeNode(nowReading);
    1165                 result.setProductionTag(39);
     1119                result.setProductionTag(38);
    11661120                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11671121                expect(Lextant.STRUCT);
     
    11721126                }
    11731127                if( nowReading.isLextant(Lextant.LCURLY) ) {
    1174                         expect(Lextant.LCURLY);
    11751128                        {
    11761129                                ASTNode child = parseStructTypeBody();
     
    11781131                                allChildren.add(child);
    11791132                        }
    1180                         expect(Lextant.RCURLY);
    11811133                }
    11821134                if(allowCompression) {
     
    11931145                boolean allowCompression = true;
    11941146                ASTNode result = new ASTNode(nowReading);
     1147                result.setProductionTag(39);
     1148                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1149                {
     1150                        ASTNode child = parseIdentifier();
     1151                        result.appendChild(child);
     1152                        allChildren.add(child);
     1153                }
     1154                if(allowCompression) {
     1155                        return compressIfPossible(result);
     1156                }
     1157                return result;
     1158        }
     1159         
     1160        public ASTNode parseStructTypeBody() {
     1161                if( !(nowReading.isLextant(Lextant.LCURLY)) ) {
     1162                        return syntaxErrorNode("structTypeBody² [LCURLY¹]");
     1163                }
     1164       
     1165                boolean allowCompression = true;
     1166                ASTNode result = new StructTypeBodyNode(nowReading);
    11951167                result.setProductionTag(40);
    11961168                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1197                 {
    1198                         ASTNode child = parseIdentifier();
    1199                         result.appendChild(child);
    1200                         allChildren.add(child);
    1201                 }
    1202                 if(allowCompression) {
    1203                         return compressIfPossible(result);
    1204                 }
    1205                 return result;
    1206         }
    1207          
    1208         public ASTNode parseStructTypeBody() {
    1209                 if( !(nowReading.isLextant(Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    1210                         return syntaxErrorNode("structTypeBody² [IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    1211                 }
    1212        
    1213                 boolean allowCompression = true;
    1214                 ASTNode result = new StructTypeBodyNode(nowReading);
    1215                 result.setProductionTag(41);
    1216                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1169                expect(Lextant.LCURLY);
    12171170                {
    12181171                        ASTNode child = parseStructMember();
     
    12291182                        expect(Lextant.TERMINATOR);
    12301183                }
     1184                expect(Lextant.RCURLY);
    12311185                if(allowCompression) {
    12321186                        return result;
     
    12421196                boolean allowCompression = true;
    12431197                ASTNode result = new StructMemberNode(nowReading);
    1244                 result.setProductionTag(42);
     1198                result.setProductionTag(41);
    12451199                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12461200                {
     
    12671221                boolean allowCompression = true;
    12681222                ASTNode result = new ASTNode(nowReading);
     1223                result.setProductionTag(42);
     1224                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     1225                {
     1226                        ASTNode child = parseIdentifier();
     1227                        result.appendChild(child);
     1228                        allChildren.add(child);
     1229                }
     1230                if(allowCompression) {
     1231                        return compressIfPossible(result);
     1232                }
     1233                return result;
     1234        }
     1235         
     1236        public ASTNode parseVoid() {
     1237                if( !(nowReading.isLextant(Lextant.VOID)) ) {
     1238                        return syntaxErrorNode("void² [VOID¹]");
     1239                }
     1240       
     1241                boolean allowCompression = true;
     1242                ASTNode result = new VoidNode(nowReading);
    12691243                result.setProductionTag(43);
    12701244                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    1271                 {
    1272                         ASTNode child = parseIdentifier();
    1273                         result.appendChild(child);
    1274                         allChildren.add(child);
    1275                 }
    1276                 if(allowCompression) {
    1277                         return compressIfPossible(result);
     1245                expect(Lextant.VOID);
     1246                if(allowCompression) {
     1247                        return result;
    12781248                }
    12791249                return result;
Note: See TracChangeset for help on using the changeset viewer.