Changeset 2702 for proto/pablo


Ignore:
Timestamp:
Nov 29, 2012, 8:34:14 PM (7 years ago)
Author:
ksherdy
Message:

General refactoring (variable names). Added final block XFormer. Move final block operations atEOF/inFile out of carry intro transformer to final block transformer.

Location:
proto/pablo
Files:
6 added
5 deleted
16 edited
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/ReadMe.txt

    r2687 r2702  
    11611611. X2Lang design decision. enum/assert etc...
    117117
    118 11. To clone the AST or not.
     11812. do_block()/do_final_block() code generation implementation.
    119119
    120         Options:
     120        We attach nodes to the Pablo AST to produce do_block() versus do_final_block() code.
    121121
    122         (a) Parse twice. Transform AST (AST_CICO_Mode AST2_CI_Mode). Generate code twice (once for each mode).
    123         (b) Clone complete AST. Transform AST (AST_CICO_Mode AST2_CI_Mode). Generate code (once for each mode).
    124         (c)
     122        Case do_block()
    125123
     124->
     125
     126
     127        Case do_final_block()
     128
     129->
     130       
     131        Implementation options:
     132       
     133        (a) Parse source file twice to produce two separate AST.
     134        (b) Clone complete AST. Apply AST transformation passes to both ASTs.
     135        (c) Add both body and final block bodies to a single AST.
     136       
     137        An additional decision remains as to which point in Pablo AST transformation we clone ASTs.
     138
     13913. Carry mode (ci/co) and do_block/do_final_block are independent concepts.
     140
     141        In the current approach we restrict the carry mode dependent transformation of the AST to
     142        the transformation to:
     143       
     144        Pablo while
     145       
     146->     
     147       
     148        Prior carry operations considered carry mode in the selection of carry dependent operations.
     149        For example, final block carry producing operations are not 'strictly' required to write
     150        carry out values.
     151
     15214. 3-Addr Form (SSA) AST permits the applications of simplification rules (local optimization)
     153        of the AST.     
     154
     155Additional Notes
     156
     157Ci|Co
     158-----
     159F | F
     160F | T
     161T | F
     162T | T
     163       
     164+ Carry Modes   
     165
     166Pablo language control structures.     
     167       
     168Ci/Co (Carry In / Carry Out Mode)
     169
     170- While statements (1st iteration)
     171- If statements
     172
     173Ci (Carry In Only Mode)
     174
     175- While statements iteration i>1
     176
     177Co (Carry Out Only Mode)
     178
     179...
     180
     181Pablo builtins
     182
     183ScanToFirst - Special consideration at initial block as well as atEOF, i.e. set carry bit at SOF, inFile(), atEOF()?
     184SpanUpTo        - Special consideration atEOF, i.e. check to ensure scan terminates at a valid position
     185Advance
     186AdvanceN
     187
     188+ Block Types
     189
     190Initial block(ScanToFirst)
     191Intermediate block (Non-initial and Non-final block)
     192Final block
     193Initial/Final block
     194
  • proto/pablo/src/application/ApplicationGenerator.java

    r2687 r2702  
    9090                // Generate
    9191                                       
     92                /*
    9293                String global = CodeGenerator.makeStructDecls((ProgramNode)syntaxTree, unparser);
    9394               
     
    9596               
    9697                System.out.print(global);
     98               
     99                String temp = CodeGenerator.makeStructDefs((ProgramNode)syntaxTree, unparser);
     100               
     101                System.out.print(temp);
     102                */     
    97103                                       
    98104//              parser.generateFile(new TemplateContentsGenerator(this.root, srcDirectory), "Parser.java"); // "Parser.java"
  • proto/pablo/src/application/Test.java

    r2670 r2702  
    2828import compiler.semanticAnalyzer.visitors.AugAssignXFormer;
    2929import compiler.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
     30import compiler.semanticAnalyzer.visitors.FinalBlockXFormer;
    3031import compiler.semanticAnalyzer.visitors.Pablo2CarryXFormer;
    3132import compiler.semanticAnalyzer.visitors.StreamFuncVisitor;
     
    4445            ADVANCECOMBINER("AdvanceCombinerXFormer", true),
    4546            ADVANCENCOUNTER("AdvanceNCounterVisitor", true),
    46             AugAssign("AugAssignXFormer", true),
     47            AUGASSIGN("AugAssignXFormer", true),
    4748            BITWISE2IDISA("Bitwise2IDISAXFormer", true),
    4849            CARRYCOUNTER("CarryCounterVisitor", true),
    49             PABLO2CARRYQCICO("Pablo2CarryQCiCoXFormer", true),
    5050            PABLO2CARRYQCI("Pablo2CarryQCiXFormer", true),
    5151            CARRYINITTOONELIST("CarryInitToOneListVisitor", true),
    52             STREAMFuncVISITOR("StreamFuncVisitor", true);
     52            STREAMFUNCVISITOR("StreamFuncVisitor", true),
     53            FINALBLOCKXFORMERISFINAL("FinalBlockXFormer/FinalBlock",true),
     54            FINALBLOCKXFORMERISNOTFINAL("FinalBlockXFormer/NotFinalBlock",true);
    5355            //CARRYQINTROXFORMER("",true); // TODO
    5456            //ASSERTZERO("",true);// TODO
     
    7981                for(Visitor test: Visitor.values()) {
    8082                       
     83                        System.out.println(test.name());
     84                       
    8185                        if (test.addTest()) {
    8286                       
     
    9599                                                        break;
    96100                                                case ADVANCENCOUNTER:
    97                                                         break;
    98                                                 case AugAssign:                                 
    99                                                                 AugAssignTest(fileAbsolutePath);
     101                                                        // TODO
     102                                                        break;
     103                                                case AUGASSIGN:                                 
     104                                                        AugAssignTest(fileAbsolutePath);
    100105                                                        break;
    101106                                                case BITWISE2IDISA:
    102                                                                 bitwise2IDISATest(fileAbsolutePath);
     107                                                        bitwise2IDISATest(fileAbsolutePath);
    103108                                                        break;                                 
    104109                                                case CARRYCOUNTER:
     110                                                        // TODO
    105111                                                        break;                                 
    106                                                 case PABLO2CARRYQCICO:
    107                                                                 carryIntroTest(fileAbsolutePath, true, true);
    108                                                         break;
    109112                                                case PABLO2CARRYQCI:
    110                                                                 carryIntroTest(fileAbsolutePath, true, false);
     113                                                        pablo2CarryQTest(fileAbsolutePath, true);
    111114                                                        break; 
     115                                                case FINALBLOCKXFORMERISFINAL:
     116                                                        finalBlockXFormerTest(fileAbsolutePath, true);
     117                                                        break;
     118                                                case FINALBLOCKXFORMERISNOTFINAL:
     119                                                        finalBlockXFormerTest(fileAbsolutePath, false);
     120                                                        break;                                                 
    112121                                                case CARRYINITTOONELIST:
     122                                                        // TODO
    113123                                                        break;                                 
    114                                                 case STREAMFuncVISITOR:
     124                                                case STREAMFUNCVISITOR:
     125                                                        // TODO
    115126                                                        break;
    116127                                                default:
     128                                                        System.err.println("Undefined test case.");
    117129                                                        break;
    118130                                        }
     
    192204         * @throws FileNotFoundException - Final Block
    193205         */
    194         public static void carryIntroTest(String fileAbsolutePath, boolean ciMode, boolean coMode) throws FileNotFoundException {
     206        public static void pablo2CarryQTest(String fileAbsolutePath, boolean ciMode) throws FileNotFoundException {
    195207                LexicalController lexController = LexicalController.make(fileAbsolutePath);
    196208                ASTNode syntaxTree = Parser.parse(lexController);
     
    206218                        CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
    207219                        Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(value, builtins2CPP, carrySet2CPP);
    208                         pablo2CarryQ.XForm(ciMode, coMode);                     
     220                        pablo2CarryQ.XForm(ciMode);                     
    209221                       
    210222                }   
     
    214226               
    215227        }       
     228
     229        /**
     230         * @param fileAbsolutePath
     231         * @throws FileNotFoundException - Final Block
     232         */
     233        public static void finalBlockXFormerTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
     234                LexicalController lexController = LexicalController.make(fileAbsolutePath);
     235                ASTNode syntaxTree = Parser.parse(lexController);
     236               
     237               
     238                StreamFuncVisitor streamFuncVisitor = new StreamFuncVisitor(syntaxTree);
     239                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
     240               
     241                Builtins2Lang builtins2CPP = new Builtins2CPP();
     242               
     243                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
     244                        ASTNode value = entry.getValue();                               
     245                        CarrySet2Lang carrySet2CPP = new CarrySet2CPP();
     246                        FinalBlockXFormer finalBlockXFormer = new FinalBlockXFormer(value, builtins2CPP);
     247                        finalBlockXFormer.XForm(isFinalBlock);                 
     248                       
     249                }   
     250               
     251                AssertCompare astTest = new AssertCompare(syntaxTree);
     252                astTest.compareAssignNodes();
     253               
     254        }               
    216255       
    217256//  CarryCounter carryCounter = new CarryCounter(node);
    218 //  AdvanceNCounter advNCounter = new AdvanceNCounter(node);
    219                            
     257//  AdvanceNCounter advNCounter = new AdvanceNCounter(node);                       
    220258//      System.out.println(entry.getKey());
    221259//      System.out.println("Carry Count = " + carryCounter.count());
     
    223261//      System.out.println();
    224262
    225        
    226263        private static void generateCodeIfNoErrors(String filename, ASTNode decoratedTree)
    227264                        throws FileNotFoundException {
  • proto/pablo/src/compiler/ast/Accessors.java

    r2687 r2702  
    3838        public static List<FuncDefNode> funcDefs(ProgramNode node) {
    3939               
     40                assert node instanceof ProgramNode;
    4041                List<FuncDefNode> funcDefs = new ArrayList<FuncDefNode>();
    4142               
     
    7980        }       
    8081
    81         public static String AssignOperator(AssignNode node) {
     82        public static String assignOperator(AssignNode node) {
    8283                return node.getToken().getLexeme();
    8384        }
     
    8788        ////////////////////////////////////////////////////////////////////////////                           
    8889
    89         public static String AssignOperator(FuncCallNode node) {
     90        public static String assignOperator(FuncCallNode node) {
    9091                return node.getToken().getLexeme();
    9192        }       
     
    104105        }               
    105106       
    106         public static String AssignOperator(LocalVarDeclNode node) {
     107        public static String assignOperator(LocalVarDeclNode node) {
    107108                return node.getToken().getLexeme();
    108109        }       
     
    185186        // FuncDefinitionNode helpers
    186187        ////////////////////////////////////////////////////////////////////////////
    187         public static IdentifierNode FuncName(FuncDefNode node) {
     188        public static IdentifierNode funcIdentifier(FuncDefNode node) {
    188189                return (IdentifierNode) node.child(1);
     190        }
     191       
     192        public static String funcName(FuncDefNode node) {
     193                return Accessors.name(node.child(1));
    189194        }
    190195       
     
    222227        // FuncCallNode helpers
    223228        ////////////////////////////////////////////////////////////////////////////
    224         public static ASTNode FuncCallName(FuncCallNode node) {
    225                 return node.child(0);
    226         }
    227 
    228         public static ASTNode FuncCallArgsListNode(FuncCallNode node) {
     229        public static ASTNode funcCallIdentifier(FuncCallNode node) {
     230                return node.child(0);
     231        }
     232
     233        public static ASTNode funcCallArgsListNode(FuncCallNode node) {
    229234                return node.child(1);
    230235        }
    231236       
    232         public static int FuncCallArgCount(FuncCallNode node) {
    233                 ASTNode argList = Accessors.FuncCallArgsListNode(node);
     237        public static int funcCallArgCount(FuncCallNode node) {
     238                ASTNode argList = Accessors.funcCallArgsListNode(node);
    234239                if (argList == null) {
    235240                        return 0;
     
    238243        }
    239244       
    240         public static ASTNode FuncCallArg(FuncCallNode node, int index) {
    241                
    242                 if((index + 1) > Accessors.FuncCallArgsListNode(node).getChildren().size()) {
     245        public static ASTNode funcCallArg(FuncCallNode node, int index) {
     246               
     247                if((index + 1) > Accessors.funcCallArgsListNode(node).getChildren().size()) {
    243248                        throw new RuntimeException("Func invocation Arg out of range.");
    244249                }
    245                 return Accessors.FuncCallArgsListNode(node).child(index);
    246         }
    247        
    248         public static List<ASTNode> FuncCallArgsList(FuncCallNode node) {
    249                 return Accessors.FuncCallArgsListNode(node).getChildren();
    250         }
    251                
    252     public static String FuncCallName(ASTNode node) {
     250                return Accessors.funcCallArgsListNode(node).child(index);
     251        }
     252       
     253        public static List<ASTNode> funcCallArgsList(FuncCallNode node) {
     254                return Accessors.funcCallArgsListNode(node).getChildren();
     255        }
     256               
     257    public static String funcCallName(ASTNode node) {
    253258        String name = new String();
    254259        if(node instanceof IdentifierNode) {
    255             name = Accessors.identifierLexeme(node);
     260            name = Accessors.name(node);
    256261        }
    257262        else if (node instanceof CompoundIdentifierNode) {
    258263            ASTNode pckage = node.child(0);
    259264            ASTNode member = node.child(1);
    260             name = Accessors.identifierLexeme(pckage);
     265            name = Accessors.name(pckage);
    261266            name += ".";
    262             name += Accessors.identifierLexeme(member);
     267            name += Accessors.name(member);
    263268        }
    264269        return name;
     
    268273        // IdentifierNode helper
    269274        ////////////////////////////////////////////////////////////////////////////
    270         public static String identifierLexeme(ASTNode node) {
    271                 IdentifierNode identifier = (IdentifierNode)node;
    272                 return identifier.getToken().getLexeme();
     275        public static String name(ASTNode node) {
     276                assert node instanceof IdentifierNode;
     277                return node.getToken().getLexeme();
    273278        }
    274279
     
    278283        public static String structName(StructTypeNode node) {
    279284        String name = new String();
    280         name = Accessors.identifierLexeme(node.child(0));
     285        name = Accessors.name(node.child(0));
    281286        return name;
    282287        }
     
    301306        ////////////////////////////////////////////////////////////////////////////
    302307        public static String structMemberName(StructMemberNode node) {
    303         String name = new String();
    304         name = Accessors.identifierLexeme(node.child(1));
    305         return name;
     308        return Accessors.name(node.child(1));
    306309        }       
    307310                       
     
    310313        ////////////////////////////////////////////////////////////////////////////
    311314        public static String streamTypeName(StreamTypeNode node) {
    312                 String name = new String();
    313                 name = node.getToken().getLexeme();
    314                 return name;
     315                return Accessors.name(node);
    315316        }       
    316317
  • proto/pablo/src/compiler/ast/Generators.java

    r2675 r2702  
    5959                if(args.length > 0) {
    6060                        for(ASTNode child: args) {
    61                                 Accessors.FuncCallArgsListNode(node).appendChild(child);
     61                                Accessors.funcCallArgsListNode(node).appendChild(child);
    6262                        }
    63                         Accessors.FuncCallArgsListNode(node).setToken(args[0].getToken());
     63                        Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
    6464                }       
    6565        }
     
    8787                if(args.size() > 0) {
    8888                        for(ASTNode child: args) {
    89                                 Accessors.FuncCallArgsListNode(node).appendChild(child);
     89                                Accessors.funcCallArgsListNode(node).appendChild(child);
    9090                        }
    91                         Accessors.FuncCallArgsListNode(node).setToken(args.get(0).getToken());
     91                        Accessors.funcCallArgsListNode(node).setToken(args.get(0).getToken());
    9292                }               
    9393        }
     
    210210                return ifStmtNode;
    211211        }
     212       
     213        // Helper
     214        public static String capitalize(String str) {
     215                return str.substring(0, 1).toUpperCase() + str.substring(1);
     216        }
     217       
     218        public static String unCapitalize(String str) {
     219                return str.substring(0, 1).toLowerCase() + str.substring(1);
     220        }
    212221}
  • proto/pablo/src/compiler/codeGenerator/CodeGenerator.java

    r2687 r2702  
    44
    55import compiler.ast.Accessors;
     6import compiler.ast.Generators;
    67import compiler.codeGenerator.visitors.CPPUnparser;
    78import compiler.codeGenerator.visitors.Unparser;
     
    2223public class CodeGenerator {
    2324
     25        //private ASTNode cicoDecoratedASTTree;
     26        //private ASTNode coDecoratedASTTree;   
     27       
    2428        //////////////////////////////////////////////////////////////
    2529        // static interface
    26         public static String makeStreamFuncDecls(ProgramNode node, Unparser unparser) {
    27                 String code = new String();
    28                 List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
    29                 for(FuncDefNode funcDef: funcDefs) {
    30                         code += unparser.getCode(funcDef);
     30       
     31        public static String makeStreamFuncDecls(ASTNode cicoASTTree, ASTNode coASTTree, Unparser unparser) {
     32               
     33                StringBuilder builder = new StringBuilder();
     34                List<FuncDefNode> cicoFuncDefs = Accessors.funcDefs((ProgramNode)cicoASTTree);
     35               
     36                for(FuncDefNode funcDef: cicoFuncDefs) {
     37                        builder.append(unparser.getCode(funcDef));
    3138                }       
    32                 return code;
     39               
     40                return builder.toString();
    3341        }       
     42
     43        //////////////////////////////////////////////////////////////
     44        // constructor and helpers
    3445       
     46        /*
    3547        public static String makeStructDecls(ProgramNode node, Unparser unparser) {
    3648                String code = new String();
     
    4254        }       
    4355               
    44         /*
    45         public static String makeDoBlock(ASTNode root, Unparser unparser) {
    46                 CodeGenerator generator = new CodeGenerator(root, unparser);           
    47                 return generator.makeDoBlock();
     56        public static String makeStructDefs(ProgramNode node, Unparser unparser) {
     57                return unparser.getStructDefs(node, 0);
    4858        }
    49         */     
     59       
     60        //////////////////////////////////////////////////////////////
     61        //
     62        public String makeStructDefs(ProgramNode node, int indent) {
     63                StringBuilder builder = new StringBuilder();
     64                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
     65                for(StructTypeNode structDecl: structDecls) {
     66                        String name = Accessors.structName(structDecl);
     67                        CodeStore.addIndentation(builder, indent);
     68                        builder.append(Generators.capitalize(name));    // TODO - hack replace with 'real' stream kernels
     69                        builder.append(" ");
     70                        builder.append(Generators.unCapitalize(name));  // TODO - hack
     71                        builder.append(";");
     72                        builder.append(CodeStore.NEWLINE);
     73                }
     74                return builder.toString();
     75        }
     76       
     77        public String makeFuncDefs(ProgramNode node, int indent) {
     78                StringBuilder builder = new StringBuilder();
     79                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
     80                for(FuncDefNode funcDef: funcDefs) {
     81                        String name = Accessors.funcName(funcDef);
     82                        CodeStore.addIndentation(builder, indent);
     83                        builder.append(Generators.capitalize(name));    // TODO - hack replace with 'real' stream kernels
     84                        builder.append(" ");
     85                        builder.append(Generators.unCapitalize(name));  // TODO - hack
     86                        builder.append(";");
     87                        builder.append(CodeStore.NEWLINE);                     
     88                }       
     89               
     90                return builder.toString();
     91        }
     92       
     93        public String makeDoBlocks(ProgramNode node, int indent) {
     94                StringBuilder builder = new StringBuilder();
     95                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
     96                for(FuncDefNode funcDef: funcDefs) {
     97                        String name = Accessors.funcName(funcDef);
     98                        CodeStore.addIndentation(builder, indent);
     99                        builder.append(Generators.unCapitalize(name));  // TODO - hack
     100                        builder.append(".doBlock();");
     101                }
     102                return null;
     103        }
     104
     105        public String makeDoFinalBlocks(ProgramNode node, int indent) {
     106                StringBuilder builder = new StringBuilder();
     107                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
     108                for(FuncDefNode funcDef: funcDefs) {
     109                        String name = Accessors.funcName(funcDef);
     110                        CodeStore.addIndentation(builder, indent);
     111                        builder.append(Generators.unCapitalize(name));  // TODO - hack
     112                        builder.append(".doFinalBlock();");
     113                }
     114                return null;
     115        }
     116        */
    50117       
    51118        /*
     
    70137        */     
    71138       
    72        
    73         // any_carry // TODO - deprecate
    74        
    75         //////////////////////////////////////////////////////////////
    76         // constructor and helpers
    77 
    78 
    79         //////////////////////////////////////////////////////////////
    80         // analysis
    81         /*
    82         public String makeStructDecls() {
    83                
    84                 // Add logic
    85                
    86                 String code = unparser.getCode();
    87                 return code;
    88         }
    89         */
    90139}               
    91140
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2687 r2702  
    77
    88import compiler.ast.Accessors;
     9import compiler.ast.Generators;
    910import compiler.codeGenerator.visitors.helpers.*;
    1011
     
    2425                return codeStore.toStringIndented(indent);
    2526        }
    26        
     27
    2728        //////////////////////////////////////////////////////////////
    2829        // visitors
    29        
    3030        public CodeStore visitLeave(ProgramNode node, List<CodeStore> childResults) {   
    3131                return  UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, false);
     
    129129                CodeStore rhs = childResults.get(1);
    130130                code.addFormattedLine("%s %s %s;", lhs.getResultVarName()
    131                                                                                  , Accessors.AssignOperator(node)
     131                                                                                 , Accessors.assignOperator(node)
    132132                                                                                 , rhs.getResultVarName());
    133133               
     
    217217                                                                type.getResultVarName(),
    218218                                                                identifier.getResultVarName(),
    219                                                                 Accessors.AssignOperator(node),
     219                                                                Accessors.assignOperator(node),
    220220                                                                expression.getResultVarName());
    221221                } else {
     
    450450        public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) {
    451451                CodeStore code = new CodeStore();
    452                 code.setResultVarName(Accessors.identifierLexeme(node));
     452                code.setResultVarName(Accessors.name(node));
    453453                return code;
    454454        }
  • proto/pablo/src/compiler/codeGenerator/visitors/Unparser.java

    r2687 r2702  
    11package compiler.codeGenerator.visitors;
     2
    23
    34import ast.ASTNode;
    45import ast.ASTVisitor.Default;
    5 
    66import compiler.codeGenerator.visitors.helpers.CodeStore;
    77
    88abstract public class Unparser extends Default<CodeStore> {
    9 
    10         abstract public String getCode(ASTNode node);
     9       
     10        abstract public String getCode(ASTNode node);           
    1111        abstract public String getCode(ASTNode node, int indent);
    12 
     12       
    1313}
  • proto/pablo/src/compiler/codeGenerator/visitors/helpers/CodeStore.java

    r2671 r2702  
    8585                for(CodeLine codeLine: code) {
    8686                        indent += codeLine.relativeIndent;
    87                         addIndentation(indent, builder);
     87                        addIndentation(builder, indent);
    8888                        builder.append(codeLine.line);
    8989                        builder.append(NEWLINE);
     
    9393        }
    9494       
    95         private void addIndentation(int indent, StringBuilder builder) {
     95        //////////////////////////////////////////////////////////////
     96        // static interface
     97        /*
     98        public static void addIndentation(int indent, StringBuilder builder) {
     99               
     100        }
     101        */
     102        public static void addIndentation(StringBuilder builder, int indent) {
    96103                for(int i=0; i<indent; i++) {
    97104                        builder.append(INDENT);
  • proto/pablo/src/compiler/lang/pablo/BuiltinsUtil.java

    r2674 r2702  
    2020       
    2121        FuncCallNode fNode = (FuncCallNode)node;
    22         ASTNode nameNode = Accessors.FuncCallName(fNode);
    23         ASTNode ArgsListNode = (ASTNode)Accessors.FuncCallArgsListNode(fNode);
     22        ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
     23        ASTNode ArgsListNode = (ASTNode)Accessors.funcCallArgsListNode(fNode);
    2424   
    2525        // Advance(X)
     
    5353                for (Builtins carryOneOperation : Builtins.carryOneOperations()) {                     
    5454                               
    55                         ASTNode identifier = Accessors.FuncCallName((FuncCallNode) node);
    56                         int argCount = Accessors.FuncCallArgCount((FuncCallNode)node);
     55                        ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
     56                        int argCount = Accessors.funcCallArgCount((FuncCallNode)node);
    5757                       
    5858                        if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloName())
     
    6767               
    6868                for (Builtins carryNOperation : Builtins.carryNOperations()) {
    69                         ASTNode identifier = Accessors.FuncCallName((FuncCallNode) node);
    70                         int argCount = Accessors.FuncCallArgCount((FuncCallNode) node);
     69                        ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
     70                        int argCount = Accessors.funcCallArgCount((FuncCallNode) node);
    7171                       
    7272                if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloName())
     
    9292       
    9393        FuncCallNode fNode = (FuncCallNode)node;
    94         ASTNode nameNode = Accessors.FuncCallName(fNode);
     94        ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
    9595
    9696        for (Builtins builtin : Builtins.values()) {
     
    136136       
    137137        FuncCallNode fNode = (FuncCallNode)node;
    138         ASTNode nameNode = Accessors.FuncCallName(fNode);
     138        ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
    139139
    140140        boolean nameMatches = isQualifiedName(nameNode, packageName, FuncName);
    141         boolean numArgsMatches = Accessors.FuncCallArgsListNode(fNode).nChildren() == numArgs;
     141        boolean numArgsMatches = Accessors.funcCallArgsListNode(fNode).nChildren() == numArgs;
    142142       
    143143        return nameMatches && numArgsMatches;
     
    156156    public static boolean isQualifiedName(ASTNode node, String packageName, String FuncName) {
    157157        if(node instanceof IdentifierNode) {           
    158             return Accessors.identifierLexeme(node) == FuncName;
     158            return Accessors.name(node) == FuncName;
    159159        }
    160160        else if (node instanceof CompoundIdentifierNode) {
     
    162162            ASTNode member = node.child(1);
    163163           
    164             return   (Accessors.identifierLexeme(pckage) == packageName) &&
    165                      (Accessors.identifierLexeme(member) == FuncName);
     164            return   (Accessors.name(pckage) == packageName) &&
     165                     (Accessors.name(member) == FuncName);
    166166        }
    167167        return false;
  • proto/pablo/src/compiler/semanticAnalyzer/SemanticAnalyzer.java

    r2687 r2702  
    6666                AugAssign.XForm();
    6767               
    68                 CarryIntroXFormer carryQIntro = new CarryIntroXFormer(root, getCarrySet2Lang());
    69                 carryQIntro.XForm(ciMode, coMode);
     68                CarryIntroXFormer carryQIntro = new CarryIntroXFormer(root, getCarrySet2Lang()); // TODO - go modeless
     69                carryQIntro.XForm(ciMode /*, coMode */);
    7070               
    7171                Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(root, getBuiltins2Lang(), getCarrySet2Lang());
    72                 pablo2CarryQ.XForm(ciMode, coMode);                 
     72                pablo2CarryQ.XForm(ciMode /*, coMode */);                   
    7373           
    7474                AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(root, getBuiltins2Lang());
  • proto/pablo/src/compiler/semanticAnalyzer/visitors/AdvanceCombinerXFormer.java

    r2672 r2702  
    4646                        }
    4747                                                       
    48                         ASTNode argsList = Accessors.FuncCallArgsListNode((FuncCallNode) node);
     48                        ASTNode argsList = Accessors.funcCallArgsListNode((FuncCallNode) node);
    4949                        FuncCallNode child = (FuncCallNode)argsList.child(0);
    5050                       
     
    6464        private int advanceAmount(FuncCallNode node) {
    6565                assert BuiltinsUtil.isAdvance(node);
    66                 if(Accessors.FuncCallArgsListNode(node).nChildren()==1) {
     66                if(Accessors.funcCallArgsListNode(node).nChildren()==1) {
    6767                        return 1;
    6868                }
    69                 assert Accessors.FuncCallArgsListNode(node).nChildren()==2;
    70                 return valueOf(Accessors.FuncCallArgsListNode(node).child(1));
     69                assert Accessors.funcCallArgsListNode(node).nChildren()==2;
     70                return valueOf(Accessors.funcCallArgsListNode(node).child(1));
    7171        }       
    7272       
     
    7676                }                       
    7777               
    78                 ASTNode argsList = Accessors.FuncCallArgsListNode((FuncCallNode) node);
     78                ASTNode argsList = Accessors.funcCallArgsListNode((FuncCallNode) node);
    7979               
    8080                return BuiltinsUtil.isAdvance(argsList.child(0));
     
    8686                        int amount1, int amount2) {
    8787               
    88                 node.replaceChild(      Accessors.FuncCallArgsListNode(node),
    89                                                         Accessors.FuncCallArgsListNode(child));
     88                node.replaceChild(      Accessors.funcCallArgsListNode(node),
     89                                                        Accessors.funcCallArgsListNode(child));
    9090               
    9191                IntegerConstantNode integerConstantNode = Generators.makeIntegerConstantNode(amount1+amount2, node.getToken());
    92                 if(Accessors.FuncCallArgsListNode(node).nChildren()==1) {
    93                         Accessors.FuncCallArgsListNode(child).appendChild(integerConstantNode);
     92                if(Accessors.funcCallArgsListNode(node).nChildren()==1) {
     93                        Accessors.funcCallArgsListNode(child).appendChild(integerConstantNode);
    9494                }
    95                 assert Accessors.FuncCallArgsListNode(node).nChildren()==2;
    96                 Accessors.FuncCallArgsListNode(node).replaceChild(
    97                                 Accessors.FuncCallArgsListNode(node).child(1),
     95                assert Accessors.funcCallArgsListNode(node).nChildren()==2;
     96                Accessors.funcCallArgsListNode(node).replaceChild(
     97                                Accessors.funcCallArgsListNode(node).child(1),
    9898                                integerConstantNode);
    9999        }
  • proto/pablo/src/compiler/semanticAnalyzer/visitors/AssertZeroXFormer.java

    r2672 r2702  
    5050                                assert (node.getParent() instanceof BlockStmtNode);
    5151
    52                                 ASTNode errorCode = Accessors.FuncCallArgsListNode(node).child(1);
    53                                 ASTNode errorStream = Accessors.FuncCallArgsListNode(node).child(0);
     52                                ASTNode errorCode = Accessors.funcCallArgsListNode(node).child(1);
     53                                ASTNode errorStream = Accessors.funcCallArgsListNode(node).child(0);
    5454                               
    5555                                assert errorCode instanceof StringConstantNode;
  • proto/pablo/src/compiler/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2686 r2702  
    2020    }
    2121
    22     /** Appends carry information to Pablo AST 'If' 'While' Stmt nodes.
    23      * 
    24      * @param ci                        carry in mode
    25      * @param co                        carry out mode
    26      */ 
    27     public void XForm(boolean ci, boolean co) {
    28                 CarryIntroVisitor visitor = new CarryIntroVisitor(ci, co);
     22    public void XForm(boolean ci /*, boolean co*/) {
     23                XFormer visitor = new XFormer(ci /*, co*/);
    2924                ASTTree.accept(visitor);
    3025    }                   
    3126       
    32         private class CarryIntroVisitor extends VoidVisitor.Default {
     27        private class XFormer extends VoidVisitor.Default {
    3328
    3429                //private final String ciSuffix = "_ci";
     
    4439                //private int lastStmtCarries;
    4540               
    46                 CarryIntroVisitor(boolean ciMode, boolean coMode) {
     41                XFormer(boolean ciMode /*, boolean coMode */) {
    4742                        this.ciMode = ciMode;
    4843                        //this.coMode = coMode;
     
    105100                        int carryCount = (new CarryCounterVisitor(node)).count();
    106101                                               
    107                         if((carryCount == 0) || (!this.ciMode)) {
     102                        if(carryCount == 0) {
     103                                return;
     104                        }
     105                       
     106                        if(!this.ciMode) { // while loop body
    108107                                return;
    109108                        }
  • proto/pablo/src/compiler/semanticAnalyzer/visitors/Pablo2CarryXFormer.java

    r2686 r2702  
    3232    }
    3333
    34     /** XForms FuncDefNode AST sub-trees w.r.t. ci/co modes.
    35      * Augments AST with 'CarryQ' Func calls.
    36      * 
    37      * @param ci                        carry in mode
    38      * @param co                        carry out mode
    39      */ 
    40     public void XForm(boolean ci, boolean co) { // ci - carry in xformation mode, co - carry out mode xformation mode
    41                 CarryIntroVisitor visitor = new CarryIntroVisitor(ci, co);
     34    public void XForm(boolean ci /*, boolean co*/) {
     35                XFormer visitor = new XFormer(ci /*, co*/);
    4236                ASTTree.accept(visitor);
    4337    }                   
    4438       
    45         private class CarryIntroVisitor extends VoidVisitor.Default {
     39        private class XFormer extends VoidVisitor.Default {
    4640
    4741                //private final String ciSuffix = "_ci";
     
    5145               
    5246                private boolean ciMode;
    53                 private boolean coMode;
     47                //private boolean coMode;
    5448                               
    5549                private int currentCarry;
     
    5751                //private int lastStmtCarries;
    5852               
    59                 CarryIntroVisitor(boolean ciMode, boolean coMode) {
     53                XFormer(boolean ciMode /*, boolean coMode*/) {
    6054                        this.ciMode = ciMode;
    61                         this.coMode = coMode;
     55                        //this.coMode = coMode;
    6256                        this.currentCarry = 0;
    6357                        this.currentAdvN = 0;
     
    9690//              carry_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_carry)]
    9791//              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
     92
     93//                      TODO - Deprecate ciMode - *likely* no longer required
     94//
     95//                     
    9896                        if(ciMode) {
    9997                                carryCall = Generators.makeFuncCallNode(
     
    287285                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloName(), Builtins.ADVANCEN.argCount())) {
    288286                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
    289                                 // TODO ==> verify advNCall
     287                                // TODO - verify advNCall is correct
    290288                                replaceFuncCallNode(node,
    291289                                                CarrySet.CarryQ_IDENTIFIER,
     
    295293                                this.currentAdvN += 1;                 
    296294                        }                                       
    297        
    298         //          elif is_BuiltIn_Call(callnode, 'atEOF', 1):
    299         //            if self.carryout != "": 
    300         //              # Non final block: atEOF(x) = 0.
    301         //              return mkCall('simd<1>::constant<0>', [])
    302         //            else: return mkCall('simd_andc', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    303                        
    304                         else  if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ATEOF.pabloName(), Builtins.ATEOF.argCount())) {
    305                                          
    306                                 if(!this.coMode) { // if not final block
    307                                         List<ASTNode> args = new ArrayList<ASTNode>();
    308                                         for(ASTNode arg : Accessors.FuncCallArgsListNode(node).getChildren()) {
    309                                                 args.add(arg);
    310                                         }       
    311                                         args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    312                                         replacementNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(), node.getToken(), args);
    313                                        
    314                                 } else {
    315                                         replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                 
    316                                 }
    317                                 node.updateSelf(replacementNode);
    318                         }                                       
    319        
    320         //          elif is_BuiltIn_Call(callnode, 'inFile', 1):
    321         //            if self.carryout != "": 
    322         //              # Non final block: inFile(x) = x.
    323         //              return callnode.args[0]
    324         //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    325 
    326                         else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INFILE.pabloName(), Builtins.INFILE.argCount())) {
    327                                
    328                                 if(!this.coMode) {  // if not final block
    329                                         List<ASTNode> args = new ArrayList<ASTNode>();
    330                                        
    331                                         for(ASTNode arg : Accessors.FuncCallArgsListNode(node).getChildren()) {
    332                                                 args.add(arg);
    333                                         }
    334                                         args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    335                                         replacementNode = Generators.makeFuncCallNode(SIMD.AND.idisaName(), node.getToken(), args);
    336                                        
    337                                 } else {
    338                                         replacementNode = Accessors.FuncCallArg(node,0);
    339                                 }
    340                                 node.updateSelf(replacementNode);
    341                         }                                       
    342        
     295               
    343296//                      Deprecated - New bitblock iterators replace StreamScan.
    344297//                     
     
    378331                        List<ASTNode> args = new ArrayList<ASTNode>();
    379332                                               
    380                         for(ASTNode arg : Accessors.FuncCallArgsListNode(node).getChildren()) {
     333                        for(ASTNode arg : Accessors.funcCallArgsListNode(node).getChildren()) {
    381334                                args.add(arg);
    382335                        }       
  • proto/pablo/src/compiler/semanticAnalyzer/visitors/StreamFuncVisitor.java

    r2672 r2702  
    77import tokens.IdentifierToken;
    88import compiler.ast.Accessors;
     9import compiler.ast.Generators;
    910
    1011
     
    4647                               
    4748                public void visitLeave(FuncDefNode node) {
    48                                                
    49                         ASTNode FuncNameNode = Accessors.FuncName(node);       
    50                         String FuncName = FuncNameNode.getToken().getLexeme();
    51                         FuncName = capitalize(FuncName);
    52                         IdentifierToken newNameToken = IdentifierToken.make(LexicalType.IDENTIFIER, FuncNameNode.getToken().getLocation(), FuncName);
     49                                                       
     50                        String name = Accessors.funcName(node);
     51                        name = Generators.capitalize(name);
     52                        IdentifierToken nameToken = IdentifierToken.make(LexicalType.IDENTIFIER,
     53                                                                                node.getToken().getLocation(),
     54                                                                                name);
    5355                       
    54                         FuncNameNode.setToken(newNameToken);
    55                         streamFuncMap.put(FuncName, node);                                     
     56                        Accessors.funcIdentifier(node).setToken(nameToken);
     57                        streamFuncMap.put(name, node);                                 
    5658                       
    5759                }
    5860               
    59                 private String capitalize(String str) {
    60                         return str.substring(0, 1).toUpperCase() + str.substring(1);
    61                 }
    6261        }
    6362}
Note: See TracChangeset for help on using the changeset viewer.