Changeset 3133 for proto/pabloj


Ignore:
Timestamp:
May 13, 2013, 1:49:24 AM (6 years ago)
Author:
shermer
Message:

Further refactoring mainly in the pabloS visitors.
Grammar recompiled with latest scatter.

Location:
proto/pabloj/branches/refactor-experimental/src
Files:
1 added
1 deleted
23 edited
5 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/ASTVisitor.java

    r2984 r3133  
    115115                        return defaultVisit(node);
    116116                }
    117                 public T defaultVisitLeave(ASTNode node) {
     117                public T defaultVisitLeave(ASTNode node, List<T> childResults) {
    118118                        return defaultVisit(node);
    119119                }
     
    124124                }
    125125                public T visitLeave(ASTNode node, List<T> childResults) {
    126                         defaultVisitLeave(node);
     126                        defaultVisitLeave(node, childResults);
    127127                        throw new RuntimeException("Node class unimplemented in DefaultVisitor: " + node.getClass());
    128128                }
     
    132132                }
    133133                public T visitLeave(AssignNode node, List<T> childResults) {
    134                         return defaultVisitLeave(node);
     134                        return defaultVisitLeave(node, childResults);
    135135                }
    136136
     
    139139                }
    140140                public T visitLeave(AssignOperatorNode node, List<T> childResults) {
    141                         return defaultVisitLeave(node);
     141                        return defaultVisitLeave(node, childResults);
    142142                }
    143143
     
    146146                }
    147147                public T visitLeave(BinaryOperatorNode node, List<T> childResults) {
    148                         return defaultVisitLeave(node);
     148                        return defaultVisitLeave(node, childResults);
    149149                }
    150150
     
    153153                }
    154154                public T visitLeave(BlockStmtNode node, List<T> childResults) {
    155                         return defaultVisitLeave(node);
     155                        return defaultVisitLeave(node, childResults);
    156156                }
    157157
     
    160160                }
    161161                public T visitLeave(CompoundIdentifierNode node, List<T> childResults) {
    162                         return defaultVisitLeave(node);
     162                        return defaultVisitLeave(node, childResults);
    163163                }
    164164
     
    167167                }
    168168                public T visitLeave(EpsilonNode node, List<T> childResults) {
    169                         return defaultVisitLeave(node);
     169                        return defaultVisitLeave(node, childResults);
    170170                }
    171171
     
    174174                }
    175175                public T visitLeave(ErrorNode node, List<T> childResults) {
    176                         return defaultVisitLeave(node);
     176                        return defaultVisitLeave(node, childResults);
    177177                }
    178178
     
    181181                }
    182182                public T visitLeave(FieldWidthNode node, List<T> childResults) {
    183                         return defaultVisitLeave(node);
     183                        return defaultVisitLeave(node, childResults);
    184184                }
    185185
     
    188188                }
    189189                public T visitLeave(FuncCallArgListNode node, List<T> childResults) {
    190                         return defaultVisitLeave(node);
     190                        return defaultVisitLeave(node, childResults);
    191191                }
    192192
     
    195195                }
    196196                public T visitLeave(FuncCallNode node, List<T> childResults) {
    197                         return defaultVisitLeave(node);
     197                        return defaultVisitLeave(node, childResults);
    198198                }
    199199
     
    202202                }
    203203                public T visitLeave(FuncCallOrAssignStmtNode node, List<T> childResults) {
    204                         return defaultVisitLeave(node);
     204                        return defaultVisitLeave(node, childResults);
    205205                }
    206206
     
    209209                }
    210210                public T visitLeave(FuncDefNode node, List<T> childResults) {
    211                         return defaultVisitLeave(node);
     211                        return defaultVisitLeave(node, childResults);
    212212                }
    213213
     
    216216                }
    217217                public T visitLeave(IdentifierNode node, List<T> childResults) {
    218                         return defaultVisitLeave(node);
     218                        return defaultVisitLeave(node, childResults);
    219219                }
    220220
     
    223223                }
    224224                public T visitLeave(IfStmtNode node, List<T> childResults) {
    225                         return defaultVisitLeave(node);
     225                        return defaultVisitLeave(node, childResults);
    226226                }
    227227
     
    230230                }
    231231                public T visitLeave(IntegerConstantNode node, List<T> childResults) {
    232                         return defaultVisitLeave(node);
     232                        return defaultVisitLeave(node, childResults);
    233233                }
    234234
     
    237237                }
    238238                public T visitLeave(LocalVarAssignOperatorNode node, List<T> childResults) {
    239                         return defaultVisitLeave(node);
     239                        return defaultVisitLeave(node, childResults);
    240240                }
    241241
     
    244244                }
    245245                public T visitLeave(LocalVarDeclNode node, List<T> childResults) {
    246                         return defaultVisitLeave(node);
     246                        return defaultVisitLeave(node, childResults);
    247247                }
    248248
     
    251251                }
    252252                public T visitLeave(ParameterListNode node, List<T> childResults) {
    253                         return defaultVisitLeave(node);
     253                        return defaultVisitLeave(node, childResults);
    254254                }
    255255
     
    258258                }
    259259                public T visitLeave(ParameterNode node, List<T> childResults) {
    260                         return defaultVisitLeave(node);
     260                        return defaultVisitLeave(node, childResults);
    261261                }
    262262
     
    265265                }
    266266                public T visitLeave(ProgramNode node, List<T> childResults) {
    267                         return defaultVisitLeave(node);
     267                        return defaultVisitLeave(node, childResults);
    268268                }
    269269
     
    272272                }
    273273                public T visitLeave(ReturnStmtNode node, List<T> childResults) {
    274                         return defaultVisitLeave(node);
     274                        return defaultVisitLeave(node, childResults);
    275275                }
    276276
     
    279279                }
    280280                public T visitLeave(StreamTypeNode node, List<T> childResults) {
    281                         return defaultVisitLeave(node);
     281                        return defaultVisitLeave(node, childResults);
    282282                }
    283283
     
    286286                }
    287287                public T visitLeave(StringConstantNode node, List<T> childResults) {
    288                         return defaultVisitLeave(node);
     288                        return defaultVisitLeave(node, childResults);
    289289                }
    290290
     
    293293                }
    294294                public T visitLeave(StructMemberNode node, List<T> childResults) {
    295                         return defaultVisitLeave(node);
     295                        return defaultVisitLeave(node, childResults);
    296296                }
    297297
     
    300300                }
    301301                public T visitLeave(StructTypeBodyNode node, List<T> childResults) {
    302                         return defaultVisitLeave(node);
     302                        return defaultVisitLeave(node, childResults);
    303303                }
    304304
     
    307307                }
    308308                public T visitLeave(StructTypeNode node, List<T> childResults) {
    309                         return defaultVisitLeave(node);
     309                        return defaultVisitLeave(node, childResults);
    310310                }
    311311
     
    314314                }
    315315                public T visitLeave(TypeDeclNode node, List<T> childResults) {
    316                         return defaultVisitLeave(node);
     316                        return defaultVisitLeave(node, childResults);
    317317                }
    318318
     
    321321                }
    322322                public T visitLeave(UnaryOperatorNode node, List<T> childResults) {
    323                         return defaultVisitLeave(node);
     323                        return defaultVisitLeave(node, childResults);
    324324                }
    325325
     
    328328                }
    329329                public T visitLeave(VoidTypeNode node, List<T> childResults) {
    330                         return defaultVisitLeave(node);
     330                        return defaultVisitLeave(node, childResults);
    331331                }
    332332
     
    335335                }
    336336                public T visitLeave(WhileStmtNode node, List<T> childResults) {
    337                         return defaultVisitLeave(node);
     337                        return defaultVisitLeave(node, childResults);
    338338                }
    339339
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/CharacterToken.java

    r3115 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class CharacterToken extends TokenImp implements IntValuedToken {
    1414        private char value;
    1515
    16         protected CharacterToken(LexicalType type, TextLocation location, String lexeme, char value) {
     16        protected CharacterToken(LexicalType type, Locator location, String lexeme, char value) {
    1717                super(type, location, lexeme.intern());
    1818                this.value = value;
    1919        }
    2020       
    21         public static CharacterToken make(LexicalType type, TextLocation location, String lexeme) {
     21        public static CharacterToken make(LexicalType type, Locator location, String lexeme) {
    2222                CharacterToken result = new CharacterToken(type, location, lexeme, lexeme.charAt(0));
    2323                return result;
    2424        }
    25         public static CharacterToken make(LexicalType type, TextLocation location, String lexeme, char value) {
     25        public static CharacterToken make(LexicalType type, Locator location, String lexeme, char value) {
    2626                CharacterToken result = new CharacterToken(type, location, lexeme, value);
    2727                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/CommentToken.java

    r2834 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class CommentToken extends TokenImp {
    1414       
    15         protected CommentToken(LexicalType type, TextLocation location, String lexeme) {
     15        protected CommentToken(LexicalType type, Locator location, String lexeme) {
    1616                super(type, location, lexeme);
    1717        }
    1818       
    19         public static CommentToken make(LexicalType type, TextLocation location, String lexeme) {
     19        public static CommentToken make(LexicalType type, Locator location, String lexeme) {
    2020                CommentToken result = new CommentToken(type, location, lexeme);
    2121                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/EscapeToken.java

    r3080 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class EscapeToken extends TokenImp  implements IntValuedToken {
     
    1515        private int valueRadix;
    1616       
    17         protected EscapeToken(LexicalType type, TextLocation location, String lexeme, String escaped, int valueRadix) {
     17        protected EscapeToken(LexicalType type, Locator location, String lexeme, String escaped, int valueRadix) {
    1818                super(type, location, lexeme);
    1919                this.escaped = escaped;
     
    2121        }
    2222       
    23         public static EscapeToken make(LexicalType type, TextLocation location, String lexeme, String escaped, int valueRadix) {
     23        public static EscapeToken make(LexicalType type, Locator location, String lexeme, String escaped, int valueRadix) {
    2424                EscapeToken result = new EscapeToken(type, location, lexeme, escaped, valueRadix);
    2525                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/FloatConstantToken.java

    r2834 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class FloatConstantToken extends TokenImp {
    1414        protected double value;
    1515       
    16         protected FloatConstantToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected FloatConstantToken(LexicalType type, Locator location, String lexeme) {
    1717                super(type, location, lexeme);
    1818        }
     
    2424        }
    2525       
    26         public static FloatConstantToken make(LexicalType type, TextLocation location, String lexeme) {
     26        public static FloatConstantToken make(LexicalType type, Locator location, String lexeme) {
    2727                FloatConstantToken result = new FloatConstantToken(type, location, lexeme);
    2828                result.setValue(Double.parseDouble(lexeme));
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/IdentifierToken.java

    r2834 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class IdentifierToken extends TokenImp {
    14         protected IdentifierToken(LexicalType type, TextLocation location, String lexeme) {
     14        protected IdentifierToken(LexicalType type, Locator location, String lexeme) {
    1515                super(type, location, lexeme.intern());
    1616        }
    1717       
    18         public static IdentifierToken make(LexicalType type, TextLocation location, String lexeme) {
     18        public static IdentifierToken make(LexicalType type, Locator location, String lexeme) {
    1919                IdentifierToken result = new IdentifierToken(type, location, lexeme);
    2020                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/IntConstantToken.java

    r3080 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class IntConstantToken extends TokenImp implements IntValuedToken {
    1414        protected int value;
    1515       
    16         protected IntConstantToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected IntConstantToken(LexicalType type, Locator location, String lexeme) {
    1717                super(type, location, lexeme);
    1818        }
     
    2424        }
    2525       
    26         public static IntConstantToken make(LexicalType type, TextLocation location, String lexeme) {
     26        public static IntConstantToken make(LexicalType type, Locator location, String lexeme) {
    2727                IntConstantToken result = new IntConstantToken(type, location, lexeme);
    2828                result.setValue(Integer.parseInt(lexeme));
     
    3535        }
    3636       
    37         public static Token makeArtifical(LexicalType type, TextLocation location, int value) {
     37        public static Token makeArtifical(LexicalType type, Locator location, int value) {
    3838                IntConstantToken result = new IntConstantToken(type, location, ""+value);
    3939                result.setValue(value);
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/LextantToken.java

    r2834 r3133  
    1010import pabloS.lexicalAnalyzer.LexicalType;
    1111import pabloS.lexicalAnalyzer.Lextant;
    12 import pabloS.inputHandler.TextLocation;
     12import pabloS.inputHandler.Locator;
    1313
    1414public final class LextantToken extends TokenImp {
     
    1616        private Lextant lextant;
    1717       
    18         private LextantToken(TextLocation location, String lexeme, Lextant lextant) {
     18        private LextantToken(Locator location, String lexeme, Lextant lextant) {
    1919                super(LexicalType.LEXTANT, location, lexeme);
    2020                this.lextant = lextant;
     
    3535        }
    3636       
    37         public static LextantToken make(TextLocation location, String lexeme, Lextant lextant) {
     37        public static LextantToken make(Locator location, String lexeme, Lextant lextant) {
    3838                return new LextantToken(location, lexeme, lextant);
    3939        }
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/NullToken.java

    r2834 r3133  
    1010import pabloS.lexicalAnalyzer.LexicalType;
    1111import pabloS.inputHandler.TextLocation;
     12import pabloS.inputHandler.Locator;
    1213
    1314public class NullToken extends TokenImp {
    1415
    15         protected NullToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected NullToken(LexicalType type, Locator location, String lexeme) {
    1617                super(type, location, lexeme);
    1718        }
     
    2223        }
    2324       
    24         public static NullToken make(LexicalType type, TextLocation location) {
     25        public static NullToken make(LexicalType type, Locator location) {
    2526                NullToken result = new NullToken(type, location, "");
    2627                return result;
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/StringConstantToken.java

    r2834 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class StringConstantToken extends TokenImp {
    1414        protected String value;
    1515       
    16         protected StringConstantToken(LexicalType type, TextLocation location, String lexeme) {
     16        protected StringConstantToken(LexicalType type, Locator location, String lexeme) {
    1717                super(type, location, lexeme);
    1818        }
     
    2424        }
    2525       
    26         public static StringConstantToken make(LexicalType type, TextLocation location, String lexeme) {
     26        public static StringConstantToken make(LexicalType type, Locator location, String lexeme) {
    2727                StringConstantToken result = new StringConstantToken(type, location, "\"" + lexeme + "\"");
    2828                result.setValue(lexeme);
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/TokenImp.java

    r2834 r3133  
    1111import pabloS.lexicalAnalyzer.Lextant;
    1212import pabloS.inputHandler.TextLocation;
     13import pabloS.inputHandler.Locator;
    1314
    1415public abstract class TokenImp implements Token {
     
    1718        private LexicalType lexicalType;
    1819
    19         protected TokenImp(LexicalType lexicalType, TextLocation location, String lexeme) {
     20        protected TokenImp(LexicalType lexicalType, Locator location, String lexeme) {
    2021                super();
    2122                this.lexicalType = lexicalType;
    22                 this.location = location;
     23                this.location = location.getLocation();
    2324                this.lexeme = lexeme;
    2425        }
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/WhitespaceToken.java

    r2834 r3133  
    99
    1010import pabloS.lexicalAnalyzer.LexicalType;
    11 import pabloS.inputHandler.TextLocation;
     11import pabloS.inputHandler.Locator;
    1212
    1313public class WhitespaceToken extends TokenImp {
    1414       
    15         protected WhitespaceToken(LexicalType type, TextLocation location, String lexeme) {
     15        protected WhitespaceToken(LexicalType type, Locator location, String lexeme) {
    1616                super(type, location, lexeme);
    1717        }
    1818       
    19         public static WhitespaceToken make(LexicalType type, TextLocation location, String lexeme) {
     19        public static WhitespaceToken make(LexicalType type, Locator location, String lexeme) {
    2020                WhitespaceToken result = new WhitespaceToken(type, location, lexeme);
    2121                return result;
  • proto/pabloj/branches/refactor-experimental/src/test/pabloS/PabloSTestHarness.java

    r3115 r3133  
    2020import toolchain.pabloS.semanticAnalyzer.visitors.CombineAdvances;
    2121import toolchain.pabloS.semanticAnalyzer.visitors.ExpandAugmentedAssignments;
    22 import toolchain.pabloS.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
    23 import toolchain.pabloS.semanticAnalyzer.visitors.InitStreamDefaultsXFormer;
     22import toolchain.pabloS.semanticAnalyzer.visitors.ConvertBitwiseBooleanToIDISACalls;
     23import toolchain.pabloS.semanticAnalyzer.visitors.InitializeStreamDefaults;
    2424import toolchain.pabloS.semanticAnalyzer.visitors.StreamFuncVisitor;
    2525import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryIntroXFormer;
     
    164164               
    165165                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
    166                         Bitwise2IDISAXFormer bitwise2IDISA = new Bitwise2IDISAXFormer(entry.getValue());
    167                         bitwise2IDISA.XForm();                     
     166                        ASTNode bitwise2IDISA = ConvertBitwiseBooleanToIDISACalls.apply(entry.getValue());
    168167                }
    169168               
     
    213212                        ASTNode value = entry.getValue();                               
    214213                        CarrySetEncoder carrySet2CPP = new CarrySetBuiltins2CPP();
    215                         CarryIntroXFormer pablo2CarryQ = new CarryIntroXFormer(value, builtins2CPP, carrySet2CPP);
    216                         pablo2CarryQ.XForm(isFinalBlock);
     214                        ASTNode pablo2CarryQ = CarryIntroXFormer.apply(value, builtins2CPP, carrySet2CPP, isFinalBlock);
    217215                }   
    218216               
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/ast/Accessors.java

    r3010 r3133  
    6767        }
    6868        */
    69        
     69
     70        ////////////////////////////////////////////////////////////////////////////
     71        // AssignNode
     72        ////////////////////////////////////////////////////////////////////////////
    7073        public static ASTNode lhs(AssignNode node) {
    7174                return node.child(0);
     
    8083        }
    8184       
    82         public static String assignOperatorLexeme(FuncCallNode node) {
    83                 return node.getToken().getLexeme();
    84         }       
    85        
    86         ////////////////////////////////////////////////////////////////////////////
    87         // Local variable declarations
     85       
     86        ////////////////////////////////////////////////////////////////////////////
     87        // LocalVarDeclNode
    8888        ////////////////////////////////////////////////////////////////////////////
    8989        public static ASTNode type(LocalVarDeclNode node) {
     
    106106       
    107107        public static boolean hasInitializationAssign(LocalVarDeclNode node) {
    108 
    109108                if (node.nChildren() > 2) {
    110109                        return true;
     
    113112        }
    114113
     114        ////////////////////////////////////////////////////////////////////////////
     115        // UnaryOperatorNode
     116        ////////////////////////////////////////////////////////////////////////////
    115117        public static ASTNode operand(UnaryOperatorNode node) {
    116118                return node.child(0);
     
    120122                return node.getToken().getLexeme();
    121123        }
    122        
     124
     125        ////////////////////////////////////////////////////////////////////////////
     126        // BinaryOperatorNode
     127        ////////////////////////////////////////////////////////////////////////////
    123128        public static ASTNode lhs(BinaryOperatorNode node) {
    124129                return node.child(0);
     
    132137                return node.getToken().getLexeme();
    133138        }               
    134        
    135         public static String integerConstantLexeme(IntegerConstantNode node) {
    136                 return node.getToken().getLexeme();
    137         }                       
    138                                        
    139         public static String stringConstantLexeme(StringConstantNode node) {
    140                 return node.getToken().getLexeme();
    141         }                       
    142        
     139
     140        ////////////////////////////////////////////////////////////////////////////
     141        // IfStmtNode
     142        ////////////////////////////////////////////////////////////////////////////
    143143        public static ASTNode ifTest(IfStmtNode node) {
    144144                return (ASTNode) node.child(0);
     145        }       
     146        public static ASTNode condition(IfStmtNode node) {
     147                return ifTest(node);
    145148        }
    146149
     
    150153       
    151154        public static boolean hasElseBlockStmt(IfStmtNode node) {
     155                return hasElseClause(node);
     156        }       
     157        public static boolean hasElseClause(IfStmtNode node) {
    152158                return node.nChildren() > 2;
    153159        }
    154160       
    155161        public static BlockStmtNode elseBlockStmt(IfStmtNode node) {
     162                return elseClause(node);
     163        }       
     164        public static BlockStmtNode elseClause(IfStmtNode node) {
    156165                return (BlockStmtNode) node.child(2);
    157166        }
    158167
     168        ////////////////////////////////////////////////////////////////////////////
     169        // WhileStmtNode
     170        ////////////////////////////////////////////////////////////////////////////
    159171        public static ASTNode whileTest(WhileStmtNode node) {
    160                 return node.child(0);
    161         }       
    162                
     172                return condition(node);
     173        }               
     174        public static ASTNode condition(WhileStmtNode node) {
     175                return node.child(0);
     176        }
    163177        public static ASTNode whileBlockStmt(WhileStmtNode node) {
     178                return body(node);
     179        }       
     180        public static ASTNode body(WhileStmtNode node) {
    164181                return node.child(1);
    165182        }
    166183       
     184
     185        ////////////////////////////////////////////////////////////////////////////
     186        // FuncDefNode
     187        ////////////////////////////////////////////////////////////////////////////
     188       
     189        //TS: what is node.child(0) ?
    167190        public static IdentifierNode funcIdentifier(FuncDefNode node) {
    168191                return (IdentifierNode) node.child(1);
    169192        }
    170        
    171193        public static String funcName(FuncDefNode node) {
    172194                return Accessors.name(node.child(1));
    173         }
    174                
     195        }       
    175196        public static boolean hasParameters(FuncDefNode node) {
    176197                ASTNode child2 = node.child(2);
     
    181202                return false;
    182203        }
    183        
    184         public static ParameterListNode parameterListNode(FuncDefNode node) {
    185                
     204        public static ParameterListNode parameterListNode(FuncDefNode node) {   
    186205                if(hasParameters(node)) {
    187206                        return (ParameterListNode) node.child(2);
     
    190209                return null;
    191210        }
    192        
     211        public static BlockStmtNode body(FuncDefNode node) {
     212                return blockStmtNode(node);
     213        }
    193214        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
    194215                int blockStmtNodeIndex;
     
    203224                assert child instanceof BlockStmtNode;
    204225        return (BlockStmtNode) child;
    205         }       
    206                
     226        }
     227       
     228
     229        ////////////////////////////////////////////////////////////////////////////
     230        // FuncCallNode
     231        ////////////////////////////////////////////////////////////////////////////
     232       
     233        public static String assignOperatorLexeme(FuncCallNode node) {
     234                return node.getToken().getLexeme();
     235        }
    207236        public static ASTNode funcCallIdentifier(FuncCallNode node) {
    208237                return node.child(0);
    209238        }
    210 
    211239        public static ASTNode funcCallArgsListNode(FuncCallNode node) {
    212240                return node.child(1);
    213241        }
    214        
    215242        public static int funcCallArgCount(FuncCallNode node) {
    216243                ASTNode argList = Accessors.funcCallArgsListNode(node);
     
    232259                return Accessors.funcCallArgsListNode(node).getChildren();
    233260        }
    234                
    235261    public static String funcCallName(ASTNode node) {
    236262        String name = new String();
     
    245271            name += Accessors.name(member);
    246272        }
     273        else {  // TS: added
     274                assert false: "Accessors.funcCallName() called on node of improper type.";
     275        }
    247276        return name;
    248277    }   
    249        
    250         public static String name(ASTNode node) {
    251                 assert node instanceof IdentifierNode;
    252                 return node.getToken().getLexeme();
    253         }
    254 
     278
     279
     280        ////////////////////////////////////////////////////////////////////////////
     281        // StructTypeNode
     282        ////////////////////////////////////////////////////////////////////////////
     283       
    255284        public static String structName(StructTypeNode node) {
    256285        String name = new String();
     
    279308       
    280309        ////////////////////////////////////////////////////////////////////////////
     310        // StreamTypeNode
     311        //
    281312        // 2^k stream type
    282313        ////////////////////////////////////////////////////////////////////////////
     
    285316        }       
    286317
    287         ////////////////////////////////////////////////////////////////////////////
    288         // Field Width
    289         ////////////////////////////////////////////////////////////////////////////
     318
    290319        public static boolean hasFieldWidth(StreamTypeNode node) {             
    291320                if(1 == node.nChildren()) {
     
    301330        }
    302331       
     332       
     333        ////////////////////////////////////////////////////////////////////////////
     334        // FieldWidthNode
     335        ////////////////////////////////////////////////////////////////////////////
    303336        public static String fieldWidthLexeme(FieldWidthNode node) {           
    304337                return node.getToken().getLexeme();
    305338        }       
    306339
     340        ////////////////////////////////////////////////////////////////////////////
     341        // VoidTypeNode
     342        ////////////////////////////////////////////////////////////////////////////
    307343        public static String voidValueLexeme(VoidTypeNode node) {               
    308344                return node.getToken().getLexeme();
    309         }       
     345        }               
     346
     347        ////////////////////////////////////////////////////////////////////////////
     348        // IdentifierNode
     349        ////////////////////////////////////////////////////////////////////////////
     350        public static String name(ASTNode node) {
     351                assert node instanceof IdentifierNode;
     352                return node.getToken().getLexeme();
     353        }
     354
     355        ////////////////////////////////////////////////////////////////////////////
     356        // IntegerConstantNode
     357        ////////////////////////////////////////////////////////////////////////////
     358       
     359        public static String integerConstantLexeme(IntegerConstantNode node) {
     360                return node.getToken().getLexeme();
     361        }                       
     362
     363        ////////////////////////////////////////////////////////////////////////////
     364        // StringConstantNode
     365        ////////////////////////////////////////////////////////////////////////////
     366        public static String stringConstantLexeme(StringConstantNode node) {
     367                return node.getToken().getLexeme();
     368        }                       
     369
    310370       
    311371}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/ast/Generators.java

    r3115 r3133  
    2323public class Generators {
    2424
     25        // TS: should change grammar and conventions so that every FuncDefNode has a ParameterListNode child
     26        //     but the PLN child has no children if there are no args.  This would eliminate the conditional
     27        //     in this method, and probably make things easier in other methods, too.
    2528        public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
    2629               
     
    5053        }
    5154
    52         // Make function Call variants
    53         public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, ASTNode ...args) {
    54                
    55                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
    56                 Generators.addFuncCallArgs(node, args);
    57                 return node;
    58         }       
    59 
    60         public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, List<ASTNode> args) {
    61                
    62                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
    63                 Generators.addFuncCallArgs(node, args);
    64                 return node;
    65         }       
    66        
     55       
     56       
     57       
     58        // Make function Call variants 
    6759        public static FuncCallNode makeFuncCallNode(String identifier, Locator locator) {
    6860                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);     
    6961                return Generators.makeFuncCallNode(identifierNode, locator);
    7062        }
     63       
     64        public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, ASTNode ...args) {
     65               
     66                FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
     67                Generators.addFuncCallArgs(node, args);
     68                return node;
     69        }       
     70
     71        public static FuncCallNode makeFuncCallNode(String identifier, Locator locator, List<ASTNode> args) {
     72               
     73                FuncCallNode node = Generators.makeFuncCallNode(identifier, locator);
     74                Generators.addFuncCallArgs(node, args);
     75                return node;
     76        }       
     77
    7178
    7279        public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, ASTNode ...args) {
     
    118125        }       
    119126                       
    120         /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from token.
     127       
     128       
     129       
     130       
     131        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
    121132         * Currently, no special consideration with only one identifier in the array.
    122133         * (Maybe we can return a IdentifierNode directly in later versions.)
     
    135146        }
    136147
    137         /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from token.
     148        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
    138149         * @param identifier
    139150         * @param locator               a token containing the TextLocation for this new node.
     
    145156        }
    146157       
    147         /** Makes a new LextantToken with the given lextant and location taken from the given token.
     158        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
    148159         * @param lextant
    149160         * @param locator
     
    154165        }
    155166
    156         /** Makes a new StringConstantToken with the given string and location taken from the given token.
     167        /** Makes a new StringConstantToken with the given string and location taken from the given locator.
    157168         * @param string
    158169         * @param locator
     
    163174        }
    164175
    165         /** Makes a new IdentifierToken with the given identifier and location taken from the given token.
     176        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
    166177         * @param identifier
    167178         * @param locator
     
    172183        }
    173184
    174         /** Makes a new StringConstantNode with the given string and the TextLocation taken from token.
     185        /** Makes a new StringConstantNode with the given string and the TextLocation taken from locator.
    175186         * @param string                        string value/lexeme of new node.
    176          * @param locator               a token containing the TextLocation for this new node.
     187         * @param locator                       a locator containing the TextLocation for this new node.
    177188         * @return      the new StringConstantNode
    178189         */
     
    182193        }
    183194
    184         /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from token.
     195        /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from locator.
    185196         * @param n                     integer value of new node.
    186197         * @param locator               a token containing the TextLocation for this new node.
     
    229240        }
    230241       
    231         public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    232                 List<ASTNode> args = new ArrayList<ASTNode>();
    233                 args.add(node);
    234                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
    235                 return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.AND.Name(), node.getToken(), args);
     242        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, BuiltinEncoder encoder) {
     243                Locator location = (Locator)node;
     244                ASTNode eofMask = makeIdentifierNode(encoder.getCode(PabloSBuiltins.EOFMASK), location);
     245                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.AND.Name(), location, arguments(node, eofMask));
     246        }               
     247        private static ASTNode[] arguments(ASTNode...astNodes) {
     248                return astNodes;
    236249        }
    237250
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/Transformer.java

    r3115 r3133  
    1212import toolchain.pabloS.semanticAnalyzer.visitors.SurroundAssert0sWithIfs;
    1313import toolchain.pabloS.semanticAnalyzer.visitors.ExpandAugmentedAssignments;
    14 import toolchain.pabloS.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
     14import toolchain.pabloS.semanticAnalyzer.visitors.ConvertBitwiseBooleanToIDISACalls;
    1515import toolchain.pabloS.semanticAnalyzer.visitors.AddAssignmentPrints;
    16 import toolchain.pabloS.semanticAnalyzer.visitors.InitStreamDefaultsXFormer;
     16import toolchain.pabloS.semanticAnalyzer.visitors.InitializeStreamDefaults;
    1717import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryIntroXFormer;
    1818
     
    7272                decoratedTree = SurroundAssert0sWithIfs.apply(decoratedTree, getBuiltinEncoder());             
    7373                decoratedTree = CombineAdvances.apply(decoratedTree);
    74 
    75             CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getBuiltinEncoder(), getCarrySet2Lang());
    76                 carryQIntro.XForm(finalBlockMode);             
    77 
    78                 Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
    79                 bitwiseToIDISA.XForm();                 
    80 
    81                 InitStreamDefaultsXFormer initStreamDefaults = new InitStreamDefaultsXFormer(decoratedTree);
    82                 initStreamDefaults.XForm();
     74                decoratedTree = CarryIntroXFormer.apply(decoratedTree, getBuiltinEncoder(), getCarrySet2Lang(), finalBlockMode);
     75                decoratedTree = ConvertBitwiseBooleanToIDISACalls.apply(decoratedTree);
     76                decoratedTree = InitializeStreamDefaults.apply(decoratedTree);
    8377               
    8478                return decoratedTree;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/helpers/ASTAssertCompareVisitor.java

    r3116 r3133  
    77 */
    88
    9 package toolchain.pabloS.semanticAnalyzer.visitors;
     9package toolchain.pabloS.semanticAnalyzer.helpers;
    1010
    1111import java.util.List;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/helpers/AssertCompare.java

    r3010 r3133  
    1111
    1212import pabloS.ast.*;
    13 import toolchain.pabloS.semanticAnalyzer.visitors.ASTAssertCompareVisitor;
    1413
    1514public class AssertCompare {
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/ConvertBitwiseBooleanToIDISACalls.java

    r3116 r3133  
    88
    99import pabloS.ast.*;
     10import pabloS.inputHandler.Locator;
    1011import pabloS.lexicalAnalyzer.Lextant;
    1112import pabloS.tokens.Token;
     
    1516import toolchain.pabloS.ast.Generators;
    1617
     18import static toolchain.pabloB.lang.idisa.IDISASIMDBitwiseBuiltins.*;
    1719
    18 public class Bitwise2IDISAXFormer {
    19         private ASTNode ASTTree;
     20public class ConvertBitwiseBooleanToIDISACalls {
     21        private ConvertBitwiseBooleanToIDISACalls() {}
    2022       
    21         public Bitwise2IDISAXFormer(ASTNode ASTree) {
    22                 this.ASTTree = ASTree;
    23         }
    24        
    25         public ASTNode XForm() {
     23        static public ASTNode apply(ASTNode root) {
     24                ASTNode ASTTree = root;
    2625               
    2726                Bitwise2IDISABinaryOperatorXFormer binOpXformer = new Bitwise2IDISABinaryOperatorXFormer();
     
    4544         *
    4645         */
    47         private class Bitwise2IDISABinaryOperatorXFormer extends VoidVisitor.Default {
    48 
     46        static private class Bitwise2IDISABinaryOperatorXFormer extends VoidVisitor.Default {
    4947                public void visitLeave(BinaryOperatorNode node) {
    5048                        Token token = node.getToken();
    5149                       
    5250                        if(token.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
    53                                 FuncCallNode funcCallNode = null;
    54                                 if(token.isLextant(Lextant.OR)) {
    55                                         funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.OR.Name(),
    56                                                                                                                                 token,
    57                                                                                                                                 new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
    58                                 } else if(token.isLextant(Lextant.AND)) {
    59                                        
    60                                         if (Accessors.rhs(node).getToken().isLextant(Lextant.NOT)) {                                           
    61                                                 funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(),
    62                                                                                                                                         token,
    63                                                                                                                                         new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node).child(0)});
    64                                         } else if(Accessors.lhs(node).getToken().isLextant(Lextant.NOT)) {
    65                                                 funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(),
    66                                                                                                                                         token,
    67                                                                                                                                         new ASTNode [] {Accessors.rhs(node), Accessors.lhs(node).child(0)});
    68                                         } else {
    69                                                 funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.AND.Name(),
    70                                                                                                                                         token,
    71                                                                                                                                         new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});                                             
    72                                         }
    73                                        
    74                                 } else if (token.isLextant(Lextant.XOR)){
    75                                         funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.XOR.Name(),
    76                                                                                                                                 token,
    77                                                                                                                                 new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
     51                                ASTNode replacement = makeIDISABinaryOperator(node, token);
     52                                node.updateSelf(replacement);
     53                        }               
     54                }
     55
     56                private FuncCallNode makeIDISABinaryOperator(BinaryOperatorNode node, Token token) {
     57                        Locator locator = (Locator)token;
     58                        ASTNode lhs = lhs(node);
     59                        ASTNode rhs = rhs(node);
     60                        if(token.isLextant(Lextant.OR)) {
     61                                return makeIDISACall(OR,
     62                                                                         arguments(lhs, rhs),
     63                                                                         locator);
     64                        }
     65                        if(token.isLextant(Lextant.AND)) {
     66                                // TS: this optimization seems inappropriate for pabloS to handle.
     67                                if (rhs.getToken().isLextant(Lextant.NOT)) {                                           
     68                                        return  makeIDISACall(ANDC,
     69                                                                                  arguments(lhs, rhs.child(0)),
     70                                                                                  locator);
     71                                }
     72                                else if(lhs.getToken().isLextant(Lextant.NOT)) {
     73                                        return  makeIDISACall(ANDC,
     74                                                                                  arguments(rhs, lhs.child(0)),
     75                                                                                  locator);
     76                                }
     77                                else {
     78                                        return  makeIDISACall(AND,
     79                                                                                  arguments(lhs, rhs),
     80                                                                                  locator);                                             
    7881                                }
    79                                
    80                                 node.updateSelf(funcCallNode);
    81                                
    82                         }               
     82                        }
     83                        else {  // if (token.isLextant(Lextant.XOR)){
     84                                return makeIDISACall(XOR,
     85                                                                         arguments(lhs, rhs),
     86                                                                         token);
     87                        }
     88                }
     89
     90
     91                private ASTNode rhs(BinaryOperatorNode node) {
     92                        return Accessors.rhs(node);
     93                }
     94                private ASTNode lhs(BinaryOperatorNode node) {
     95                        return Accessors.lhs(node);
    8396                }
    8497        }       
     
    87100         * PabloS unary ops to IDISA
    88101         */
    89         private class Bitwise2IDISAUnaryOperatorXFormer extends VoidVisitor.Default {
     102        static private class Bitwise2IDISAUnaryOperatorXFormer extends VoidVisitor.Default {
    90103                public void visitLeave(UnaryOperatorNode node) {
    91                         Token op = node.getToken();
    92                         if(op.isLextant(Lextant.NOT)) {
    93 
    94                                 FuncCallNode FuncCallNode =
    95                                                 Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.NOT.Name(),
    96                                                                                                                                 op,
    97                                                                                                                                 new ASTNode [] {Accessors.operand(node)});                     
    98                                 node.updateSelf(FuncCallNode);
     104                        Token token = node.getToken();
     105                        if(token.isLextant(Lextant.NOT)) {
     106                                ASTNode replacement =
     107                                                makeIDISACall(NOT, arguments(Accessors.operand(node)), token);                 
     108                                node.updateSelf(replacement);
    99109                        }
    100110                }               
     
    104114         * PabloS 'if and 'while' to PabloB 'if and 'while'
    105115         */
    106         private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
    107                
    108 //          def visit_If_Node(self, ifNode):
    109 //        self.generic_visit(ifNode)
    110 //        ifNode.test = makeCall('bitblock::any', [ifNode.test])
    111 //        return ifNode         
     116        static private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
    112117                public void visitLeave(IfStmtNode node) {
    113                         ASTNode ifTest = Accessors.ifTest(node);                       
    114                         String FuncName = IDISABitBlockBuiltins.ANY.IDISALexeme(); // TODO Update to IDISA syntax
    115                         FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest});
    116                         node.replaceChild(ifTest, FuncCallNode);
     118                        ASTNode condition = Accessors.ifTest(node);                     
     119                        insertANYintoCondition(node, condition);
    117120                }
    118121               
    119 //          def visit_While_Node(self, whileNode):
    120 //              self.generic_visit(whileNode)
    121 //              whileNode.test = makeCall('bitblock::any', [whileNode.test])
    122 //              return whileNode
    123122                public void visitLeave(WhileStmtNode node) {
    124                         ASTNode whileTest = Accessors.whileTest(node);                 
    125                                                                                                                                
     123                        ASTNode condition = Accessors.whileTest(node);                         
     124                        insertANYintoCondition(node, condition);
     125                }
     126
     127                private void insertANYintoCondition(ASTNode node, ASTNode condition) {
    126128                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
    127129                                        IDISABitBlockBuiltins.ANY.IDISALexeme(), // TODO Update to IDISA syntax
    128                                         node.getToken(),
    129                                         new ASTNode [] {whileTest});                           
     130                                        node,
     131                                        arguments(condition.deepCopy()));                               
    130132                       
    131                         node.replaceChild(whileTest, FuncCallNode);
     133                        node.replaceChild(condition, FuncCallNode);
    132134                }
     135        }
     136       
     137        static private FuncCallNode makeIDISACall(IDISASIMDBitwiseBuiltins idisaName, ASTNode[] arguments, Locator locator) {
     138                return Generators.makeFuncCallNode(idisaName.Name(), locator, arguments);
     139        }
     140        static private ASTNode[] arguments(ASTNode...astNodes) {
     141                return astNodes;
    133142        }
    134143}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/InitializeStreamDefaults.java

    r3116 r3133  
    1919
    2020
    21 public class InitStreamDefaultsXFormer {
    22         private ASTNode ASTTree;
     21public class InitializeStreamDefaults {
     22        private InitializeStreamDefaults() {}
    2323       
    24         public InitStreamDefaultsXFormer(ASTNode ASTree) {
    25                 this.ASTTree = ASTree;
    26         }
    27        
    28         public ASTNode XForm() {
     24        static public ASTNode apply(ASTNode root) {
     25                ASTNode ASTTree = root;
    2926               
    3027                Bitwise2IDISAGeneralXFormer xFormer = new Bitwise2IDISAGeneralXFormer();
     
    3431        }
    3532               
    36         private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
    37                        
     33        static private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
     34                private static final int DEFAULT_FIELD_WIDTH = 1;
     35               
    3836                public void visitLeave(LocalVarDeclNode node) {
    39        
    40                         if(!Accessors.hasInitializationAssign(node)) {
    41                        
    42                                 ASTNode type                            = Accessors.type(node);
    43                                 IdentifierNode identifier       = Accessors.identifier(node);
    44                                
    45                                 if(type instanceof StreamTypeNode) {
    46                                        
    47                                         int fieldWidth = 1;
    48                                        
    49                                         if(Accessors.hasFieldWidth((StreamTypeNode)type)) {
    50                                                 fieldWidth = Integer.parseInt(Accessors.fieldWidthLexeme(Accessors.fieldWidthNode((StreamTypeNode)type)));
    51                                         }
    52                                        
    53                                         IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node.getToken());
    54                                         IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(fieldWidth, node.getToken());
    55                                        
    56                                         FuncCallNode mask = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
    57                                                         node.getToken(),
    58                                                         fieldWidthNode, zeroConstantNode);
    59                                        
    60                                         LocalVarDeclNode localVarDeclNode = Generators.makeLocalVarDeclNode(type, identifier, mask, node.getToken());
    61                                        
    62                                         node.updateSelf(localVarDeclNode);
    63                                        
    64                                 }
     37                        if(Accessors.hasInitializationAssign(node)) {
     38                                return;
     39                        }
     40
     41                        ASTNode type                            = Accessors.type(node);
     42                        IdentifierNode identifier       = Accessors.identifier(node);
     43
     44                        if(type instanceof StreamTypeNode) {
     45                                StreamTypeNode streamType = (StreamTypeNode)type;
     46
     47                                int fieldWidth = fieldWidth(streamType);
     48
     49                                IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node);
     50                                IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(fieldWidth, node);
     51
     52                                FuncCallNode mask = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
     53                                                node.getToken(),
     54                                                arguments(fieldWidthNode, zeroConstantNode));
     55
     56                                // instead of the following, why not node.appendChild(mask)?
     57                                LocalVarDeclNode localVarDeclNode = Generators.makeLocalVarDeclNode(type, identifier, mask, node);
     58                                node.updateSelf(localVarDeclNode);
     59                        }
     60                        else {
     61                                // TS: leave unitialized?
     62                        }
     63                }
     64
     65                private int fieldWidth(StreamTypeNode streamType) {
     66                        if(Accessors.hasFieldWidth(streamType)) {
     67                                FieldWidthNode fieldWidthNode = Accessors.fieldWidthNode(streamType);
     68                                String lexeme = fieldWidthNode.getToken().getLexeme();
     69                                return Integer.parseInt(lexeme);
     70                        }
     71                        else {
     72                                return DEFAULT_FIELD_WIDTH;
    6573                        }
    6674                }
     
    6977                        // TODO - implement
    7078                }
    71                
     79                static private ASTNode[] arguments(ASTNode...astNodes) {
     80                        return astNodes;
     81                }
    7282        }
    7383}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r3117 r3133  
    77package toolchain.pabloS.semanticAnalyzer.visitors;
    88
     9import java.lang.reflect.Constructor;
    910import java.util.LinkedHashMap;
    1011import java.util.List;
     
    3738
    3839       
    39         private CarrySetEncoder carrySet2Lang;
     40        private CarrySetEncoder carrySetEncoder;
    4041       
    4142        /*
     
    4647         */
    4748 
    48     public PabloS2PabloBXFormer(toolchain.pabloB.symbols.SymbolTable pabloSSymbolTable, CarrySetEncoder carrySet2Lang) {
     49    public PabloS2PabloBXFormer(toolchain.pabloB.symbols.SymbolTable pabloSSymbolTable, CarrySetEncoder carrySetEncoder) {
    4950        this.decoratedASTTree = null;
    5051        this.optDecoratedASTTree = null;
    5152        this.pabloSSymbolTable = pabloSSymbolTable;
    5253       
    53         this.carrySet2Lang = carrySet2Lang;
     54        this.carrySetEncoder = carrySetEncoder;
    5455    }
    5556
     
    122123                                                        FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    123124                                                                new String [] {CarrySetEncoder.CARRYSETBASENAME,
    124                                                                                                 carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
     125                                                                                                carrySetEncoder.getCode(CarrySetBuiltins.GETCARRY)},
    125126                                                                                                locationToken,
    126127                                                                                                new ASTNode [] {indexNode});
     
    128129                                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    129130                                                                        new String [] {CarrySetEncoder.CARRYSETBASENAME,
    130                                                                                                         carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
     131                                                                                                        carrySetEncoder.getCode(CarrySetBuiltins.CARRYFLIP)},
    131132                                                                                                        locationToken,
    132133                                                                                                        new ASTNode [] {getCarryFuncCall});
     
    134135                                                        FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    135136                                                                        new String [] {CarrySetEncoder.CARRYSETBASENAME,
    136                                                                                                         carrySet2Lang.getCode(CarrySetBuiltins.SETCARRY)},
     137                                                                                                        carrySetEncoder.getCode(CarrySetBuiltins.SETCARRY)},
    137138                                                                                                        locationToken,
    138139                                                                                                        new ASTNode [] {carryFlipFuncCall, indexNode});
     
    166167     */
    167168        private class pabloBASTBuilder extends Default<pabloB.ast.ASTNode> {
    168                        
     169                // first crack at reflection version.
     170                @Override
     171                public pabloB.ast.ASTNode defaultVisitLeave(pabloS.ast.ASTNode node, List<pabloB.ast.ASTNode> childResults) {
     172                        Class<?> nodeClass = node.getClass();
     173                        String nodeName = nodeClass.getSimpleName();
     174                        String pabloBNodeName = "pabloB.ast." + nodeName;
     175                       
     176                        pabloB.tokens.Token pabloBToken = Generators.makePabloBToken(node.getToken());
     177                        try {
     178                                Class<?> pabloBNodeClass = Class.forName(pabloBNodeName);
     179                                Constructor<?> constructor = pabloBNodeClass.getConstructor(pabloB.tokens.Token.class);
     180                                pabloB.ast.ASTNode pabloBNode = (pabloB.ast.ASTNode) constructor.newInstance(pabloBToken);
     181                                appendChildResults(pabloBNode, childResults);
     182                                return pabloBNode;
     183                        } catch (Exception e) {
     184                                e.printStackTrace();
     185                        }
     186                        return null;
     187                }
     188               
    169189                public pabloB.ast.ASTNode visitLeave(pabloS.ast.AssignNode node, List<pabloB.ast.ASTNode> childResults) {
    170190                        pabloB.ast.ASTNode bNode = new pabloB.ast.AssignNode(Generators.makePabloBToken(node.getToken()));
     
    345365                }
    346366                */
     367
    347368               
    348369                public pabloB.ast.ASTNode visitLeave(pabloS.ast.FuncCallOrAssignStmtNode node, List<pabloB.ast.ASTNode> childResults) {
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/StreamFuncVisitor.java

    r3010 r3133  
    5454                               
    5555                public void visitLeave(FuncDefNode node) {
    56                                                        
     56                        // TS: Accessors.funcName() and Accessors.funcIdentifier reference the same node.  Hmmmm.
    5757                        String name = Accessors.funcName(node);
    5858                        name = Generators.capitalize(name);
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/AdvanceNCount.java

    r3116 r3133  
    1010import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    1111
    12 public class AdvanceNCounterVisitor {
    13         private ASTNode ASTree;
     12public class AdvanceNCount {
     13    public static int forTree(ASTNode tree) {
     14        AdvNCounterVisitor visitor = new AdvNCounterVisitor();
     15        tree.accept(visitor);
     16        return visitor.advNCount();
     17    }   
    1418       
    15         public AdvanceNCounterVisitor(ASTNode ASTree) {
    16                 this.ASTree = ASTree;
    17         }
    18        
    19         public int count() {
    20             AdvNCounterVisitor visitor = new AdvNCounterVisitor();
    21                 ASTree.accept(visitor);
    22                 return ((AdvNCounterVisitor)visitor).advNCount();
    23         }
    24        
    25         private class AdvNCounterVisitor extends VoidVisitor.Default {
     19        static private class AdvNCounterVisitor extends VoidVisitor.Default {
    2620                private int advNCount = 0;
    2721               
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/BuiltinTranslator.java

    r3117 r3133  
    9797                ASTNode argument = Accessors.funcCallArg(node, 1);
    9898               
    99                 if(context.getFinalBlockMode()) {
     99                if(context.isFinalBlockMode()) {
    100100                        ASTNode replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument, context.getBuiltinEncoder());
    101101                        argument.updateSelf(replacementNode);
     
    126126        }               
    127127        public void atEOFAction(FuncCallNode node, Counter counter, Context context) {
    128                 if(context.getFinalBlockMode()) {
     128                if(context.isFinalBlockMode()) {
    129129                        ASTNode argNode = Accessors.funcCallArg(node, 0);
    130130                        ASTNode replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
     
    136136        }       
    137137        public void infileAction(FuncCallNode node, Counter counter, Context context) {
    138                 if(context.getFinalBlockMode()) {                                       
     138                if(context.isFinalBlockMode()) {                                       
    139139                        ASTNode argNode = Accessors.funcCallArg(node, 0);
    140140                        ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, context.getBuiltinEncoder());
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/Carry1Count.java

    r3116 r3133  
    1010import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    1111
    12 public class CarryCounterVisitor {
     12public class Carry1Count {
     13        private Carry1Count(){}
    1314       
    14     private ASTNode ASTree;
    15    
    16     public CarryCounterVisitor(ASTNode ASTree) {
    17         this.ASTree = ASTree;
    18     }
    19    
    20     public int carry1Count() {
     15    public static int forTree(ASTNode tree) {
    2116        Carry1Counter visitor = new Carry1Counter();
    22         this.ASTree.accept(visitor);
    23         return ((Carry1Counter)visitor).count();
    24     }   
    25 
    26     public int carryNCount() {
    27         CarryNCounter visitor = new CarryNCounter();
    28         this.ASTree.accept(visitor);
    29         return ((CarryNCounter)visitor).count();
     17        tree.accept(visitor);
     18        return visitor.count();
    3019    }   
    3120       
    32         private class Carry1Counter extends VoidVisitor.Default {
    33                 private int carry1Count         = 0;
     21    private static class Carry1Counter extends VoidVisitor.Default {
     22                private int carry1Count = 0;
    3423
    3524                public int count() {
     
    4332                }
    4433        }
    45 
    46         private class CarryNCounter extends VoidVisitor.Default {
    47                 private int carryNCount         = 0;
    48 
    49                 public int count() {
    50                         return carryNCount;
    51                 }
    52                                
    53                 public void visitLeave(FuncCallNode node) {
    54                         if(PabloSBuiltinsUtil.isCarryN(node)) {
    55                             carryNCount += 1;
    56                         }                       
    57                 }
    58                
    59         }
    60        
    6134}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryIntroXFormer.java

    r3117 r3133  
    44import pabloS.ast.*;
    55import pabloS.tokens.LextantToken;
     6import pabloS.inputHandler.Locator;
    67import pabloS.lexicalAnalyzer.Lextant;
    78import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
     
    6162 */
    6263
    63 public class CarryIntroXFormer {       
    64         private ASTNode ASTTree;       
    65         private BuiltinEncoder builtinEncoder;
    66         private CarrySetEncoder carrySetEncoder;
    67 
    68     public CarryIntroXFormer(ASTNode node, BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder) {
    69         this.ASTTree = node;
    70         this.builtinEncoder  = builtinEncoder;
    71         this.carrySetEncoder = carrySetEncoder;
    72     }   
    73 
    74     public void XForm(boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
    75         Context context = new Context(ciMode, finalBlockMode, builtinEncoder, carrySetEncoder, carrySetDepth); 
    76         XFormer visitor = new XFormer(context);
    77                 ASTTree.accept(visitor);
    78     }                   
    79     public void XForm(boolean finalBlockMode) {
    80         XForm(finalBlockMode, true, 0);
     64public class CarryIntroXFormer {           
     65    public static ASTNode apply(ASTNode root, Context context) {
     66        Transformer transformer = new Transformer(context);
     67        root.accept(transformer);
     68        return root;
     69    }
     70    public static ASTNode apply(ASTNode root, BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder,
     71                                boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
     72        Context context = new Context(ciMode, finalBlockMode, builtinEncoder, carrySetEncoder, carrySetDepth);
     73        return apply(root, context);
     74    }
     75    public static ASTNode apply(ASTNode root, BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder, boolean finalBlockMode) {
     76        return apply(root, builtinEncoder, carrySetEncoder, finalBlockMode, true, 0);
    8177    }
    8278   
    8379   
    84     private class XFormer extends VoidVisitor.Default {
     80    static private class Transformer extends VoidVisitor.Default {
    8581        private Context context;
    86         private Counter carryCount    = new Counter(CarrySetBuiltins.GETCARRY);
    87         private Counter advanceNCount = new Counter(CarrySetBuiltins.PENDING64);
     82        private Counter carryCounter    = new Counter(CarrySetBuiltins.GETCARRY);
     83        private Counter advanceNCounter = new Counter(CarrySetBuiltins.PENDING64);
    8884       
    89                 XFormer(Context context) {
     85                Transformer(Context context) {
    9086                        this.context = context;
    9187                       
    92                         carryCount.reset();
    93                         advanceNCount.reset();                                 
    94                 }
    95                
    96 
    97                 // xFormers
    98                
    99                 //              def xfrm_fndef(self, fndef):
    100                 //          self.current_carry = 0
    101                 //          self.current_adv_n = 0
    102                 //          carry_count = CarryCounter().count(fndef)
    103                 //          if carry_count == 0: return fndef
    104                 //          self.generic_visit(fndef)
    105                 //      #   
    106                 //      #    fndef.body.insert(0, mkCallStmt('CarryDeclare', [self.carryvar, ast.Num(carry_count)]))
    107                 //          return fndef
     88                        carryCounter.reset();
     89                        advanceNCounter.reset();                               
     90                }
     91               
     92               
     93                ///////////////////////////////////////////////////////////////////
     94                // FuncDefNode
    10895               
    10996                public void visitEnter(FuncDefNode node) {
    110                         carryCount.reset();
    111                         advanceNCount.reset();
    112                         //this.lastStmtCarries = 0;
    113                        
    114                        
    115                         CarryCounterVisitor carryCounter = new CarryCounterVisitor(node);
    116                         int carry1Count = carryCounter.carry1Count();
    117                         int carryNCount = carryCounter.carryNCount();
    118                        
    119                         if(carry1Count > 0) { 
    120                                 IntegerConstantNode carry1CountNode =  Generators.makeIntegerConstantNode(carry1Count, node.getToken());
    121                                
    122                                 FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    123                                                                                 carrySetFunction(CarrySetBuiltins.CARRYADJUST),
    124                                                                                 node,
    125                                                                                 carry1CountNode);
    126                                
    127                                 BlockStmtNode blockStmtNode = Accessors.blockStmtNode(node);
    128                                 if(!context.getFinalBlockMode()) {
    129                                         blockStmtNode.appendChild(carryAdjustFuncCall);
    130                                 }       
     97                        carryCounter.reset();
     98                        advanceNCounter.reset();
     99                       
     100                        int carry1Count = Carry1Count.forTree(node);
     101                        int carryNCount = CarryNCount.forTree(node);
     102                       
     103                        if(needsCarryAdjustment(carry1Count) ) { 
     104                                addCarryAdjustment(node, carry1Count);
    131105                        }                       
    132106                       
    133                         IdentifierNode carrySetIdentifierNode   =       Generators.makeIdentifierNode(context.getCarrySetIdentifier(), node.getToken());
    134                         IntegerConstantNode carry1CountNode     =       Generators.makeIntegerConstantNode(carry1Count, node.getToken());
    135                         IntegerConstantNode carryNCountNode     =       Generators.makeIntegerConstantNode(carryNCount, node.getToken());
    136                        
    137                         FuncCallNode carryDeclareFuncCall
    138                                                                 = (FuncCallNode) Generators.makeFuncCallNode(
    139                                                                         carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE),
    140                                                                         node,
    141                                                                         new ASTNode [] {carrySetIdentifierNode, carry1CountNode, carryNCountNode});
    142                        
    143                         node.appendChild(carryDeclareFuncCall);
    144                
    145                 }
    146 
    147 
    148                
     107                        FuncCallNode carryDeclareCall = makeCarryDeclareCall(node, carry1Count, carryNCount);
     108                        node.appendChild(carryDeclareCall);     
     109                        // TS: seems an odd place to put carryDeclareCall.
     110                        // Why not append to ParameterList or body?
     111                }
    149112                public void visitLeave(FuncDefNode node) {
    150                         if(context.getFinalBlockMode()) {
    151                                 ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(builtinEncoder, node.getToken());
     113                        if(context.isFinalBlockMode()) {
     114                                ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(context.getBuiltinEncoder(), node);
    152115                                Generators.appendParameter(node, EOFMaskParameter);
    153116                        }
    154117                }               
    155                
    156                 //public void visitLeave(FuncCallNode node) {
    157                 //      if(BuiltinsUtil.isCarryOne(node)) {
    158                 //              carryCount.increment();
    159                 //      }                                       
    160                 //}
     118
     119                private boolean needsCarryAdjustment(int carry1Count) {
     120                        return carry1Count > 0  && !context.isFinalBlockMode();
     121                }
     122                private void addCarryAdjustment(FuncDefNode node, int carry1Count) {
     123                        FuncCallNode carryAdjustment = makeCarryAdjustmentCall(node, carry1Count);
     124                       
     125                        ASTNode body = Accessors.body(node);
     126                        body.appendChild(carryAdjustment);
     127                }
     128                private FuncCallNode makeCarryAdjustmentCall(Locator location, int carry1Count) {
     129                        IntegerConstantNode carry1CountNode =  leaf(carry1Count, location);
     130                       
     131                        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
     132                                                                        carrySetFunction(CarrySetBuiltins.CARRYADJUST),
     133                                                                        location,
     134                                                                        arguments(carry1CountNode));
     135                        return carryAdjustment;
     136                }
     137                private FuncCallNode makeCarryDeclareCall(FuncDefNode node, int carry1Count, int carryNCount) {
     138                        IdentifierNode carrySetIdentifierNode   =       context.carrySetIdentifierNode(node);
     139                        IntegerConstantNode carry1CountNode     =       Generators.makeIntegerConstantNode(carry1Count, node);
     140                        IntegerConstantNode carryNCountNode     =       Generators.makeIntegerConstantNode(carryNCount, node);
     141                       
     142                        return Generators.makeFuncCallNode(
     143                                        context.getCode(CarrySetBuiltins.CARRYDECLARE),
     144                                        node,
     145                                        arguments(carrySetIdentifierNode, carry1CountNode, carryNCountNode));
     146                }
     147
     148
     149               
     150                ///////////////////////////////////////////////////////////////////
     151                // FuncCallNode
    161152               
    162153                public void visitLeave(FuncCallNode node) {
     
    164155                        for(BuiltinTranslator translator: BuiltinTranslator.values()) {
    165156                                if (translator.isCall(node)) {
    166                                         translator.action(node, carryCount, advanceNCount, context);
     157                                        translator.action(node, carryCounter, advanceNCounter, context);
    167158                                        translated = true;
    168159                                        break;
     
    174165                        }                                                                                                                       
    175166                }
    176                
    177                 //              if self.carryin == "_ci":
    178                 //              carry_args = [mkCall(self.carryvar.id + "." + 'get_carry_in', [ast.Num(self.current_carry)]), ast.Num(self.current_carry)]
    179                 //              adv_n_args = [mkCall(self.carryvar.id + "." + 'get_pending64', [ast.Num(self.current_adv_n)]), ast.Num(self.current_adv_n)]
    180                 //          else:
    181                 //              carry_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_carry)]
    182                 //              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    183                
    184                
    185                
    186                 //      def visit_If(self, ifNode):
    187                 //      carry_base = self.current_carry
    188                 //      carries = CarryCounter().count(ifNode)
    189                 //      assert adv_nCounter().count(ifNode) == 0, "Advance(x,n) within if: illegal\n"
    190                 //      self.generic_visit(ifNode)
    191                 //      if carries == 0 or self.carryin == "": return ifNode
    192                 //      #CARRYSET
    193                 //      carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
    194                 //      new_test = ast.BoolOp(ast.Or(), [ifNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
    195                 //      new_else_part = ifNode.orelse + [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]
    196                 //      return ast.If(new_test, ifNode.body, new_else_part)
    197                
    198                 public void visitEnter(IfStmtNode node) { // current PabloS if statement implementation does not support n-bit CarryTest for Advance(x,n)
    199                         assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) illegal within an if statement \n";
    200                        
    201                         int carryBase = carryCount.value();
    202                         int carryCount = (new CarryCounterVisitor(node)).carry1Count();
     167
     168
     169               
     170                ///////////////////////////////////////////////////////////////////
     171                // IfStmtNode
     172               
     173                // current PabloS if statement implementation does not support n-bit CarryTest for Advance(x,n)
     174                public void visitEnter(IfStmtNode node) {
     175                        assert (AdvanceNCount.forTree(node) == 0): "Advance(x,n) illegal within an if statement \n";    // should be better diagnostic
     176                       
     177                        int carryBase   = carryCounter.value();
     178                        int carry1Count = Carry1Count.forTree(node);
    203179                                               
    204                         if(carryCount == 0) {
    205                                 return;
    206                         }
    207                        
    208                         if(!this.context.getCarryInMode()) { // not in the context of the 1st iteration of a while loop
    209                                 return;
    210                         }
    211 
    212                         IntegerConstantNode carryBaseNode = Generators.makeIntegerConstantNode(carryBase, node.getToken());
    213                         IntegerConstantNode carryCountNode = Generators.makeIntegerConstantNode(carryCount, node.getToken());
    214                        
    215                         BinaryOperatorNode replacementIfTestNode = makeBitwiseOrCarryTest(Accessors.ifTest(node), carryBaseNode, carryCountNode);
    216                        
    217                         node.replaceChild(Accessors.ifTest(node), replacementIfTestNode);
    218                        
    219                         // else part, append CarryDequeueEnqueue call
     180                        if(ifNeedsCarryProcessing(carry1Count)) {
     181                                orCarryrangeIntoCondition(node, carryBase, carry1Count);
     182                                appendCarryDequeueEnqueueToElseClause(node, carryBase, carry1Count);
     183                        }
     184                }
     185                private boolean ifNeedsCarryProcessing(int carry1Count) {
     186                        return carry1Count > 0  &&  context.isCarryInMode();
     187                }
     188                private void orCarryrangeIntoCondition(IfStmtNode node, int carryBase, int carry1Count) {
     189                        ASTNode condition = Accessors.condition(node);
     190                        ASTNode replacementCondition = makeBitwiseOrCarryTest(condition.deepCopy(), carryBase, carry1Count);
     191                       
     192                        node.replaceChild(condition, replacementCondition);
     193                }
     194                private void appendCarryDequeueEnqueueToElseClause(IfStmtNode node, int carryBase, int carry1Count) {
     195                        Locator location = (Locator)node;
     196                        ASTNode carryDequeueEnqueue = makeCarryDequeueEnqueue(location, carryBase, carry1Count);
     197
     198                        ensureHasElseClause(node);     
     199                        Accessors.elseClause(node).appendChild(carryDequeueEnqueue);
     200                }
     201                private FuncCallNode makeCarryDequeueEnqueue(Locator location,
     202                                int carryBase, int carry1Count) {
     203                        IntegerConstantNode carryBaseNode = leaf(carryBase, location);
     204                        IntegerConstantNode carryCountNode = leaf(carry1Count, location);
     205                       
    220206                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    221207                                                                carrySetFunction(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    222                                                                 node.getToken(),
    223                                                                 carryBaseNode, carryCountNode);
    224                        
    225                         if (Accessors.hasElseBlockStmt(node)) {
    226                                 Accessors.elseBlockStmt(node).appendChild(carryDequeueEnqueue);
    227                         } else {
    228                                 BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(node.getToken());
    229                                 blockStmtNode.appendChild(carryDequeueEnqueue);
     208                                                                location,
     209                                                                arguments(carryBaseNode, carryCountNode));
     210                        return carryDequeueEnqueue;
     211                }
     212                private void ensureHasElseClause(IfStmtNode node) {
     213                        if (!Accessors.hasElseClause(node)) {   
     214                                BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(node);
    230215                                node.appendChild(blockStmtNode);
    231                         }                               
    232                 }
    233                                
     216                        }
     217                }
     218
     219               
     220                //   while(condition) body  =>
     221                //
     222                //       error                                                  if any carryN's in the while.
     223                //       while(condition') body                 if no carry1's in the while.
     224                //       general-replacement                    otherwise
     225                //
     226                //   where
     227                //              condition' = condition (and EOFMask if finalBlock)
     228                //              general-replacement is defined below.
     229               
    234230                public void visitEnter(WhileStmtNode node) {
    235 
    236                         //          if self.carryout == '':
    237                         //            whileNode.test.args[0] = mkCall("simd_and", [whileNode.test.args[0], ast.Name('EOF_mask', ast.Load())])
    238                         //          carry_base = self.current_carry
    239                         //          assert adv_nCounter().count(whileNode) == 0, "Advance(x,n) within while: illegal\n"
    240                         //          carries = CarryCounter().count(whileNode)
    241                         //          #CARRYSET
    242                         //          if carries == 0: return whileNode
    243                         //          carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
    244                         //          local_carryvar = 'sub' + self.carryvar.id
    245                        
    246                         if(context.getFinalBlockMode()) {
    247                                 ASTNode whileConditionNode = Accessors.whileTest(node);
    248                                 ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(whileConditionNode, builtinEncoder);
    249                                 node.replaceChild(whileConditionNode, replacementNode);                                 
    250                         }
    251                        
    252                         int carryBase           = carryCount.value();
    253                         int carry1Count         = (new CarryCounterVisitor(node)).carry1Count();                       
    254                         int carryNCount         = (new CarryCounterVisitor(node)).carryNCount();
    255                        
     231                        if(context.isFinalBlockMode()) {
     232                                andConditionWithEOFMask(node);                                 
     233                        }
     234                       
     235                        int carry1Count         = Carry1Count.forTree(node);           
     236                        int carryNCount         = CarryNCount.forTree(node);
     237
     238                        // TS: switched order of following two, to catch more errors.
     239                        assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";
    256240                        if(carry1Count == 0) {
    257241                                return;
    258242                        }
    259243                       
    260                         assert (carryNCount == 0): "Advance(x,n) illegal within an if statement \n";
    261 
    262                         IdentifierNode carrySetIdentifierNode = Generators.makeIdentifierNode(context.getCarrySetIdentifier(), node.getToken());
    263                        
    264                         IntegerConstantNode carryBaseNode       =       Generators.makeIntegerConstantNode(carryBase, node.getToken());
    265                         IntegerConstantNode carry1CountNode =   Generators.makeIntegerConstantNode(carry1Count, node.getToken());
    266                         IntegerConstantNode carryNCountNode =   Generators.makeIntegerConstantNode(carryNCount, node.getToken());
    267                        
    268                        
    269                                        
    270                         //          inner_while = CarryIntro(local_carryvar, '', self.carryout).generic_xfrm(copy.deepcopy(whileNode))
    271                         //          self.generic_visit(whileNode)
    272                         //          local_carry_decl = mkCallStmt('LocalCarryDeclare', [ast.Name(local_carryvar, ast.Load()), ast.Num(carries)])
    273                         //          inner_while.body.insert(0, local_carry_decl)
    274                         //          final_combine =
    275                         //                      mkCallStmt      (ast.Attribute(self.carryvar, 'CarryCombine', ast.Load()),
    276                         //                                                      [ast.Attribute(ast.Name(local_carryvar, ast.Load()),
    277 ////////////                    //                                                              'cq', ast.Load()),
    278                         //                                                              ast.Num(carry_base),
    279                         //                                                              ast.Num(carries)
    280                         //                                                      ]
    281                         //                                              )
    282                         //          inner_while.body.append(final_combine)                     
    283 
    284                         //              translate inner while ciMode disabled and local carry object
    285                        
    286                         WhileStmtNode innerWhile = node.deepCopy();
    287                         CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtinEncoder, carrySetEncoder);
    288                         xFormer.XForm(context.getFinalBlockMode(), false, (context.getCarrySetDepth() + 1));   
    289                        
    290                         IdentifierNode localCarrySetIdentifierNode = Generators.makeIdentifierNode(
    291 //next arg was:         xFormer.context.getCarrySetIdentifier(),
    292                                         context.getCarrySetIdentifier(context.getCarrySetDepth()+1),
    293                                         node);
    294 
    295                                 /*
    296                         CompoundIdentifierNode localCarrySetArrayIdentifierNode = Generators.makeCompoundIdentifierNode(
    297                                         new String [] {xFormer.context.getCarrySetIdentifier(), CarrySetBuiltins2Lang.CARRYQARRAYNAME},
    298                                         node.getToken());
    299                         */
    300                        
    301                         FuncCallNode carryDeclareFuncCall
    302                                                                 = (FuncCallNode) Generators.makeFuncCallNode(
    303                                                                         carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE),
    304                                                                         node.getToken(),
    305                                                                         localCarrySetIdentifierNode, carry1CountNode, carryNCountNode);
    306                                                
    307                         Accessors.whileBlockStmt(innerWhile).insertChild(carryDeclareFuncCall);
    308 
    309                         FuncCallNode carryLocalCombine = (FuncCallNode) Generators.makeFuncCallNode(
    310                                         carrySetEncoder.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE),
    311                                         node.getToken(),
    312                                         carrySetIdentifierNode, localCarrySetIdentifierNode, carryBaseNode, carry1CountNode);
    313                        
    314                         Accessors.whileBlockStmt(innerWhile).appendChild(carryLocalCombine);
    315                        
    316                         //
    317                         //          #CARRYSET
    318                         //          if self.carryin == '': new_test = whileNode.test
    319                         //          else: new_test = ast.BoolOp(ast.Or(), [whileNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
    320                         //          else_part = [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]   
    321                         //          return ast.If(new_test, whileNode.body + [inner_while], else_part)
    322                        
    323                         // if condition
    324                         ASTNode ifTest = Accessors.whileTest(node).deepCopy();
    325                        
    326                         if(!context.getCarryInMode()) {
    327                                 ifTest = Accessors.whileTest(node).deepCopy();
    328                         } else {                               
    329                                 ifTest = makeBitwiseOrCarryTest(ifTest, carryBaseNode, carry1CountNode);
    330                         }
    331                        
    332                         // if body
    333                         BlockStmtNode ifBlockStmtNode = Generators.makeBlockStmtNode(node.getToken());
    334                         ifBlockStmtNode.appendChild(Accessors.whileBlockStmt(node));
    335                         ifBlockStmtNode.appendChild(innerWhile);
     244                        ASTNode replacement = makeGeneralWhileReplacement(node, carry1Count);
     245                       
     246                        node.updateSelf(replacement);   
     247                }
     248                private void andConditionWithEOFMask(WhileStmtNode node) {
     249                        ASTNode condition = Accessors.condition(node);
     250                        ASTNode replacement = Generators.makeSIMDAndEOFMaskFuncCall(condition.deepCopy(), context.getBuiltinEncoder());
     251                        node.replaceChild(condition, replacement);
     252                }
     253               
     254                // general-replacement:
     255                //
     256                //
     257                //   while(condition) body  =>
     258                //
     259                //   if(condition'') {
     260                //              body
     261                //              while(condition') {
     262                //                      carryDeclare(localCarrySetID, carry1Count, carryNCount)
     263                //              phi(body)                       
     264                //                      carryCombine(carrySetID, localCarrySetID, carryBase, carry1Count)
     265                //              }
     266                //   }
     267                //   else {
     268                //              carryDequeEnque(carryBase, carry1Count)
     269                //   }
     270                //
     271                //   condition' = condition (AND EOFMask if in finalBlock mode)
     272                //   condition'' = condition' (OR carry if in carryIn mode)
     273                //   phi is recursive transform with depth+1 and carryIn=false, using localCarrySet
     274               
     275                private IfStmtNode makeGeneralWhileReplacement(WhileStmtNode node, int carry1Count) {
     276                        Locator locator = (Locator)node;
     277
     278                        int carryBase           = carryCounter.value();
     279                       
     280                        ASTNode      ifCondition = outerIfCondition(node, carryBase, carry1Count);
     281                        BlockStmtNode thenClause = outerIfThenClause(node, carryBase, carry1Count);
     282                        BlockStmtNode elseClause = outerIfElseClause(locator, carryBase, carry1Count);
     283                       
     284                        return Generators.makeIfStmtNode(locator,
     285                                                                                         ifCondition,
     286                                                                                         thenClause,
     287                                                                                         elseClause);
     288                }
     289                private ASTNode outerIfCondition(WhileStmtNode node, int carryBase, int carry1Count) {
     290                        ASTNode result = Accessors.condition(node).deepCopy();
     291                       
     292                        if(context.isCarryInMode()) {
     293                                result = makeBitwiseOrCarryTest(result, carryBase, carry1Count);
     294                        }
     295                        return result;
     296                }
     297                private BlockStmtNode outerIfThenClause(WhileStmtNode node, int carryBase, int carry1Count) {
     298                        Locator locator = (Locator)node;
     299                        WhileStmtNode innerWhile = makeInnerWhile(node, carryBase, carry1Count);
     300                       
     301                        return Generators.makeBlockStmtNode(locator,
     302                                                                                        Accessors.body(node),
     303                                                                                        innerWhile);
     304                }
     305                private BlockStmtNode outerIfElseClause(Locator locator, int carryBase, int carry1Count) {
     306                        IntegerConstantNode carryBaseNode       =       Generators.makeIntegerConstantNode(carryBase, locator);
     307                        IntegerConstantNode carry1CountNode =   Generators.makeIntegerConstantNode(carry1Count, locator);
    336308                       
    337309                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    338310                                                                        carrySetFunction(CarrySetBuiltins.CARRYDEQUEUEENQUEUE),
    339                                                                         node.getToken(),
    340                                                                         carryBaseNode, carry1CountNode);
    341                        
    342                         // else body                   
    343                         BlockStmtNode elseBlockStmtNode = Generators.makeBlockStmtNode(node.getToken());
    344                         elseBlockStmtNode.appendChild(carryDequeueEnqueue);
    345                        
    346                         IfStmtNode ifStmtNode = Generators.makeIfStmtNode(node.getToken(),
    347                                                                                                                                 ifTest,
    348                                                                                                                                 ifBlockStmtNode,
    349                                                                                                                                 elseBlockStmtNode);
    350                         node.updateSelf(ifStmtNode);
    351                        
    352                        
    353                 }
    354                
    355                 // Helpers
    356                
     311                                                                        locator,
     312                                                                        arguments(carryBaseNode, carry1CountNode));
     313                       
     314                                               
     315                        return Generators.makeBlockStmtNode(locator, carryDequeueEnqueue);
     316                }
     317               
     318                // innerwhile =>
     319                //
     320                // while(condition') {
     321                //         carryDeclare(localCarrySetID, carry1Count, carryNCount)
     322                //     phi(body)                       
     323                //         carryCombine(carrySetID, localCarrySetID, carryBase, carry1Count)
     324                // }
     325                //
     326                //     phi is recursive transform with depth+1 and carryIn=false
     327                private WhileStmtNode makeInnerWhile(WhileStmtNode node,
     328                                int carryBase,
     329                                int carry1Count) {
     330                       
     331                        int carryNCount = 0;                                            // by assert in visitEnter(WhileStmtNode)
     332                        Locator location = (Locator)node;
     333                        WhileStmtNode innerWhile = node.deepCopy();
     334                       
     335                        Context localContext = context.incrementDepth().clearCarryIn();
     336                        ASTNode newBody = transformBody(innerWhile, localContext);
     337                       
     338                        insertCarryDeclare(newBody, carry1Count, carryNCount, localContext, location);
     339                        appendCarryCombine(newBody, carryBase, carry1Count, localContext, location);
     340                       
     341                        return innerWhile;
     342                }
     343
     344                private ASTNode transformBody(WhileStmtNode innerWhile, Context localContext) {
     345                        ASTNode body = Accessors.body(innerWhile);
     346                        ASTNode newBody = CarryIntroXFormer.apply(body, localContext);
     347                        innerWhile.replaceChild(body, newBody);
     348                        return newBody;
     349                }
     350                private void insertCarryDeclare(ASTNode body, int carry1Count,
     351                                int carryNCount, Context localContext, Locator location) {
     352                       
     353                        FuncCallNode carryDeclare = makeCarryDeclare(carry1Count, carryNCount, localContext, location);
     354                        body.insertChild(carryDeclare);
     355                }
     356                private void appendCarryCombine(ASTNode body, int carryBase,
     357                                int carry1Count, Context localContext, Locator location) {
     358                       
     359                        FuncCallNode localCarryCombine = makeLocalCarryCombine(carryBase, carry1Count, localContext, location);
     360                        body.appendChild(localCarryCombine);
     361                }
     362                private FuncCallNode makeCarryDeclare(int carry1Count, int carryNCount,
     363                                Context localContext, Locator location) {
     364                       
     365                        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(location);
     366                       
     367                        FuncCallNode carryDeclare = Generators.makeFuncCallNode(
     368                                                                context.getCode(CarrySetBuiltins.CARRYDECLARE),
     369                                                                location,
     370                                                                localCarrySetIdentifierNode, leaf(carry1Count, location), leaf(carryNCount, location));
     371                        return carryDeclare;
     372                }
     373                private FuncCallNode makeLocalCarryCombine(int carryBase, int carry1Count,
     374                                Context localContext, Locator locator) {
     375
     376                        IdentifierNode localCarrySetIdentifierNode = localContext.carrySetIdentifierNode(locator);
     377                        ASTNode carryBaseNode = leaf(carryBase, locator);
     378                        ASTNode carry1CountNode = leaf(carry1Count, locator);
     379                       
     380                        return Generators.makeFuncCallNode(
     381                                                context.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE),
     382                                                locator,
     383                                                arguments(context.carrySetIdentifierNode(locator),
     384                                                                  localCarrySetIdentifierNode,
     385                                                                  carryBaseNode,
     386                                                                  carry1CountNode));
     387
     388                }
    357389
    358390               
    359391                /*
    360                  * Makes Bitwise OR of if expression and CARRYRANGE.
     392                 * Makes Bitwise OR of condition and CARRYRANGE(carryBase, carryCount).
    361393                 */
    362                 private BinaryOperatorNode makeBitwiseOrCarryTest(ASTNode ifTest,
    363                                 IntegerConstantNode carryBaseNode,
    364                                 IntegerConstantNode carryCountNode) {
    365        
    366                         ASTNode lhs = ifTest;
    367                                
    368                         String lexeme = Lextant.OR.getPrimaryLexeme();
    369                         LextantToken binaryOperatorToken = LextantToken.make(lhs.getToken().getLocation(), lexeme, Lextant.OR);
    370                        
    371                         FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
     394                private BinaryOperatorNode makeBitwiseOrCarryTest(ASTNode condition,
     395                                int carryBase,
     396                                int carryCount) {
     397                        Locator location = (Locator)condition;
     398                       
     399                        ASTNode carryBaseNode  = leaf(carryBase, location);
     400                        ASTNode carryCountNode = leaf(carryCount, location);
     401                        ASTNode carryRange = Generators.makeFuncCallNode(
    372402                                                                        carrySetFunction(CarrySetBuiltins.CARRYRANGE),
    373                                                                         lhs,
    374                                                                         carryBaseNode, carryCountNode);
    375                        
    376                         BinaryOperatorNode replacementIfTestNode = Generators.makeBinaryOperatorNode(lhs, rhs, binaryOperatorToken);
    377                        
    378                         return replacementIfTestNode;
    379                 }
     403                                                                        location,
     404                                                                        arguments(carryBaseNode, carryCountNode));
     405
     406                        LextantToken or = Generators.makeLextantToken(Lextant.OR, condition);
     407                        return Generators.makeBinaryOperatorNode(condition, carryRange, or);
     408                }
     409               
     410               
     411               
     412                ///////////////////////////////////////////////////////////////////
     413                // Utilities
    380414
    381415                // gives the proper array of strings for a carrySetBuiltin call.
     
    386420                        };
    387421                }               
     422                private ASTNode[] arguments(ASTNode...astNodes) {
     423                        return astNodes;
     424                }
     425                public IntegerConstantNode leaf(int n, Locator locator) {
     426                        return Generators.makeIntegerConstantNode(n, locator);
     427                }               
    388428        }
    389429}       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/Context.java

    r3117 r3133  
    11package toolchain.pabloS.semanticAnalyzer.visitors.carry;
    22
     3import pabloS.ast.IdentifierNode;
     4import pabloS.inputHandler.Locator;
     5import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    36import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
     7import toolchain.pabloS.ast.Generators;
    48import toolchain.pabloS.lang.BuiltinEncoder;
     9import toolchain.pabloS.lang.PabloSBuiltins;
    510
    611// immutable
     
    2328        }
    2429       
    25         public final boolean getCarryInMode() {
     30        //getters - field retrieval
     31        public final boolean isCarryInMode() {
    2632                return carryInMode;
    2733        }
    28         public final boolean getFinalBlockMode() {
     34        public final boolean isFinalBlockMode() {
    2935                return finalBlockMode;
    3036        }
     
    3844                return carrySetDepth;
    3945        }
     46       
     47        // getters - directly computed from fields
    4048        public final String getCarrySetIdentifier() {
    41                 return getCarrySetIdentifier(carrySetDepth);
     49                return CarrySetEncoder.CARRYSET_BASENAME_PREFIX + carrySetDepth;
    4250        }
    43         public final String getCarrySetIdentifier(int depth) {
    44                 return CarrySetEncoder.CARRYSET_BASENAME_PREFIX + depth;
     51       
     52        // compound operations
     53        public final IdentifierNode carrySetIdentifierNode(Locator location) {
     54                return Generators.makeIdentifierNode(getCarrySetIdentifier(), location);
     55        }
     56        public final String getCode(CarrySetBuiltins carrySetBuiltin) {
     57                return getCarrySetEncoder().getCode(carrySetBuiltin);
     58        }
     59        public final String getCode(PabloSBuiltins builtin) {
     60                return getBuiltinEncoder().getCode(builtin);
     61        }
     62       
     63        // create new Contexts
     64        public final Context incrementDepth() {
     65                return new Context(carryInMode, finalBlockMode,
     66                                builtinEncoder, carrySetEncoder,
     67                                carrySetDepth + 1);
     68        }
     69        public final Context clearCarryIn() {
     70                return new Context(false, finalBlockMode,
     71                                builtinEncoder, carrySetEncoder,
     72                                carrySetDepth);
    4573        }
    4674}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/Counter.java

    r3115 r3133  
    2929        }
    3030        public ASTNode callOrMask(Locator locator, Context context) {
    31                 if(context.getCarryInMode()) {
     31                if(context.isCarryInMode()) {
    3232                        return Generators.makeFuncCallNode(
    3333                                        new String [] {context.getCarrySetIdentifier(), context.getCarrySetEncoder().getCode(builtin)},
Note: See TracChangeset for help on using the changeset viewer.