Changeset 2917


Ignore:
Timestamp:
Mar 10, 2013, 12:37:08 AM (5 years ago)
Author:
ksherdy
Message:

Updated and simplified application generation.

Location:
proto/pabloj/trunk/src
Files:
2 added
5 deleted
19 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/applicationGenerator/ApplicationGenerator.java

    r2834 r2917  
    77import java.io.FileOutputStream;
    88import java.io.PrintStream;
     9
     10import applicationGenerator.helpers.FileUtil;
    911
    1012import compiler.codeGenerator.visitors.CPPUnparser;
     
    2123
    2224public class ApplicationGenerator {
    23        
    24         public final static String generatedCodeWarning = "// DO NOT MODIFY\n//\n// Generated code.\n";
    25        
    26 //  private static final String LOGGING_DIRECTORY          = "logging";
    27 //  private static final String APPLICATIONS_DIRECTORY     = "applications";
    28        
     25                       
    2926    private CompilerConfig compilerConfig;
    3027   
     
    3330       
    3431        public ApplicationGenerator(CompilerConfig applicationConfiguration) {
    35                 pabloS.tokens.Tokens.setPrintLevel(pabloS.tokens.Tokens.Level.FULL);
    36                
    37                
     32                pabloS.tokens.Tokens.setPrintLevel(pabloS.tokens.Tokens.Level.FULL);           
    3833                this.compilerConfig = applicationConfiguration;
    39                 OutputCodeDirectory.setWarningMessage(generatedCodeWarning);
    4034        }
    4135       
     
    5044        public void generate() throws SyntacticAnalysisFailedException {
    5145
     46                SymbolTable symbolTable                         = new SymbolTable();   
     47               
    5248                // Transformation configuration
    53                 Builtins2Lang builtins2Lang = null;
     49                Builtins2Lang builtins2Lang             = null;
    5450                CarrySetBuiltins2Lang carrySet2Lang = null;
    55                 Unparser unparser = null;
    56 
     51                Unparser unparser                                       = null;
     52               
     53               
    5754                if(compilerConfig.targetLang.contentEquals(CompilerConfig.CLANG)) {
    5855                        //builtins2Lang = new Builtins2C();
    5956                        //carrySet2Lang = new CarrySet2C();
    6057                        //unparser = new CUnparser();
    61                 } else {
     58                } else { // default C++
    6259                        builtins2Lang = new Builtins2CPP();
    6360                        carrySet2Lang = new CarrySetBuiltins2CPP();
     61                        unparser          = new CPPUnparser(symbolTable);
    6462                }               
    6563
     
    6866
    6967                // Build Carry Information Set symbol table
    70                 //
    7168                // TODO - carry_count, advance_n_count, add symbol table to root node
    72                 //
    73                 SymbolTable symbolTable = new SymbolTable();
    7469               
    7570                CarryInfoSetVisitor carryInfoSetVisitor = new CarryInfoSetVisitor(syntaxTree, symbolTable);
     
    9186                pabloB.ast.ASTNode pabloBASTTree = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
    9287               
    93 
    94                                
    95                 // Fill template               
    96                 String outputDirectory = ensureEndsWith(compilerConfig.outputDirectory + compilerConfig.targetLang, File.separator);
    97                 String templateDirectory = ensureEndsWith(compilerConfig.templateDirectory, File.separator);
    98                 String templateFile = templateDirectory + compilerConfig.templateFile;
     88       
     89                String outputDirectory          = ensureEndsWith(compilerConfig.outputDirectory + compilerConfig.targetLang, File.separator);
     90                String templateDirectory        = ensureEndsWith(compilerConfig.templateDirectory, File.separator);
     91                String templateFilePath         = templateDirectory + compilerConfig.templateFile;
     92                String targetFilePath           = outputDirectory + FileUtil.replaceFileNameExtension(new File(compilerConfig.templateFile).getName(), ".hpp"); 
    9993               
    10094                HeaderTemplateContentsGenerator contentsGenerator =
    101                                 new HeaderTemplateContentsGenerator((pabloB.ast.ProgramNode)pabloBASTTree, symbolTable, outputDirectory, templateFile);
     95                                new HeaderTemplateContentsGenerator((pabloB.ast.ProgramNode)pabloBASTTree,
     96                                                                                                        unparser,
     97                                                                                                        outputDirectory,
     98                                                                                                        templateFilePath,
     99                                                                                                        targetFilePath);       
    102100               
    103101                contentsGenerator.generate();
  • proto/pabloj/trunk/src/applicationGenerator/CompilerConfig.java

    r2834 r2917  
     1/**
     2 * Application configuration POD (plain old data).
     3 *
     4 * Specifies the application configuration to the application generator.
     5 *
     6 * @author Ken Herdy <ksherdy at sfu dot ca>
     7 */
     8
    19package applicationGenerator;
    210
     
    412
    513        // Warning Message
    6         public static final String WARNING_MESSAGE = "GENERATED CODE. DO NOT MODIFY.";
     14        public static final String COMPILERNAME                 = "PabloJ";     
     15        public static final String WARNING_MESSAGE      = "GENERATED CODE. DO NOT MODIFY.";
     16        public static final int EXIT_CODE_FOR_ERROR     = 1;
    717       
    8         // Directory structure
    9         public static final String OUTPUT_DIRECTORY = "output/";
    10         public static final String TEMPLATES_DIRECTORY = "src/applicationGenerator/templates/";
    11        
     18        // Compiler directory structure
     19        public static final String OUTPUT_DIRECTORY             = "output/";
     20        public static final String TEMPLATES_DIRECTORY  = "input/templates/";
     21        public static final String CPPLANG                              = "cpplang";
     22        public static final String CLANG                                        = "clang";
     23               
    1224        // Options
    13         public static final String CLANG = "clang";
    14         public static final String CPPLANG = "cpplang";
    15                
    16         public Boolean addAssertBitBlockAlignStmts;
    17         public Boolean addDumpStmts;
    18         public String errorRoutine;
    19        
    2025        public String inputFile;
    2126    public String templateFile;
     
    2328    public String outputFile;           
    2429        public String outputDirectory;   
    25         // public String targetDirectory;
    26        
     30
    2731        public String targetLang;
     32               
     33        // Debug Options
     34        public Boolean addAssertBitBlockAlignStmts;
     35        public Boolean addDumpStmts;
     36        public String errorRoutine;     
     37
    2838}
     39
     40
  • proto/pabloj/trunk/src/applicationGenerator/CompilerConfigFactory.java

    r2834 r2917  
    1313        compilerConfig.inputFile = cli.getOptionValue("i");
    1414
    15         // target lang specific defaults
     15        // set defaults
     16        compilerConfig.outputDirectory = cli.getOptionValue("O", CompilerConfig.OUTPUT_DIRECTORY);
    1617        compilerConfig.targetLang = cli.getOptionValue("x", CompilerConfig.CPPLANG);
    17         compilerConfig.outputDirectory = cli.getOptionValue("O", CompilerConfig.OUTPUT_DIRECTORY);
    1818       
    19         if (compilerConfig.targetLang.equals(CompilerConfig.CLANG)) { // C
     19        if (compilerConfig.targetLang.equals(CompilerConfig.CLANG)) { // C language
    2020                compilerConfig.templateFile = cli.getOptionValue("t", "pablo_definitions.template");
    21                 compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + "C" + File.separator);
     21                compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + CompilerConfig.CLANG + File.separator);
    2222                compilerConfig.outputFile = cli.getOptionValue("o", "code.c");
    2323                //compilerConfig.targetDirectory = cli.getOptionValue("O", CompilerConfig.CLANG);
    24         } else { // CPP
     24               
     25        } else { // C++ language - default
    2526                compilerConfig.templateFile = cli.getOptionValue("t", "pablo_definitions.template");
    26                 compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + "CPP" + File.separator);
     27                compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + CompilerConfig.CPPLANG + File.separator);
    2728                compilerConfig.outputFile = cli.getOptionValue("o", "code.cpp");
    2829                //compilerConfig.targetDirectory = cli.getOptionValue("O", CompilerConfig.CPPLANG);
  • proto/pabloj/trunk/src/applicationGenerator/CompilerOptions.java

    r2834 r2917  
     1/**
     2 * Command line options.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
    16package applicationGenerator;
    2 
    37
    48import org.apache.commons.cli.HelpFormatter;
     
    610import org.apache.commons.cli.OptionBuilder;
    711import org.apache.commons.cli.Options;
    8 
    9 
    1012
    1113public class CompilerOptions { 
     
    4850                        // Output directory "L"
    4951                       
    50                         // template base directory "T"
     52                        // Template directory "T"
    5153                       
    5254                    OptionBuilder.hasArg(true);
    5355                    OptionBuilder.isRequired(false);
    5456                    OptionBuilder.withLongOpt("error");
    55                     OptionBuilder.withDescription("Name/qualified name for error routine.");
     57                    OptionBuilder.withDescription("Name/qualified name of error routine.");
    5658                        option = OptionBuilder.create("e");
    5759                        options.addOption(option);
     
    6062                    OptionBuilder.isRequired(false);
    6163                    OptionBuilder.withLongOpt("align");
    62                     OptionBuilder.withDescription("Add ASSERT_BITBLOCK_ALIGN Stmts.");
     64                    OptionBuilder.withDescription("Add ASSERT_BITBLOCK_ALIGN statments.");
    6365                        option = OptionBuilder.create("a");
    6466                        options.addOption(option);                     
     
    6769                    OptionBuilder.isRequired(false);
    6870                    OptionBuilder.withLongOpt("dump");
    69                     OptionBuilder.withDescription("Add SIMD register dump Stmts.");
     71                    OptionBuilder.withDescription("Add SIMD register dump statements.");
    7072                        option = OptionBuilder.create("d");
    7173                        options.addOption(option);                     
     
    7476                    OptionBuilder.isRequired(false);
    7577                    OptionBuilder.withLongOpt("language");
    76                     OptionBuilder.withDescription("Target language. Permissible languages include: 'cpp'.");
     78                    OptionBuilder.withDescription("Target language. Targets include: 'cpplang', 'clang (not yet supported)'.");
    7779                        option = OptionBuilder.create("x");
    7880                        options.addOption(option);                             
     
    8183                  }
    8284
    83           public static void exitWithUsageMessage(Options options) {
    84             HelpFormatter h = new HelpFormatter();
    85             h.printHelp("java " + PabloJ.COMPILERNAME + "\n", options);
    86             System.exit(PabloJ.EXIT_CODE_FOR_ERROR);
     85          public static void usageMessage(Options options) {
     86                  HelpFormatter h = new HelpFormatter();
     87                  h.printHelp("java " + CompilerConfig.COMPILERNAME + "\n", options);   
    8788          }       
    88          
    8989}
  • proto/pabloj/trunk/src/applicationGenerator/HeaderTemplateContentsGenerator.java

    r2834 r2917  
    33import pabloB.ast.*;
    44
     5import applicationGenerator.helpers.FileUtil;
    56import compiler.ast.pabloB.Accessors;
    67import compiler.codeGenerator.visitors.CPPUnparser;
     8import compiler.codeGenerator.visitors.Unparser;
    79import compiler.symbols.SymbolTable;
    810import compiler.template.FileTemplate;
    9 import compiler.template.MemoryTemplate;
    1011import compiler.template.Template;
    1112
    1213import java.io.File;
     14import java.io.IOException;
    1315import java.io.PrintStream;
    1416import java.util.List;
     
    1618public class HeaderTemplateContentsGenerator extends TemplateContentsGenerator {
    1719   
    18         public HeaderTemplateContentsGenerator(ProgramNode ASTTree,
    19                         SymbolTable symbolTable,
    20                         String outputDirectory,
    21                         String templateFile) {
    22                 super(ASTTree, symbolTable, outputDirectory, templateFile);
     20        public HeaderTemplateContentsGenerator( ProgramNode programNode,
     21                                                                                        Unparser unparser,
     22                                                                                        String outputDirectory,
     23                                                                                        String templateFilePath,
     24                                                                                        String targetFilePath) {
     25               
     26                super(programNode, unparser, outputDirectory, templateFilePath, targetFilePath);
    2327        }
    2428
    2529        public void generate() {
    2630               
    27                  OutputCodeDirectory outputCodeDirectory = new OutputCodeDirectory(outputDirectory);
    28                  
    29                  String targetFileName = replaceFileNameExtension(new File(templateFile).getName(), ".hpp");
    30                  outputCodeDirectory.generateFile(new HeaderContentsGenerator(ASTTree, symbolTable), targetFileName);                           
     31                FileUtil.makeDirectories(outputDirectory);
     32               
     33                String templateName = FileUtil.getBaseName(new File(templateFilePath).getName());
     34                Template template = new FileTemplate(templateName, templateFilePath);
     35               
     36                template.set("warningComment", CompilerConfig.WARNING_MESSAGE);
     37               
     38                String globalDefinitions = makeGlobalDefinitions();
     39                template.set("global", globalDefinitions);
     40               
     41                PrintStream     out = makePrintStreamFromFilename(targetFilePath);
     42                template.print(out);
     43        }
     44       
     45        private String makeGlobalDefinitions() {
     46                                       
     47                StringBuffer codeBuffer = new StringBuffer();
     48
     49                List<StructTypeNode> structTypeDeclNodes = Accessors.structTypeDeclNodes(programNode);
     50                for(StructTypeNode structTypeNode : structTypeDeclNodes) {
     51                        codeBuffer.append(unparser.getCode(structTypeNode));
     52                }                       
     53               
     54                List<KernelDefNode> kernelDefNodes = Accessors.kernelDefNodes(programNode);
     55                for(KernelDefNode kernelDefNode : kernelDefNodes) {
     56                        codeBuffer.append(unparser.getCode(kernelDefNode));
     57                }
     58               
     59                String code = codeBuffer.toString();                   
     60               
     61                return code;
     62        }
     63       
     64        private PrintStream makePrintStreamFromFilename(String filename) {
     65               
     66                PrintStream out = null;
     67                try {
     68                        File file = new File(filename);
     69                        file.createNewFile();
     70                        out = new PrintStream(file, "UTF-8");
     71                } catch (IOException e) {
     72                        e.printStackTrace();
     73                        System.exit(1);
     74                }
     75
     76                return out;
    3177        }
    3278
    33         private class HeaderContentsGenerator implements ContentsGenerator {
    34                
    35                 private ProgramNode programNode;
    36                 private SymbolTable symbolTable;
    37                
    38                 public HeaderContentsGenerator(ProgramNode programNode, SymbolTable symbolTable) {
    39                         this.programNode = programNode;
    40                         this.symbolTable = symbolTable;
    41                 }
    42                
    43                 public void generate(PrintStream out, OutputCodeDirectory outputCodeDirectory) {
    44                         String globalDefinitions = makeGlobalDefinitions();
    45                
    46                         String baseName = replaceFileNameExtension(new File(templateFile).getName(), "");
    47                        
    48                         Template template = outputCodeDirectory.fileTemplate(baseName, templateFile);
    49                         template.set("warningComment", CompilerConfig.WARNING_MESSAGE);
    50                         template.set("global", globalDefinitions);
    51                         template.print(out);
    52                 }
    53                
    54                 private String makeGlobalDefinitions() {
    55                        
    56                         CPPUnparser unparser = new CPPUnparser(symbolTable);
    57                        
    58                         StringBuffer codeBuffer = new StringBuffer();
    59 
    60                         List<StructTypeNode> structTypeDeclNodes = Accessors.structTypeDeclNodes(programNode);
    61                         for(StructTypeNode structTypeNode : structTypeDeclNodes) {
    62                                 codeBuffer.append(unparser.getCode(structTypeNode));
    63                         }                       
    64                        
    65                         List<KernelDefNode> kernelDefNodes = Accessors.kernelDefNodes(programNode);
    66                         for(KernelDefNode kernelDefNode : kernelDefNodes) {
    67                                 codeBuffer.append(unparser.getCode(kernelDefNode));
    68                         }
    69                        
    70                         String code = codeBuffer.toString();                   
    71                        
    72                         return code;
    73                 }
    74         }       
    75        
    76         /*
    77          *      Header per kernel definition.
    78          */
    79         /*
    80         private class HeaderContentsGenerator implements ContentsGenerator {
    81                
    82                 private KernelDefNode kernelDefNode = null;
    83                 private SymbolTable symbolTable = null;
    84                
    85                 public HeaderContentsGenerator(KernelDefNode kernelDefNode, SymbolTable symbolTable) {
    86                         this.kernelDefNode = kernelDefNode;
    87                         this.symbolTable = symbolTable;
    88                 }
    89                
    90                 public void generate(PrintStream out, OutputCodeDirectory outputCodeDirectory) {
    91                         String globalDefinitions = makeGlobalDefinition();
    92                
    93                         String baseName = replaceFileNameExtension(new File(templateFile).getName(), "");
    94                        
    95                         Template template = outputCodeDirectory.fileTemplate(baseName, templateFile);
    96                         template.set("warningComment", CompilerConfig.WARNING_MESSAGE);
    97                         template.set("global", globalDefinitions);
    98                         template.print(out);
    99                 }
    100                
    101                 private String makeGlobalDefinition() {
    102                         CPPUnparser unparser = new CPPUnparser(symbolTable);
    103                         String code = unparser.getCode(kernelDefNode);                 
    104                         return code;
    105                 }       
    106         }
    107         */     
    108        
    109         public static String replaceFileNameExtension(String fileName, String ext) {
    110 
    111                 int index = fileName.lastIndexOf('.');
    112                 if (index > 0) {
    113                 return fileName.substring(0, index) + ext;
    114                 } else {
    115                         return fileName + ext;
    116                 }
    117         }
    118        
    11979}
  • proto/pabloj/trunk/src/applicationGenerator/PabloJ.java

    r2834 r2917  
     1/**
     2 * Compiler entry point.
     3 * 
     4 * Parses command line arguments.
     5 * Constructs configuration object.
     6 * Generates target application.
     7 *
     8 * @author Ken Herdy <ksherdy at sfu dot ca>
     9 */
     10
    111package  applicationGenerator;
    2 
    3 import java.io.FileNotFoundException;
    4 import java.util.ArrayList;
    5 import java.util.List;
    6 import java.util.Map;
    7 
    8 import pabloS.tokens.Tokens;
    9 import pabloS.ast.ASTNode;
    10 import pabloS.lexicalAnalyzer.LexicalController;
    11 import pabloS.parser.Parser;
    12 import pabloS.logging.ScatterLogger;
    13 
    14 import compiler.lang.carry.*;
    15 import compiler.lang.idisa.*;
    16 import compiler.lang.pabloS.*;
    1712
    1813import org.apache.commons.cli.CommandLine;
    1914import org.apache.commons.cli.CommandLineParser;
    20 import org.apache.commons.cli.HelpFormatter;
    21 import org.apache.commons.cli.Option;
    2215import org.apache.commons.cli.Options;
    2316import org.apache.commons.cli.PosixParser;
    2417 
    25 @SuppressWarnings("unused")
    26 
    2718public class PabloJ {
    28        
    29         public static final String COMPILERNAME = "PabloJ";     
    30         public static final int EXIT_CODE_FOR_ERROR = 1;
    3119                       
    3220        public static void main(String[] args) {
     
    4533                       
    4634                        e.printStackTrace();                   
    47                         CompilerOptions.exitWithUsageMessage(options);
    48                        
     35                        CompilerOptions.usageMessage(options);
     36                        System.exit(CompilerConfig.EXIT_CODE_FOR_ERROR);
    4937                }       
     38               
    5039        }
     40       
     41
    5142}
  • proto/pabloj/trunk/src/applicationGenerator/TemplateContentsGenerator.java

    r2834 r2917  
     1/**
     2 * Generates target language output file.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
     6
    17package applicationGenerator;
    28
    3 import pabloB.ast.*;
    4 import compiler.symbols.SymbolTable;
     9import compiler.codeGenerator.visitors.Unparser;
    510
    611abstract public class TemplateContentsGenerator {
    712   
    8         protected ProgramNode ASTTree;
    9         protected SymbolTable symbolTable;
     13        protected pabloB.ast.ProgramNode programNode;
     14        protected Unparser unparser;
    1015    protected String outputDirectory;
    11         protected String templateFile;
    12        
    13         public TemplateContentsGenerator(ProgramNode ASTTree,
    14                                                                         SymbolTable symbolTable,
    15                                                                         String outputDirectory,
    16                                                                         String templateFile) {
    17                 this.ASTTree = ASTTree;         
    18                 this.symbolTable = symbolTable;
    19                 this.outputDirectory = outputDirectory;         
    20                 this.templateFile = templateFile;
     16        protected String templateFilePath;
     17        protected String targetFilePath;
     18               
     19        public TemplateContentsGenerator(pabloB.ast.ProgramNode programNode,
     20                                                                                Unparser unparser,
     21                                                                                String outputDirectory,
     22                                                                                String templateFilePath,
     23                                                                                String targetFilePath) {
     24               
     25                this.programNode                = programNode;         
     26                this.unparser                   = unparser;
     27                this.outputDirectory    = outputDirectory;                     
     28                this.templateFilePath   = templateFilePath;
     29                this.targetFilePath             = targetFilePath;
    2130               
    2231        }
    2332
    2433        abstract public void generate();
    25 
     34       
    2635}
  • proto/pabloj/trunk/src/compiler/ast/pabloB/Accessors.java

    r2834 r2917  
    2020
    2121        ////////////////////////////////////////////////////////////////////////////
    22         // Program helpers
     22        // Program
    2323        ////////////////////////////////////////////////////////////////////////////
    2424               
     
    4747       
    4848        ////////////////////////////////////////////////////////////////////////////
    49         // Kernel Definition helpers
     49        // Kernel Definition
    5050        ////////////////////////////////////////////////////////////////////////////
    5151       
     
    5858       
    5959        ////////////////////////////////////////////////////////////////////////////
    60         // Functions
     60        // Kernel Definition
    6161        ////////////////////////////////////////////////////////////////////////////                   
    6262        public static FuncDefNode funcDefNode(KernelDefNode node) {
     
    8181
    8282        ////////////////////////////////////////////////////////////////////////////
    83         // Function Definition helpers
     83        // Kernel Definition
    8484        ////////////////////////////////////////////////////////////////////////////
    8585        public static InitBlockNode initBlockNode(InitDefNode node) {
     
    8888       
    8989        ////////////////////////////////////////////////////////////////////////////
    90         // Function Definition helpers
     90        // Function Definition
    9191        ////////////////////////////////////////////////////////////////////////////
    9292        public static IdentifierNode funcIdentifier(FuncDefNode node) {
     
    122122       
    123123        ////////////////////////////////////////////////////////////////////////////
    124         // Local Var Decl Stmts
     124        // Local Var Decl Statements
    125125        ////////////////////////////////////////////////////////////////////////////
    126126       
     
    147147       
    148148        ////////////////////////////////////////////////////////////////////////////
    149         // Assign Stmts
     149        // Assign Statements
    150150        ////////////////////////////////////////////////////////////////////////////                           
    151151        public static ASTNode lhs(AssignNode node) {
     
    183183       
    184184        ////////////////////////////////////////////////////////////////////////////
    185         // IfStmtNode helpers
     185        // IfStmtNode
    186186        ////////////////////////////////////////////////////////////////////////////   
    187187        public static ASTNode ifTest(IfStmtNode node) {
     
    202202       
    203203        ////////////////////////////////////////////////////////////////////////////
    204         // IdentifierNode helper
     204        // IdentifierNode
    205205        ////////////////////////////////////////////////////////////////////////////
    206206        public static String name(ASTNode node) {
     
    249249
    250250        ////////////////////////////////////////////////////////////////////////////
    251         // StructTypeNode helper
     251        // StructTypeNode
    252252        ////////////////////////////////////////////////////////////////////////////
    253253        public static String structName(StructTypeNode node) {
     
    273273
    274274        ////////////////////////////////////////////////////////////////////////////
    275         // Stream Type helpers
     275        // Stream Type
    276276        ////////////////////////////////////////////////////////////////////////////
    277277        public static String fieldWidthLexeme(FieldWidthNode node) {           
     
    287287       
    288288        ////////////////////////////////////////////////////////////////////////////
    289         // FuncCallNode helpers
     289        // FuncCallNode
    290290        ////////////////////////////////////////////////////////////////////////////
    291291        public static ASTNode funcCallIdentifier(FuncCallNode node) {
  • proto/pabloj/trunk/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2834 r2917  
    7070        }
    7171       
     72        public String getFileExt() {
     73                return ".hpp";
     74        }
     75       
    7276        //////////////////////////////////////////////////////////////
    7377        // visitors
     
    110114                // TODO -       Kludgy. Fix. See 'notes'.
    111115                CarryInfoSetSymbol carryInfoSet = (CarryInfoSetSymbol) symbolTable.get(kernelName);
     116                               
    112117                int carry1Count = carryInfoSet.getCarry1Count();
    113118                int carryNCount = carryInfoSet.getCarryNCount();
     119               
    114120                if( carry1Count > 0 || carryNCount > 0 )
    115121                {
    116                 formatString = carrySetBuiltins2CPP.CARRYSETDECLAREFORMATSTRING;
    117                 formatString += ";";
    118                 code.addFormattedLine(formatString,
    119                                 carry1Count,
    120                                 carryNCount,
    121                                 carrySetBuiltins2CPP.CARRYQNAME);
    122                
     122                        formatString = carrySetBuiltins2CPP.CARRYSETDECLAREFORMATSTRING;
     123                        formatString += ";";
     124                        code.addFormattedLine(formatString,
     125                                        carry1Count,
     126                                        carryNCount,
     127                                        carrySetBuiltins2CPP.CARRYQNAME);
     128                       
    123129                }
    124130               
  • proto/pabloj/trunk/src/compiler/codeGenerator/visitors/Unparser.java

    r2834 r2917  
    4949        abstract public String getCode(ASTNode node);           
    5050        abstract public String getCode(ASTNode node, int indent);
     51        abstract public String getFileExt();
    5152       
    52         protected SymbolTable symbolTable;
    5353       
    54         protected SymbolTable getSymbolTable() {
     54        protected SymbolTable symbolTable; // TODO - refactor / remove
     55       
     56        protected SymbolTable getSymbolTable() { // TODO - refactor / remove
    5557                return symbolTable;
    5658        }
    5759       
    58         protected void setSymbolTable(SymbolTable symbolTable) {
     60        protected void setSymbolTable(SymbolTable symbolTable) { // TODO - refactor / remove
    5961                this.symbolTable = symbolTable;
    6062        }
  • proto/pabloj/trunk/src/compiler/transformer/visitors/CarryInfoSetVisitor.java

    r2834 r2917  
    5151                        if(BuiltinsUtil.isCarryN(node)) {
    5252                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    53                                 String value = Accessors.streamConstantLexeme((StreamConstantNode)arguments.get(1));
     53                                String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
    5454                                ((CarryInfoSetSymbol)symbolTable.get(key)).addCarryN(Integer.parseInt(value));
    5555                        }
  • proto/pabloj/trunk/src/compiler/transformer/visitors/CarryIntroXFormer.java

    r2834 r2917  
    466466                               
    467467                                ASTNode formatValue = Accessors.funcCallArg(node, 1);
    468                                 String value = Accessors.streamConstantLexeme((StreamConstantNode)formatValue);
     468                                String value = Accessors.integerConstantLexeme((IntegerConstantNode)formatValue);
    469469                               
    470470                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
  • proto/pabloj/trunk/src/compiler/transformer/visitors/PabloS2PabloBXFormer.java

    r2834 r2917  
    104104                        if(carryInfoSetSymbol.getCarry1Count() > 0) {
    105105                                               
    106                         Integer [] carry1Array = carryInfoSetSymbol.getCarry1Array();   
    107                                
    108                         for(int i=0; i < carry1Array.length; i++) {     
    109                                
    110                                 if(carry1Array[i] > 0) {
     106                                Integer [] carry1Array = carryInfoSetSymbol.getCarry1Array();   
    111107                                       
    112                                                 String carryFlipArrayExpr = String.format(CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME + "[%s]", Integer.toString(i));   
     108                                for(int i=0; i < carry1Array.length; i++) {     
     109                                       
     110                                        if(carry1Array[i] > 0) {
    113111                                               
    114                                                 String[] carryFlipIdentiferArray = new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carryFlipArrayExpr};
    115                                                
    116                                                 pabloB.ast.CompoundIdentifierNode carryFlipIdentifierNode
    117                                                                 = Generators.makeCompoundIdentifierNode(carryFlipIdentiferArray,
    118                                                                 locationToken);
    119                                                
    120                                                 FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    121                                                                 new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
    122                                                                 locationToken,
    123                                                                 new ASTNode [] {carryFlipIdentifierNode});
    124                                                
    125                                                 AssignNode assignNode = Generators.makeAssignEqualNode(carryFlipIdentiferArray,
    126                                                                 carryFlipFuncCall,
    127                                                                 locationToken);
    128                                                                                                
    129                                                 compiler.ast.pabloB.Accessors.initBlockNode(initDefNode).appendChild(assignNode);                                               
    130                                                
     112                                                        String carryFlipArrayExpr = String.format(CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME + "[%s]",
     113                                                                                                                                                Integer.toString(i));   
     114                                                       
     115                                                        String[] carryFlipIdentiferArray = new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carryFlipArrayExpr};
     116                                                       
     117                                                        pabloB.ast.CompoundIdentifierNode carryFlipIdentifierNode
     118                                                                        = Generators.makeCompoundIdentifierNode(carryFlipIdentiferArray,
     119                                                                        locationToken);
     120                                                       
     121                                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     122                                                                        new String [] {CarrySetBuiltins2Lang.CARRYQNAME, carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
     123                                                                        locationToken,
     124                                                                        new ASTNode [] {carryFlipIdentifierNode});
     125                                                       
     126                                                        AssignNode assignNode = Generators.makeAssignEqualNode(carryFlipIdentiferArray,
     127                                                                        carryFlipFuncCall,
     128                                                                        locationToken);
     129                                                                                                       
     130                                                        compiler.ast.pabloB.Accessors.initBlockNode(initDefNode).appendChild(assignNode);                                                                       
    131131                                        }
    132132                                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r2834 r2917  
    6666        public ASTNode visit(StateSizeNode node);
    6767
     68        public ASTNode visit(StateValueNode node);
     69
    6870        public ASTNode visit(StreamConstantNode node);
    6971
     
    205207                }
    206208
     209                public ASTNode visit(StateValueNode node) {
     210                        return defaultVisit(node);
     211                }
     212
    207213                public ASTNode visit(StreamConstantNode node) {
    208214                        return defaultVisit(node);
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r2834 r2917  
    9595        public T visitLeave(StateSizeNode node, List<T> childResults);
    9696
     97        public void visitEnter(StateValueNode node);
     98        public T visitLeave(StateValueNode node, List<T> childResults);
     99
    97100        public void visitEnter(StreamConstantNode node);
    98101        public T visitLeave(StreamConstantNode node, List<T> childResults);
     
    338341                }
    339342
     343                public void visitEnter(StateValueNode node) {
     344                        defaultVisitEnter(node);
     345                }
     346                public T visitLeave(StateValueNode node, List<T> childResults) {
     347                        return defaultVisitLeave(node);
     348                }
     349
    340350                public void visitEnter(StreamConstantNode node) {
    341351                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r2834 r2917  
    6767        public void visit(StateSizeNode node);
    6868
     69        public void visit(StateValueNode node);
     70
    6971        public void visit(StreamConstantNode node);
    7072
     
    206208                }
    207209
     210                public void visit(StateValueNode node) {
     211                        defaultVisit(node);
     212                }
     213
    208214                public void visit(StreamConstantNode node) {
    209215                        defaultVisit(node);
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r2834 r2917  
    9393        public void visitLeave(StateSizeNode node);
    9494
     95        public void visitEnter(StateValueNode node);
     96        public void visitLeave(StateValueNode node);
     97
    9598        public void visitEnter(StreamConstantNode node);
    9699        public void visitLeave(StreamConstantNode node);
     
    335338                }
    336339
     340                public void visitEnter(StateValueNode node) {
     341                        defaultVisitEnter(node);
     342                }
     343                public void visitLeave(StateValueNode node) {
     344                        defaultVisitLeave(node);
     345                }
     346
    337347                public void visitEnter(StreamConstantNode node) {
    338348                        defaultVisitEnter(node);
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r2835 r2917  
    211211                result.setProductionTag(7);
    212212                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    213                 {
    214                         ASTNode child = parseStateIdentifier();
    215                         result.appendChild(child);
    216                         allChildren.add(child);
    217                 }
    218                 expect(Lextant.LSQUARE);
    219                 {
    220                         ASTNode child = parseStateSize();
    221                         result.appendChild(child);
    222                         allChildren.add(child);
    223                 }
    224                 expect(Lextant.RSQUARE);
    225                 expect(Lextant.ASSIGN);
    226                 expect(Lextant.LCURLY);
    227                 {
    228                         ASTNode child = parseStateInitList();
    229                         result.appendChild(child);
    230                         allChildren.add(child);
    231                 }
    232                 expect(Lextant.RCURLY);
    233                 if( nowReading.isLextant(Lextant.TERMINATOR) ) {
    234                         expect(Lextant.TERMINATOR);
     213                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     214                        {
     215                                ASTNode child = parseStateIdentifier();
     216                                result.appendChild(child);
     217                                allChildren.add(child);
     218                        }
     219                        expect(Lextant.LSQUARE);
     220                        {
     221                                ASTNode child = parseStateSize();
     222                                result.appendChild(child);
     223                                allChildren.add(child);
     224                        }
     225                        expect(Lextant.RSQUARE);
     226                        expect(Lextant.ASSIGN);
     227                        expect(Lextant.LCURLY);
     228                        {
     229                                ASTNode child = parseStateInitList();
     230                                result.appendChild(child);
     231                                allChildren.add(child);
     232                        }
     233                        expect(Lextant.RCURLY);
     234                }
     235                else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     236                        {
     237                                ASTNode child = parseStateIdentifier();
     238                                result.appendChild(child);
     239                                allChildren.add(child);
     240                        }
     241                        expect(Lextant.ASSIGN);
     242                        {
     243                                ASTNode child = parseStateValue();
     244                                result.appendChild(child);
     245                                allChildren.add(child);
     246                        }
     247                        if( nowReading.isLextant(Lextant.TERMINATOR) ) {
     248                                expect(Lextant.TERMINATOR);
     249                        }
    235250                }
    236251                if(allowCompression) {
     
    307322        }
    308323         
     324        public ASTNode parseStateValue() {
     325                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     326                        return syntaxErrorNode("stateValue² [INTEGER_CONST¹]");
     327                }
     328       
     329                boolean allowCompression = true;
     330                ASTNode result = new StateValueNode(nowReading);
     331                result.setProductionTag(11);
     332                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     333                {
     334                        ASTNode child = parseIntegerConstant();
     335                        result.appendChild(child);
     336                        allChildren.add(child);
     337                }
     338                if(allowCompression) {
     339                        return result;
     340                }
     341                return result;
     342        }
     343         
    309344        public ASTNode parseFuncDef() {
    310345                if( !(nowReading.isLextant(Lextant.FUNCTION)) ) {
     
    314349                boolean allowCompression = true;
    315350                ASTNode result = new FuncDefNode(nowReading);
    316                 result.setProductionTag(11);
     351                result.setProductionTag(12);
    317352                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    318353                expect(Lextant.FUNCTION);
     
    357392                boolean allowCompression = true;
    358393                ASTNode result = new ASTNode(nowReading);
    359                 result.setProductionTag(12);
     394                result.setProductionTag(13);
    360395                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    361396                {
     
    377412                boolean allowCompression = true;
    378413                ASTNode result = new ParameterListNode(nowReading);
    379                 result.setProductionTag(13);
     414                result.setProductionTag(14);
    380415                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    381416                {
     
    405440                boolean allowCompression = true;
    406441                ASTNode result = new ASTNode(nowReading);
    407                 result.setProductionTag(14);
     442                result.setProductionTag(15);
    408443                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    409444                {
     
    425460                boolean allowCompression = true;
    426461                ASTNode result = new ParameterNode(nowReading);
    427                 result.setProductionTag(15);
     462                result.setProductionTag(16);
    428463                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    429464                {
     
    450485                boolean allowCompression = true;
    451486                ASTNode result = new ASTNode(nowReading);
    452                 result.setProductionTag(16);
     487                result.setProductionTag(17);
    453488                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    454489                {
     
    470505                boolean allowCompression = true;
    471506                ASTNode result = new ASTNode(nowReading);
    472                 result.setProductionTag(17);
     507                result.setProductionTag(18);
    473508                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    474509                {
     
    490525                boolean allowCompression = true;
    491526                ASTNode result = new ASTNode(nowReading);
    492                 result.setProductionTag(18);
     527                result.setProductionTag(19);
    493528                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    494529                {
     
    510545                boolean allowCompression = true;
    511546                ASTNode result = new ASTNode(nowReading);
    512                 result.setProductionTag(19);
     547                result.setProductionTag(20);
    513548                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    514549                if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    563598                boolean allowCompression = true;
    564599                ASTNode result = new FuncCallOrAssignStmtNode(nowReading);
    565                 result.setProductionTag(20);
     600                result.setProductionTag(21);
    566601                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    567602                {
     
    602637                boolean allowCompression = true;
    603638                ASTNode result = new FuncCallNode(nowReading);
    604                 result.setProductionTag(21);
     639                result.setProductionTag(22);
    605640                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    606641                result.setToken(nowReading);
     
    621656                boolean allowCompression = true;
    622657                ASTNode result = new FuncCallArgListNode(nowReading);
    623                 result.setProductionTag(22);
     658                result.setProductionTag(23);
    624659                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    625660                if( nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    651686                boolean allowCompression = true;
    652687                ASTNode result = new AssignOperatorNode(nowReading);
    653                 result.setProductionTag(23);
     688                result.setProductionTag(24);
    654689                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    655690                if( nowReading.isLextant(Lextant.ASSIGN) ) {
     
    678713                boolean allowCompression = true;
    679714                ASTNode result = new AssignNode(nowReading);
    680                 result.setProductionTag(24);
     715                result.setProductionTag(25);
    681716                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    682717                {
     
    704739                boolean allowCompression = true;
    705740                ASTNode result = new IfStmtNode(nowReading);
    706                 result.setProductionTag(25);
     741                result.setProductionTag(26);
    707742                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    708743                expect(Lextant.IF);
     
    740775                boolean allowCompression = true;
    741776                ASTNode result = new WhileStmtNode(nowReading);
    742                 result.setProductionTag(26);
     777                result.setProductionTag(27);
    743778                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    744779                expect(Lextant.WHILE);
     
    768803                boolean allowCompression = true;
    769804                ASTNode result = new ReturnStmtNode(nowReading);
    770                 result.setProductionTag(27);
     805                result.setProductionTag(28);
    771806                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    772807                expect(Lextant.RETURN);
     
    792827                boolean allowCompression = true;
    793828                ASTNode result = new LocalVarDeclNode(nowReading);
    794                 result.setProductionTag(28);
     829                result.setProductionTag(29);
    795830                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    796831                expect(Lextant.VAR);
     
    831866                boolean allowCompression = true;
    832867                ASTNode result = new ASTNode(nowReading);
    833                 result.setProductionTag(29);
     868                result.setProductionTag(30);
    834869                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    835870                {
     
    851886                boolean allowCompression = true;
    852887                ASTNode result = new BlockStmtNode(nowReading);
    853                 result.setProductionTag(30);
     888                result.setProductionTag(31);
    854889                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    855890                expect(Lextant.LCURLY);
     
    875910                boolean allowCompression = true;
    876911                ASTNode result = new BinaryOperatorNode(nowReading);
    877                 result.setProductionTag(31);
     912                result.setProductionTag(32);
    878913                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    879914                {
     
    910945                boolean allowCompression = true;
    911946                ASTNode result = new BinaryOperatorNode(nowReading);
    912                 result.setProductionTag(32);
     947                result.setProductionTag(33);
    913948                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    914949                {
     
    939974                boolean allowCompression = true;
    940975                ASTNode result = new UnaryOperatorNode(nowReading);
    941                 result.setProductionTag(33);
     976                result.setProductionTag(34);
    942977                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    943978                if( nowReading.isLextant(Lextant.NOT) ) {
     
    9651000                boolean allowCompression = true;
    9661001                ASTNode result = new ASTNode(nowReading);
    967                 result.setProductionTag(34);
     1002                result.setProductionTag(35);
    9681003                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    9691004                if( nowReading.isLextant(Lextant.LROUND) ) {
     
    10191054                boolean allowCompression = true;
    10201055                ASTNode result = new ASTNode(nowReading);
    1021                 result.setProductionTag(35);
     1056                result.setProductionTag(36);
    10221057                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10231058                if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    10481083                boolean allowCompression = true;
    10491084                ASTNode result = new StreamConstantNode(nowReading);
    1050                 result.setProductionTag(36);
     1085                result.setProductionTag(37);
    10511086                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10521087                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    10741109                boolean allowCompression = true;
    10751110                ASTNode result = new ASTNode(nowReading);
    1076                 result.setProductionTag(37);
     1111                result.setProductionTag(38);
    10771112                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10781113                if( nowReading.isLextant(Lextant.MINUS) ) {
     
    11141149                boolean allowCompression = true;
    11151150                ASTNode result = new IntegerConstantNode(nowReading);
    1116                 result.setProductionTag(38);
     1151                result.setProductionTag(39);
    11171152                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11181153                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    11401175                boolean allowCompression = true;
    11411176                ASTNode result = new StringConstantNode(nowReading);
    1142                 result.setProductionTag(39);
     1177                result.setProductionTag(40);
    11431178                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11441179                if( (nowReading.isLexicalType(LexicalType.STRING)) ) {
     
    11671202                boolean allowCompression = true;
    11681203                ASTNode result = new CompoundIdentifierNode(nowReading);
    1169                 result.setProductionTag(40);
     1204                result.setProductionTag(41);
    11701205                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    11711206                {
     
    11961231                boolean allowCompression = true;
    11971232                ASTNode result = new IdentifierNode(nowReading);
    1198                 result.setProductionTag(41);
     1233                result.setProductionTag(42);
    11991234                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12001235                if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     
    12151250                boolean allowCompression = true;
    12161251                ASTNode result = new ASTNode(nowReading);
    1217                 result.setProductionTag(42);
     1252                result.setProductionTag(43);
    12181253                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12191254                if( nowReading.isLextant(Lextant.STREAM) ) {
     
    12581293                boolean allowCompression = true;
    12591294                ASTNode result = new StreamTypeNode(nowReading);
    1260                 result.setProductionTag(43);
     1295                result.setProductionTag(44);
    12611296                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12621297                expect(Lextant.STREAM);
     
    12831318                boolean allowCompression = true;
    12841319                ASTNode result = new FieldWidthNode(nowReading);
    1285                 result.setProductionTag(44);
     1320                result.setProductionTag(45);
    12861321                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    12871322                {
     
    13031338                boolean allowCompression = true;
    13041339                ASTNode result = new ASTNode(nowReading);
    1305                 result.setProductionTag(45);
     1340                result.setProductionTag(46);
    13061341                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13071342                {
     
    13231358                boolean allowCompression = true;
    13241359                ASTNode result = new StructTypeNode(nowReading);
    1325                 result.setProductionTag(46);
     1360                result.setProductionTag(47);
    13261361                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13271362                expect(Lextant.STRUCT);
     
    13511386                boolean allowCompression = true;
    13521387                ASTNode result = new ASTNode(nowReading);
    1353                 result.setProductionTag(47);
     1388                result.setProductionTag(48);
    13541389                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13551390                {
     
    13711406                boolean allowCompression = true;
    13721407                ASTNode result = new StructTypeBodyNode(nowReading);
    1373                 result.setProductionTag(48);
     1408                result.setProductionTag(49);
    13741409                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    13751410                expect(Lextant.LCURLY);
     
    14021437                boolean allowCompression = true;
    14031438                ASTNode result = new StructMemberNode(nowReading);
    1404                 result.setProductionTag(49);
     1439                result.setProductionTag(50);
    14051440                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14061441                {
     
    14271462                boolean allowCompression = true;
    14281463                ASTNode result = new ASTNode(nowReading);
    1429                 result.setProductionTag(50);
     1464                result.setProductionTag(51);
    14301465                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14311466                {
     
    14471482                boolean allowCompression = true;
    14481483                ASTNode result = new VoidNode(nowReading);
    1449                 result.setProductionTag(51);
     1484                result.setProductionTag(52);
    14501485                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    14511486                expect(Lextant.VOID);
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r2834 r2917  
    763763                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    764764                        {
    765                                 ASTNode child = parseStreamConstant();
     765                                ASTNode child = parseIntegerConstant();
    766766                                result.appendChild(child);
    767767                                allChildren.add(child);
     
    819819        }
    820820         
     821        public ASTNode parseSignedIntegerConstant() {
     822                if( !(nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     823                        return syntaxErrorNode("signedIntegerConstant² [INTEGER_CONST¹, MINUS¹]");
     824                }
     825       
     826                boolean allowCompression = true;
     827                ASTNode result = new ASTNode(nowReading);
     828                result.setProductionTag(27);
     829                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     830                if( nowReading.isLextant(Lextant.MINUS) ) {
     831                        expect(Lextant.MINUS);
     832                        {
     833                                ASTNode child = parseIntegerConstant();
     834                                result.appendChild(child);
     835                                allChildren.add(child);
     836                        }
     837                        {
     838                                ASTNode temp_1 = allChildren.revGet(0);
     839                                IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
     840                                int temp_4 = 0;
     841                                ASTNode temp_5 = allChildren.revGet(0);
     842                                IntValuedNodeType temp_7 = (IntValuedNodeType)temp_5;
     843                                int temp_6 = temp_7.getValue();
     844                                int temp_8 = temp_4 - temp_6;
     845                                temp_3.setValue( temp_8 );
     846                        }
     847                }
     848                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     849                        {
     850                                ASTNode child = parseIntegerConstant();
     851                                result.appendChild(child);
     852                                allChildren.add(child);
     853                        }
     854                }
     855                if(allowCompression) {
     856                        return compressIfPossible(result);
     857                }
     858                return result;
     859        }
     860         
    821861        public ASTNode parseStreamConstant() {
    822862                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     
    826866                boolean allowCompression = true;
    827867                ASTNode result = new StreamConstantNode(nowReading);
    828                 result.setProductionTag(27);
     868                result.setProductionTag(28);
    829869                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    830870                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     
    833873                readToken();
    834874                {
    835                         ASTNode temp_1 = result;
    836                         IntValuedNodeType temp_3 = (IntValuedNodeType)temp_1;
    837                         IntConstantToken temp_6 = (IntConstantToken)previouslyRead;
    838                         int temp_5 = temp_6.getValue();
    839                         temp_3.setValue( temp_5 );
    840                 }
    841                 if(allowCompression) {
    842                         return result;
    843                 }
    844                 return result;
    845         }
    846          
    847         public ASTNode parseSignedIntegerConstant() {
    848                 if( !(nowReading.isLextant(Lextant.MINUS) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
    849                         return syntaxErrorNode("signedIntegerConstant² [INTEGER_CONST¹, MINUS¹]");
    850                 }
    851        
    852                 boolean allowCompression = true;
    853                 ASTNode result = new ASTNode(nowReading);
    854                 result.setProductionTag(28);
    855                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    856                 if( nowReading.isLextant(Lextant.MINUS) ) {
    857                         expect(Lextant.MINUS);
    858                         {
    859                                 ASTNode child = parseIntegerConstant();
    860                                 result.appendChild(child);
    861                                 allChildren.add(child);
    862                         }
    863                         {
    864                                 ASTNode temp_7 = allChildren.revGet(0);
    865                                 IntValuedNodeType temp_9 = (IntValuedNodeType)temp_7;
    866                                 int temp_10 = 0;
    867                                 ASTNode temp_11 = allChildren.revGet(0);
    868                                 IntValuedNodeType temp_13 = (IntValuedNodeType)temp_11;
    869                                 int temp_12 = temp_13.getValue();
    870                                 int temp_14 = temp_10 - temp_12;
    871                                 temp_9.setValue( temp_14 );
    872                         }
    873                 }
    874                 else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    875                         {
    876                                 ASTNode child = parseIntegerConstant();
    877                                 result.appendChild(child);
    878                                 allChildren.add(child);
    879                         }
    880                 }
    881                 if(allowCompression) {
    882                         return compressIfPossible(result);
     875                        ASTNode temp_9 = result;
     876                        IntValuedNodeType temp_11 = (IntValuedNodeType)temp_9;
     877                        IntConstantToken temp_14 = (IntConstantToken)previouslyRead;
     878                        int temp_13 = temp_14.getValue();
     879                        temp_11.setValue( temp_13 );
     880                }
     881                if(allowCompression) {
     882                        return result;
    883883                }
    884884                return result;
     
    10641064                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    10651065                {
    1066                         ASTNode child = parseIntegerConstant();
     1066                        ASTNode child = parseStreamConstant();
    10671067                        result.appendChild(child);
    10681068                        allChildren.add(child);
Note: See TracChangeset for help on using the changeset viewer.