Changeset 3115


Ignore:
Timestamp:
May 6, 2013, 1:14:37 PM (6 years ago)
Author:
shermer
Message:

several changes centered on pabloS semanticAnalyzer package.
Unknown if project still works.
Suspect the test harness is broken by these changes.

Location:
proto/pabloj/branches/refactor-experimental
Files:
451 added
11 deleted
23 edited
11 copied

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/.classpath

    r2950 r3115  
    22<classpath>
    33        <classpathentry kind="src" path="src"/>
     4        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
    45        <classpathentry kind="lib" path="ext/lib/commons-cli-1.2.jar"/>
    5         <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
    66        <classpathentry kind="output" path="bin"/>
    77</classpath>
  • proto/pabloj/branches/refactor-experimental/.settings/org.eclipse.jdt.core.prefs

    r3013 r3115  
     1#Thu May 02 12:41:33 PDT 2013
    12eclipse.preferences.version=1
    23org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloS.scatter

    r3004 r3115  
    1717         Whitespace [IGNORE],
    1818         Integer [INTEGER_CONST],
    19          Identifier [IDENTIFIER],                       // Java identifiers. Produces Lextant tokens for keywords.
     19         Identifier [IDENTIFIER],                       // Java identifiers, except $ character. Produces Lextant tokens for keywords.
    2020         Comment [IGNORE] "#" "\n",                     // Added to support parabix2_pablo debugging.
    2121         Comment [IGNORE] "//" "\n",     
     
    7272
    7373nodes {
    74   binaryOperator {} [expr expr1],//, expr4],
    75   unaryOperator {} [expr2],// expr5],
     74  binaryOperator {} [expr expr1],       //, expr4],
     75  unaryOperator {} [expr2],                     // expr5],
    7676  assign {} [assignRest],
    7777  funcCall {} [funcCallRest],
     
    151151        // e x p r e s s i o n s
    152152        //     
    153         expr            #->     expr1 ((OR^|XOR^) expr)? ;
    154                                        
    155         expr1           #-> expr2 ((AND^) expr1)? ;
    156                                        
    157         expr2           #-> NOT^^? expr3  _leftAssoc_;
     153        expr            #->     expr1 ((OR^|XOR^) expr)?  _leftAssoc_ ;
     154                                       
     155        expr1           #-> expr2 ((AND^) expr1)?  _leftAssoc_ ;
     156                                       
     157        expr2           #-> NOT^^? expr3;
    158158       
    159159        expr3           #-> LROUND expr RROUND
  • proto/pabloj/branches/refactor-experimental/input/test/pabloS/test.pablos

    r3082 r3115  
    11function void Test() {
    2         a.b;
     2        a.b();
    33};
  • proto/pabloj/branches/refactor-experimental/src/application/generators/ApplicationGenerator.java

    r3010 r3115  
    2525import toolchain.pabloB.codeGenerator.visitors.AbstractUnparser;
    2626import toolchain.pabloB.codeGenerator.visitors.Unparser;
    27 import toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
     27import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    2828import toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
    2929import toolchain.pabloB.symbols.SymbolTable;
    3030import toolchain.pabloS.lang.*;
    3131import toolchain.pabloS.semanticAnalyzer.Transformer;
    32 import toolchain.pabloS.semanticAnalyzer.visitors.CarryInfoSetVisitor;
    3332import toolchain.pabloS.semanticAnalyzer.visitors.PabloS2PabloBXFormer;
     33import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryInfoSetVisitor;
    3434
    3535import application.config.Configuration;
     
    5656               
    5757                // Transformation configurations to support multiple backends
    58                 AbstractPabloSBuiltins2Lang builtins2Lang               = null;
    59                 AbstractCarrySetBuiltins2Lang carrySet2Lang     = null;
     58                BuiltinEncoder builtins2Lang            = null;
     59                CarrySetEncoder carrySet2Lang   = null;
    6060                AbstractUnparser unparser                                               = null;
    6161               
  • proto/pabloj/branches/refactor-experimental/src/pabloS/ast/ASTNode.java

    r3004 r3115  
    1111
    1212import pabloS.tokens.Token;
    13 
    14 
    15 
    16 public class ASTNode  {
     13import pabloS.inputHandler.Locator;
     14import pabloS.inputHandler.TextLocation;
     15
     16
     17
     18public class ASTNode implements Locator  {
    1719        public static final ASTNode NO_PARENT = null;
    1820        public static final int NO_TAG = -1;
     
    8486                return simplifiable;
    8587        }
     88        public TextLocation getLocation() {
     89                return getToken().getLocation();
     90        }       
    8691
    8792
     
    133138                replaceChild(index, replacement);
    134139        }
    135         private void replaceChild(int index, ASTNode replacement) {
     140        public void replaceChild(int index, ASTNode replacement) {
    136141                ASTNode oldChild = children.remove(index);
    137142                oldChild.setParent(null);
  • proto/pabloj/branches/refactor-experimental/src/pabloS/inputHandler/BookmarkCharStream.java

    r2834 r3115  
    88package pabloS.inputHandler;
    99
    10 import java.util.Stack;
     10import java.util.ArrayDeque;
     11import java.util.Deque;
    1112
    1213public class BookmarkCharStream extends PushbackCharStream {
     
    1819
    1920       
    20         private Stack<Object> bookmarkedText;
     21        private Deque<Object> bookmarkedText;
    2122        private boolean isBookmarking;
    2223       
    2324        public BookmarkCharStream(InputHandler handler) {
    2425                super(handler);
    25                 this.bookmarkedText = new Stack<Object>();
     26                this.bookmarkedText = new ArrayDeque<Object>();
    2627                isBookmarking = false;
    2728        }
     
    7172        }
    7273
    73         // it would probably be faster to check the bottom of stack against
    74         // bookmark first...
     74
    7575        public void release(Bookmark bookmark) {
    76                 Object object;
    77                 do {
    78                         object = bookmarkedText.pop();
    79                 } while (object != bookmark);
    80                
    81                 if(bookmarkedText.isEmpty()) {
     76                if(bookmark == bookmarkedText.peekLast()) {
     77                        bookmarkedText.clear();
    8278                        isBookmarking = false;
     79                }
     80                else {
     81                        bookmarkedText.removeFirstOccurrence(bookmark);
    8382                }
    8483        }
  • proto/pabloj/branches/refactor-experimental/src/pabloS/inputHandler/TextLocation.java

    r2834 r3115  
    99
    1010// value object for specifying the location of a lexeme or other piece of text
    11 public class TextLocation {
     11public class TextLocation implements Locator {
    1212        private String filename;
    1313        private int lineNumber;
     
    4343        }
    4444       
     45        @Override
     46        public TextLocation getLocation() {
     47                return this;
     48        }
    4549       
    4650       
  • proto/pabloj/branches/refactor-experimental/src/pabloS/lexicalAnalyzer/tokenRecognizers/CharacterTokenRecognizer.java

    r3080 r3115  
    1010import pabloS.tokens.CharacterToken;
    1111import pabloS.tokens.Token;
    12 import pabloS.tokens.NullToken;
    1312import pabloS.inputHandler.BookmarkCharStream;
    1413import pabloS.inputHandler.LocatedChar;
    1514import pabloS.inputHandler.TextLocation;
    16 import pabloS.inputHandler.LocatedCharStream;
    1715
    1816public class CharacterTokenRecognizer extends TokenRecognizerImp {
  • proto/pabloj/branches/refactor-experimental/src/pabloS/lexicalAnalyzer/tokenRecognizers/TokenRecognizerImp.java

    r3080 r3115  
    99import pabloS.lexicalAnalyzer.LexicalType;
    1010import pabloS.lexicalAnalyzer.TokenRecognizer;
     11import pabloS.logging.ScatterLogger;
    1112import pabloS.tokens.Token;
    1213import pabloS.inputHandler.LocatedChar;
     
    115116                return result;
    116117        }
    117                
     118
    118119        private boolean sloppyInputStartsWith(String lexeme) {
    119120                for(int i=0; i<lexeme.length(); i++) {
     
    124125                return true;
    125126        }
     127       
     128       
     129        protected void lexicalError(String msg) {
     130                logError("lexical error: " + msg);
     131        }
     132
     133        static void logError(String message) {
     134                ScatterLogger log = ScatterLogger.getLogger("compiler.semanticAnalyzer");
     135                log.severe(message);
     136        }
    126137}
  • proto/pabloj/branches/refactor-experimental/src/pabloS/parser/Parser.java

    r3080 r3115  
    6363                                }
    6464                        }
     65                        else {
     66                                return syntaxErrorNode("[FUNCTION¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     67                        }
    6568                }
    6669                if(allowCompression) {
     
    291294                        }
    292295                }
     296                else {
     297                        return syntaxErrorNode("[IDENTIFIER¹, IF¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STRING¹, VAR¹, WHILE¹]");
     298                }
    293299                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
    294300                        expect(Lextant.TERMINATOR);
     
    331337                        result = promoteLastChild(result);
    332338                        allowCompression = false;
     339                }
     340                else {
     341                        return syntaxErrorNode("[AND_ASSIGN¹, ASSIGN¹, LROUND¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
    333342                }
    334343                expect(Lextant.TERMINATOR);
     
    409418                        expect(Lextant.XOR_ASSIGN);
    410419                }
     420                else {
     421                        return syntaxErrorNode("[AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     422                }
    411423                if(allowCompression) {
    412424                        return result;
     
    651663                                expect(Lextant.XOR);
    652664                        }
     665                        else {
     666                                return syntaxErrorNode("[OR¹, XOR¹]");
     667                        }
    653668                        {
    654669                                ASTNode child = parseExpr();
     
    657672                        }
    658673                }
     674                result = rotateLeftIfPossible(result);
    659675                if(allowCompression) {
    660676                        return compressIfPossible(result);
     
    686702                        }
    687703                }
     704                result = rotateLeftIfPossible(result);
    688705                if(allowCompression) {
    689706                        return compressIfPossible(result);
     
    711728                        allChildren.add(child);
    712729                }
    713                 result = rotateLeftIfPossible(result);
    714730                if(allowCompression) {
    715731                        return compressIfPossible(result);
     
    766782                        }
    767783                }
     784                else {
     785                        return syntaxErrorNode("[IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
     786                }
    768787                if(allowCompression) {
    769788                        return compressIfPossible(result);
     
    794813                                allChildren.add(child);
    795814                        }
     815                }
     816                else {
     817                        return syntaxErrorNode("[INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
    796818                }
    797819                if(allowCompression) {
     
    848870                        readToken();
    849871                }
     872                else {
     873                        return syntaxErrorNode("[SQ_STRING¹, STRING¹]");
     874                }
    850875                if(allowCompression) {
    851876                        return result;
     
    938963                                allChildren.add(child);
    939964                        }
     965                }
     966                else {
     967                        return syntaxErrorNode("[IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    940968                }
    941969                if(allowCompression) {
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/CharacterToken.java

    r3080 r3115  
    1111import pabloS.inputHandler.TextLocation;
    1212
    13 public class CharacterToken extends TokenImp  implements IntValuedToken {
    14         protected CharacterToken(LexicalType type, TextLocation location, String lexeme) {
     13public class CharacterToken extends TokenImp implements IntValuedToken {
     14        private char value;
     15
     16        protected CharacterToken(LexicalType type, TextLocation location, String lexeme, char value) {
    1517                super(type, location, lexeme.intern());
     18                this.value = value;
    1619        }
    1720       
    1821        public static CharacterToken make(LexicalType type, TextLocation location, String lexeme) {
    19                 CharacterToken result = new CharacterToken(type, location, lexeme);
     22                CharacterToken result = new CharacterToken(type, location, lexeme, lexeme.charAt(0));
    2023                return result;
    2124        }
    22 
    23         public int getValue() {
    24                 return (int)(getLexeme().charAt(0));
     25        public static CharacterToken make(LexicalType type, TextLocation location, String lexeme, char value) {
     26                CharacterToken result = new CharacterToken(type, location, lexeme, value);
     27                return result;
    2528        }
    2629       
     30        public char getChar() {
     31                return value;
     32        }
     33        public int getValue() {
     34                return (int)(value);
     35        }
     36
    2737        @Override
    2838        protected String rawString() {
    29                 return "character, " + getLexeme();
     39                return "character, " + getChar();
    3040        }
    3141}
  • proto/pabloj/branches/refactor-experimental/src/pabloS/tokens/Token.java

    r2834 r3115  
    1111import pabloS.lexicalAnalyzer.Lextant;
    1212import pabloS.inputHandler.TextLocation;
     13import pabloS.inputHandler.Locator;
    1314
    14 public interface Token {
     15public interface Token extends Locator {
    1516        public String getLexeme();
    1617        public String getPrintableLexeme();
  • proto/pabloj/branches/refactor-experimental/src/test/pabloS/PabloSTestHarness.java

    r3010 r3115  
    1212import  pabloS.ast.ASTNode;
    1313import  pabloS.logging.ScatterLogger;
    14 import toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
     14import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    1515import toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
    16 import toolchain.pabloS.lang.AbstractPabloSBuiltins2Lang;
     16import toolchain.pabloS.lang.BuiltinEncoder;
    1717import toolchain.pabloS.lang.PabloSBuiltins;
    1818import toolchain.pabloS.lang.PabloSBuiltins2CPP;
    1919import toolchain.pabloS.semanticAnalyzer.helpers.AssertCompare;
    20 import toolchain.pabloS.semanticAnalyzer.visitors.AdvanceCombinerXFormer;
    21 import toolchain.pabloS.semanticAnalyzer.visitors.AugAssignXFormer;
     20import toolchain.pabloS.semanticAnalyzer.visitors.CombineAdvances;
     21import toolchain.pabloS.semanticAnalyzer.visitors.ExpandAugmentedAssignments;
    2222import toolchain.pabloS.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
    23 import toolchain.pabloS.semanticAnalyzer.visitors.CarryIntroXFormer;
    2423import toolchain.pabloS.semanticAnalyzer.visitors.InitStreamDefaultsXFormer;
    2524import toolchain.pabloS.semanticAnalyzer.visitors.StreamFuncVisitor;
     25import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryIntroXFormer;
    2626import toolchain.test.*;
    2727
     
    144144               
    145145                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                             
    146                     AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(entry.getValue());
    147                     advanceCombiner.XForm();                       
     146                    CombineAdvances.apply(entry.getValue());   
    148147                }   
    149148               
     
    187186               
    188187                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {                                                                     
    189                         AugAssignXFormer AugAssign = new AugAssignXFormer(entry.getValue());   
    190                         AugAssign.XForm();
     188                        ExpandAugmentedAssignments.apply(entry.getValue());     
    191189                }   
    192190               
     
    210208                Map<String, ASTNode> streamFuncMap = streamFuncVisitor.makeStreamFuncMap();
    211209               
    212                 AbstractPabloSBuiltins2Lang builtins2CPP = new PabloSBuiltins2CPP();
     210                BuiltinEncoder builtins2CPP = new PabloSBuiltins2CPP();
    213211               
    214212                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
    215213                        ASTNode value = entry.getValue();                               
    216                         AbstractCarrySetBuiltins2Lang carrySet2CPP = new CarrySetBuiltins2CPP();
     214                        CarrySetEncoder carrySet2CPP = new CarrySetBuiltins2CPP();
    217215                        CarryIntroXFormer pablo2CarryQ = new CarryIntroXFormer(value, builtins2CPP, carrySet2CPP);
    218216                        pablo2CarryQ.XForm(isFinalBlock);
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3035 r3115  
    151151        public CodeStore visitLeave(StateIdentifierNode node, List<CodeStore> childResults) {           
    152152               
    153                 stateIdentifier = Accessors.stateName(node); // synthetic attribute
     153//              stateIdentifier = Accessors.stateName(node); // synthetic attribute
    154154               
    155155                CodeStore code = new CodeStore();
     
    190190        public CodeStore visitLeave(StateSizeNode node, List<CodeStore> childResults) {
    191191                CodeStore code = new CodeStore();
    192                 code.setResultVarName(Accessors.integerConstantLexeme(node));
     192//              code.setResultVarName(Accessors.integerConstantLexeme(node));
    193193                return code;
    194194        }       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/lang/carrySet/CarrySetBuiltins2CPP.java

    r3010 r3115  
    1010import java.util.Map;
    1111
    12 public class CarrySetBuiltins2CPP extends AbstractCarrySetBuiltins2Lang {
     12public class CarrySetBuiltins2CPP extends CarrySetEncoder {
    1313       
    1414        private static Map<CarrySetBuiltins, String> carry2CPPCode;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/lang/carrySet/CarrySetEncoder.java

    r3102 r3115  
    77package toolchain.pabloB.lang.carrySet;
    88
    9 public abstract class AbstractCarrySetBuiltins2Lang {
     9public abstract class CarrySetEncoder {
    1010       
    1111        public abstract String getCode(CarrySetBuiltins op);
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/semanticAnalyzer/Transformer.java

    r3097 r3115  
    1818       
    1919        private AbstractPabloBBuiltins2Lang builtins2Lang;
    20         private AbstractCarrySetBuiltins2Lang carrySet2Lang;
     20        private CarrySetEncoder carrySet2Lang;
    2121       
    2222        //////////////////////////////////////////////////////////////
     
    6262        }
    6363
    64         public AbstractCarrySetBuiltins2Lang getCarrySet2Lang() {
     64        public CarrySetEncoder getCarrySet2Lang() {
    6565                return carrySet2Lang;
    6666        }
    6767
    68         public void setCarrySet2Lang(AbstractCarrySetBuiltins2Lang carrySet2Lang) {
     68        public void setCarrySet2Lang(CarrySetEncoder carrySet2Lang) {
    6969                this.carrySet2Lang = carrySet2Lang;
    7070        }
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/ast/Generators.java

    r3098 r3115  
    1414import java.util.ArrayList;
    1515import java.util.List;
     16
     17import pabloS.inputHandler.Locator;
    1618import pabloS.lexicalAnalyzer.*;
    1719import pabloS.tokens.*;
     
    3638        }
    3739       
    38         public static LocalVarDeclNode makeLocalVarDeclNode(ASTNode type, IdentifierNode identifier, ASTNode rhs, Token locationToken) {
    39                
    40                 Token assignToken = Generators.makeLextantToken(Lextant.ASSIGN, locationToken);
     40        public static LocalVarDeclNode makeLocalVarDeclNode(ASTNode type, IdentifierNode identifier, ASTNode rhs, Locator locator) {
     41               
     42                Token assignToken = Generators.makeLextantToken(Lextant.ASSIGN, locator);
    4143                LocalVarDeclNode localVarDeclNode = new LocalVarDeclNode(assignToken);
    4244               
     
    4951
    5052        // Make function Call variants
    51         public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, ASTNode ...args) {
    52                
    53                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
    54                 Generators.addFuncCallArgs(node, args);
    55                 return node;
    56         }       
    57 
    58         public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, List<ASTNode> args) {
    59                
    60                 FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
    61                 Generators.addFuncCallArgs(node, args);
    62                 return node;
    63         }       
    64        
    65         public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken) {
    66                 IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);       
    67                 return Generators.makeFuncCallNode(identifierNode, locationToken);
    68         }
    69 
    70         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode ...args) {
    71                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
    72                 Generators.addFuncCallArgs(node, args);
    73                 return node;
    74         }
    75 
    76         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, List<ASTNode> args) {
    77                
    78                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     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       
     67        public static FuncCallNode makeFuncCallNode(String identifier, Locator locator) {
     68                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);     
     69                return Generators.makeFuncCallNode(identifierNode, locator);
     70        }
     71
     72        public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, ASTNode ...args) {
     73                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
     74                Generators.addFuncCallArgs(node, args);
     75                return node;
     76        }
     77
     78        public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator, List<ASTNode> args) {
     79               
     80                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locator);
    7981                Generators.addFuncCallArgs(node, args);
    8082                return node;
    8183        }               
    8284       
    83         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {               
    84                 CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
    85                 return Generators.makeFuncCallNode(identifierNode, locationToken);
    86         }
    87 
    88         private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
     85        public static FuncCallNode makeFuncCallNode(String[] identifiers, Locator locator) {           
     86                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locator);
     87                return Generators.makeFuncCallNode(identifierNode, locator);
     88        }
     89
     90        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Locator locator) {
    8991                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
    9092
    91                 LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
     93                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locator);
    9294                FuncCallNode FuncCallNode = new FuncCallNode(token);
    9395                FuncCallNode.appendChild(identifier);
    94                 FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
     96                FuncCallNode.appendChild(new FuncCallArgListNode(token));               // TODO: verify the token is okay for the ArgListNode
    9597
    9698                return FuncCallNode;
     
    120122         * (Maybe we can return a IdentifierNode directly in later versions.)
    121123         * @param identifiers           all identifiers
    122          * @param locationToken         a token containing the TextLocation for this new node.
     124         * @param locator               a token containing the TextLocation for this new node.
    123125         * @return      the new CompoundIdentifierNode
    124126         */
    125         public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Token locationToken) {
    126                 Token dotToken = Generators.makeLextantToken(Lextant.DOT, locationToken);
     127        public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Locator locator) {
     128                Token dotToken = Generators.makeLextantToken(Lextant.DOT, locator);
    127129                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
    128130                for (String identifier : identifiers) {
    129                         IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);
     131                        IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);
    130132                        CompoundIdentifierNode.appendChild(identifierNode);
    131133                }
     
    135137        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from token.
    136138         * @param identifier
    137          * @param locationToken         a token containing the TextLocation for this new node.
     139         * @param locator               a token containing the TextLocation for this new node.
    138140         * @return      the new IdentifierNode
    139141         */
    140         public static IdentifierNode makeIdentifierNode(String identifier, Token locationToken) {
    141                 IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
     142        public static IdentifierNode makeIdentifierNode(String identifier, Locator locator) {
     143                IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locator);
    142144                return new IdentifierNode(newToken);
    143145        }
     
    145147        /** Makes a new LextantToken with the given lextant and location taken from the given token.
    146148         * @param lextant
    147          * @param locationToken
     149         * @param locator
    148150         * @return the new LextantToken
    149151         */
    150         public static LextantToken makeLextantToken(Lextant lextant, Token locationToken) {
    151                 return LextantToken.make(locationToken.getLocation(), lextant.getPrimaryLexeme(), lextant);
     152        public static LextantToken makeLextantToken(Lextant lextant, Locator locator) {
     153                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
    152154        }
    153155
    154156        /** Makes a new StringConstantToken with the given string and location taken from the given token.
    155157         * @param string
    156          * @param locationToken
     158         * @param locator
    157159         * @return the new StringConstantToken
    158160         */
    159         public static StringConstantToken makeStringConstantToken(String string, Token locationToken) {
    160                 return StringConstantToken.make(LexicalType.STRING, locationToken.getLocation(), string);
     161        public static StringConstantToken makeStringConstantToken(String string, Locator locator) {
     162                return StringConstantToken.make(LexicalType.STRING, locator.getLocation(), string);
    161163        }
    162164
    163165        /** Makes a new IdentifierToken with the given identifier and location taken from the given token.
    164166         * @param identifier
    165          * @param locationToken
     167         * @param locator
    166168         * @return the new IdentifierToken
    167169         */
    168         public static IdentifierToken makeIdentifierToken(String identifier, Token locationToken) {
    169                 return IdentifierToken.make(LexicalType.IDENTIFIER, locationToken.getLocation(), identifier);
     170        public static IdentifierToken makeIdentifierToken(String identifier, Locator locator) {
     171                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
    170172        }
    171173
    172174        /** Makes a new StringConstantNode with the given string and the TextLocation taken from token.
    173175         * @param string                        string value/lexeme of new node.
    174          * @param locationToken         a token containing the TextLocation for this new node.
     176         * @param locator               a token containing the TextLocation for this new node.
    175177         * @return      the new StringConstantNode
    176178         */
    177         public static StringConstantNode makeStringConstantNode(String string, Token locationToken) {
    178                 StringConstantToken newToken = makeStringConstantToken(string, locationToken);
     179        public static StringConstantNode makeStringConstantNode(String string, Locator locator) {
     180                StringConstantToken newToken = makeStringConstantToken(string, locator);
    179181                return new StringConstantNode(newToken);
    180182        }
     
    182184        /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from token.
    183185         * @param n                     integer value of new node.
    184          * @param locationToken         a token containing the TextLocation for this new node.
     186         * @param locator               a token containing the TextLocation for this new node.
    185187         * @return      the new IntegerConstantNode
    186188         */
    187         public static IntegerConstantNode makeIntegerConstantNode(int n, Token locationToken) {
    188                 Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
     189        public static IntegerConstantNode makeIntegerConstantNode(int n, Locator locator) {
     190                Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
    189191                IntegerConstantNode integerConstantNode = new IntegerConstantNode(newToken);
    190192                integerConstantNode.setValue(n);
     
    192194        }
    193195       
    194         public static IntConstantToken makeIntegerConstantToken(int n, Token locationToken) {
    195                 return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
    196         }       
    197        
    198         public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token locationToken) {
    199                 BinaryOperatorNode node = new BinaryOperatorNode(locationToken);
     196        public static IntConstantToken makeIntegerConstantToken(int n,  Locator locator) {
     197                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
     198        }       
     199       
     200        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token token) {
     201                BinaryOperatorNode node = new BinaryOperatorNode(token);
    200202                node.appendChild(lhs.deepCopy());
    201203                node.appendChild(rhs.deepCopy());
     
    203205        }       
    204206       
    205         public static BlockStmtNode makeBlockStmtNode(Token tokenLocation) {
    206                 LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, tokenLocation);
    207                 return new BlockStmtNode(token);
    208         }
    209 
    210         public static IfStmtNode makeIfStmtNode(Token tokenLocation, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
    211                 IfStmtNode ifStmtNode = makeIfStmtNode(tokenLocation, expression, ifBlockStmt);
     207        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
     208                LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, locator);
     209               
     210                BlockStmtNode result = new BlockStmtNode(token);
     211                for(ASTNode child: children) {
     212                        result.appendChild(child);
     213                }
     214                return result;
     215        }
     216
     217        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
     218                IfStmtNode ifStmtNode = makeIfStmtNode(locator, expression, ifBlockStmt);
    212219                ifStmtNode.appendChild(elseBlockStmt);
    213220                return ifStmtNode;
    214221        }       
    215222       
    216         public static IfStmtNode makeIfStmtNode(Token tokenLocation, ASTNode expression, BlockStmtNode blockStmt) {
    217                 LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, tokenLocation);
     223        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode blockStmt) {
     224                LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, locator);
    218225                IfStmtNode ifStmtNode = new IfStmtNode(token);
    219226                ifStmtNode.appendChild(expression);
     
    222229        }
    223230       
    224         public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
     231        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    225232                List<ASTNode> args = new ArrayList<ASTNode>();
    226233                args.add(node);
     
    229236        }
    230237
    231         public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
     238        public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    232239                List<ASTNode> args = new ArrayList<ASTNode>();
    233240                args.add(node);
     
    236243        }       
    237244
    238         public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
     245        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    239246                List<ASTNode> args = new ArrayList<ASTNode>();
    240247                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
     
    243250        }               
    244251       
    245         public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang) {
     252        public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    246253                List<ASTNode> args = new ArrayList<ASTNode>();
    247254                args.add(node);
     
    249256        }               
    250257       
    251         public static ParameterNode makeEOFMaskParameter(AbstractPabloSBuiltins2Lang builtins2Lang, Token locationToken) {
    252                
    253                 Token parameterNodeToken = Generators.makeLextantToken(Lextant.STREAM, locationToken);
     258        public static ParameterNode makeEOFMaskParameter(BuiltinEncoder builtins2Lang, Locator locator) {
     259               
     260                Token parameterNodeToken = Generators.makeLextantToken(Lextant.STREAM, locator);
    254261                ParameterNode parameterNode = new ParameterNode(parameterNodeToken);
    255262               
    256                 Token streamTypeToken = Generators.makeLextantToken(Lextant.STREAM, locationToken);
     263                Token streamTypeToken = Generators.makeLextantToken(Lextant.STREAM, locator);
    257264                StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
    258                 IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), locationToken);
     265                IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), locator);
    259266               
    260267                parameterNode.appendChild(streamTypeNode);
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/lang/BuiltinEncoder.java

    r3102 r3115  
    11package toolchain.pabloS.lang;
    22
    3 public abstract class AbstractPabloSBuiltins2Lang {
     3public abstract class BuiltinEncoder {
    44        public abstract String getCode(PabloSBuiltins builtin);
    55}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/lang/PabloSBuiltins.java

    r3098 r3115  
    2323    ATEOF("atEOF", CarryType.None, 1),
    2424    INFILE("inFile", CarryType.None, 1),
    25     ASSERTZERO("assert_0", CarryType.None, 2), 
     25    ASSERT_ZERO("assert_0", CarryType.None, 2),
    2626    EOFMASK("EOF_mask", CarryType.None, 0), // deprecated
    2727       
    28     PRINTBITBLOCK("PrintBitBlock", CarryType.None, 1),
    29     ASSERTBITBLOCKALIGN("AssertBitBlockAlign", CarryType.None, 1);
     28    PRINT_BITBLOCK("PrintBitBlock", CarryType.None, 1),
     29    ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign", CarryType.None, 1);
    3030   
    31     private enum CarryType{One, N, None};   
     31    public enum CarryType{One, N, None};   
    3232   
    3333    private final CarryType type;
     
    4343        public String pabloSName() { return this.name; }
    4444        public int argCount() { return this.argCount; }
    45 
     45        public final CarryType getCarryType() { return type; }
     46       
    4647        public static List<PabloSBuiltins> carryOneOperations () {
    4748               
     
    6970                return carryN;
    7071        }
     72
    7173       
    7274}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/lang/PabloSBuiltins2CPP.java

    r3010 r3115  
    1515import java.util.Map;
    1616
    17 public class PabloSBuiltins2CPP extends AbstractPabloSBuiltins2Lang {
     17public class PabloSBuiltins2CPP extends BuiltinEncoder {
    1818
    1919        private static Map<PabloSBuiltins, String> pabloS2CPPCode;
     
    3939        pabloS2CPPCode.put(PabloSBuiltins.ATEOF, "atEOF");
    4040        pabloS2CPPCode.put(PabloSBuiltins.INFILE, "inFile");
    41         pabloS2CPPCode.put(PabloSBuiltins.ASSERTZERO, "assert_0_error");       
     41        pabloS2CPPCode.put(PabloSBuiltins.ASSERT_ZERO, "assert_0_error");       
    4242        pabloS2CPPCode.put(PabloSBuiltins.EOFMASK, "EOF_mask");
    4343       
    44         pabloS2CPPCode.put(PabloSBuiltins.PRINTBITBLOCK, "print_register<BitBlock>");
    45         pabloS2CPPCode.put(PabloSBuiltins.ASSERTBITBLOCKALIGN, "assert_bitblock_align");       
     44        pabloS2CPPCode.put(PabloSBuiltins.PRINT_BITBLOCK, "print_register<BitBlock>");
     45        pabloS2CPPCode.put(PabloSBuiltins.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");     
    4646               
    4747        for(PabloSBuiltins builtin : PabloSBuiltins.values()) {
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/lang/PabloSBuiltinsUtil.java

    r3098 r3115  
    5050       
    5151                for (PabloSBuiltins carryOneOperation : PabloSBuiltins.carryOneOperations()) {                         
     52                        @SuppressWarnings("unused")
    5253                        int argCount = Accessors.funcCallArgCount((FuncCallNode)node);
    5354                if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloSName(), carryOneOperation.argCount())){
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/Transformer.java

    r3010 r3115  
    88
    99import toolchain.pabloS.lang.*;
    10 import toolchain.pabloS.semanticAnalyzer.visitors.AdvanceCombinerXFormer;
    11 import toolchain.pabloS.semanticAnalyzer.visitors.AssertBitBlockAlignStmtsXFormer;
    12 import toolchain.pabloS.semanticAnalyzer.visitors.AssertZeroXFormer;
    13 import toolchain.pabloS.semanticAnalyzer.visitors.AugAssignXFormer;
     10import toolchain.pabloS.semanticAnalyzer.visitors.CombineAdvances;
     11import toolchain.pabloS.semanticAnalyzer.visitors.AddAlignmentAssertions;
     12import toolchain.pabloS.semanticAnalyzer.visitors.SurroundAssert0sWithIfs;
     13import toolchain.pabloS.semanticAnalyzer.visitors.ExpandAugmentedAssignments;
    1414import toolchain.pabloS.semanticAnalyzer.visitors.Bitwise2IDISAXFormer;
    15 import toolchain.pabloS.semanticAnalyzer.visitors.CarryIntroXFormer;
    16 import toolchain.pabloS.semanticAnalyzer.visitors.DumpAssignStmtsXFormer;
     15import toolchain.pabloS.semanticAnalyzer.visitors.AddAssignmentPrints;
    1716import toolchain.pabloS.semanticAnalyzer.visitors.InitStreamDefaultsXFormer;
     17import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryIntroXFormer;
    1818
    1919public class Transformer {
     
    2323        //private SymbolTable symbolTable;
    2424       
    25         private toolchain.pabloS.lang.AbstractPabloSBuiltins2Lang builtins2Lang;
    26         private toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang carrySet2Lang;
     25        private toolchain.pabloS.lang.BuiltinEncoder builtinEncoder;
     26        private toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySet2Lang;
    2727        private boolean finalBlockMode;
    2828       
     
    6262                pabloS.ast.ASTNode decoratedTree = ASTTree.deepCopy();
    6363
    64                 if(isAddDumpStmts()) {
    65                         DumpAssignStmtsXFormer dumpAssignStmtsXFormer = new DumpAssignStmtsXFormer(decoratedTree, getBuiltins2Lang()); 
    66                         dumpAssignStmtsXFormer.XForm();
     64                if(addingAssignmentPrints()) {
     65                        decoratedTree = AddAssignmentPrints.apply(decoratedTree, getBuiltinEncoder());
    6766                }
    68                
    69                 if(isAddAssertBitBlockAlignStmts()) {
    70                         AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(decoratedTree, getBuiltins2Lang()); 
    71                         assertBitBlockAlignStmtsXFormer.XForm();
     67                if(addingAlignmentAssertions()) {
     68                        decoratedTree = AddAlignmentAssertions.apply(decoratedTree, getBuiltinEncoder()); 
    7269                }                       
    7370               
    74             AugAssignXFormer AugAssign = new AugAssignXFormer(decoratedTree);
    75                 AugAssign.XForm();             
    76            
    77             AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(decoratedTree, getBuiltins2Lang());
    78                 assertZeroXFormer.XForm();                             
     71                decoratedTree = ExpandAugmentedAssignments.apply(decoratedTree);
     72                decoratedTree = SurroundAssert0sWithIfs.apply(decoratedTree, getBuiltinEncoder());             
     73                decoratedTree = CombineAdvances.apply(decoratedTree);
    7974
    80             AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(decoratedTree);
    81             advanceCombiner.XForm();
    82 
    83             CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
     75            CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getBuiltinEncoder(), getCarrySet2Lang());
    8476                carryQIntro.XForm(finalBlockMode);             
    8577
     
    9486        }
    9587
    96         public boolean isAddDumpStmts() {
     88        public boolean addingAssignmentPrints() {
    9789                return addDumpStmts;
    9890        }
     
    10294        }
    10395
    104         public boolean isAddAssertBitBlockAlignStmts() {
     96        public boolean addingAlignmentAssertions() {
    10597                return addAssertBitBlockAlignStmts;
    10698        }
     
    110102        }
    111103
    112         public AbstractPabloSBuiltins2Lang getBuiltins2Lang() {
    113                 return this.builtins2Lang;
     104        public BuiltinEncoder getBuiltinEncoder() {
     105                return this.builtinEncoder;
    114106        }
    115107
    116         public void setBuiltins2Lang(AbstractPabloSBuiltins2Lang builtins2Lang) {
    117                 this.builtins2Lang = builtins2Lang;
     108        public void setBuiltins2Lang(BuiltinEncoder builtins2Lang) {
     109                this.builtinEncoder = builtins2Lang;
    118110        }
    119111
    120         public toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang getCarrySet2Lang() {
     112        public toolchain.pabloB.lang.carrySet.CarrySetEncoder getCarrySet2Lang() {
    121113                return carrySet2Lang;
    122114        }
    123115
    124         public void setCarrySet2Lang(toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang carrySet2Lang) {
     116        public void setCarrySet2Lang(toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySet2Lang) {
    125117                this.carrySet2Lang = carrySet2Lang;
    126118        }
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/AddAlignmentAssertions.java

    r3102 r3115  
    1313import toolchain.pabloS.ast.Accessors;
    1414import toolchain.pabloS.ast.Generators;
    15 import toolchain.pabloS.lang.AbstractPabloSBuiltins2Lang;
     15import toolchain.pabloS.ast.Mutators;
     16import toolchain.pabloS.lang.BuiltinEncoder;
    1617import toolchain.pabloS.lang.PabloSBuiltins;
    1718
    18 public class AssertBitBlockAlignStmtsXFormer {
    19         private ASTNode ASTree;
     19public class AddAlignmentAssertions {
     20        private AddAlignmentAssertions(){}
    2021       
    21         private AbstractPabloSBuiltins2Lang builtins2Lang;
     22        static public ASTNode apply(ASTNode ASTree, BuiltinEncoder encoder) {
     23                XFormer xformer = new XFormer(encoder);
     24                ASTree.accept(xformer);
     25                return ASTree;          // root ASTree does not change
     26        }   
    2227       
    23         public AssertBitBlockAlignStmtsXFormer(ASTNode ASTree, AbstractPabloSBuiltins2Lang builtins2Lang) {
    24                 this.ASTree = ASTree;
    25                 this.builtins2Lang = builtins2Lang;
    26         }
    27        
    28         public ASTNode XForm() {
    29                 XFormer XFormer = new XFormer();
    30                 ASTree.accept(XFormer);
    31                 return ASTree;
    32         }
    33 
    34         private class XFormer extends VoidVisitor.Default {
    35                                
    36                 public XFormer () {}
    37                                
     28        static private class XFormer extends VoidVisitor.Default {
     29                private final BuiltinEncoder encoder;
     30                private XFormer(BuiltinEncoder encoder) {
     31                        this.encoder = encoder;
     32                }
     33               
     34                // visits               
    3835                public void visitEnter(LocalVarDeclNode node) {
    39                         addAssertBitBlockAssignStmt(node, Accessors.identifier(node));
     36                        addAssertStmt(node, Accessors.identifier(node));
    4037                }               
    4138               
    4239                public void visitEnter(AssignNode node) {
    43                         addAssertBitBlockAssignStmt(node, Accessors.lhs(node));
     40                        addAssertStmt(node, Accessors.lhs(node));
    4441                }
    4542
    46                 private void addAssertBitBlockAssignStmt(ASTNode node, ASTNode lhs) {
    47                         FuncCallNode printRegisterStmt =
    48                                         Generators.makeFuncCallNode(  builtins2Lang.getCode(PabloSBuiltins.ASSERTBITBLOCKALIGN),
    49                                                                                                                         node.getToken(),
    50                                                                                                                         new ASTNode [] {lhs});
    51                        
    52                         (node.getParent()).insertAfterChild(node, printRegisterStmt);                           
     43                // other methods
     44                private void addAssertStmt(ASTNode node, ASTNode lhs) {
     45                        FuncCallNode assertAlignCall = makeAssertAlignCall(node, lhs.deepCopy()); // deepCopy
     46                        Mutators.insertStatementAfter(node, assertAlignCall);                           
     47                }
     48
     49                private FuncCallNode makeAssertAlignCall(ASTNode node, ASTNode lhs) {
     50                        String assertAlign = encoder.getCode(PabloSBuiltins.ASSERT_BITBLOCK_ALIGN);
     51                        return Generators.makeFuncCallNode(assertAlign, node.getToken(), lhs);
    5352                }
    5453        }       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/AddAssignmentPrints.java

    r3102 r3115  
    1313import toolchain.pabloS.ast.Accessors;
    1414import toolchain.pabloS.ast.Generators;
    15 import toolchain.pabloS.lang.AbstractPabloSBuiltins2Lang;
     15import toolchain.pabloS.ast.Mutators;
     16import toolchain.pabloS.lang.BuiltinEncoder;
    1617import toolchain.pabloS.lang.PabloSBuiltins;
    1718
    18 public class DumpAssignStmtsXFormer {
    19         private ASTNode ASTree;
    20         private AbstractPabloSBuiltins2Lang builtins2Lang;
     19public class AddAssignmentPrints {
     20        private AddAssignmentPrints(){}
     21
     22        static public ASTNode apply(ASTNode ASTree, BuiltinEncoder encoder) {
     23                XFormer xformer = new XFormer(encoder);
     24                ASTree.accept(xformer);
     25                return ASTree;          // root ASTree does not change
     26        }   
    2127       
    22         public DumpAssignStmtsXFormer(ASTNode ASTree, AbstractPabloSBuiltins2Lang builtins2Lang) {
    23                 this.ASTree = ASTree;
    24                 this.builtins2Lang = builtins2Lang;
    25         }
    26        
    27         public ASTNode XForm() {
    28                 XFormer XFormer = new XFormer();
    29                 ASTree.accept(XFormer);
    30                 return ASTree;
    31         }
    3228
    33         private class XFormer extends VoidVisitor.Default {
    34                                
    35                 public XFormer () {}
    36                                
     29        static private class XFormer extends VoidVisitor.Default {
     30                private final BuiltinEncoder encoder;
     31                private XFormer(BuiltinEncoder encoder) {
     32                        this.encoder = encoder;
     33                }
     34               
     35                // visits
    3736                public void visitEnter(LocalVarDeclNode node) {
    38                         addDumpStmt(node, Accessors.identifier(node));
     37                        addPrintStatement(node, Accessors.identifier(node));
    3938                }               
    4039               
    4140                public void visitEnter(AssignNode node) {
    42                         addDumpStmt(node, Accessors.lhs(node));
     41                        addPrintStatement(node, Accessors.lhs(node));
    4342                }
    4443
    45                 private void addDumpStmt(ASTNode node, ASTNode lhs) {
    46                         FuncCallNode printRegisterStmt =
    47                                         Generators.makeFuncCallNode(  builtins2Lang.getCode(PabloSBuiltins.PRINTBITBLOCK),
    48                                                                                                                         node.getToken(),
    49                                                                                                                         new ASTNode [] {lhs});
    50                        
    51                         (node.getParent()).insertAfterChild(node, printRegisterStmt);                           
     44               
     45                // other methods
     46                private void addPrintStatement(ASTNode node, ASTNode lhs) {
     47                        FuncCallNode printCall = makePrintCall(node, lhs.deepCopy());   // deepCopy
     48                        Mutators.insertStatementAfter(node, printCall);                         
     49                }
     50
     51                private FuncCallNode makePrintCall(ASTNode node, ASTNode argument) {
     52                        String printBitblockCode = encoder.getCode(PabloSBuiltins.PRINT_BITBLOCK);
     53                        return Generators.makeFuncCallNode(printBitblockCode, node.getToken(), argument);
    5254                }
    5355        }       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/CombineAdvances.java

    r3102 r3115  
    1616import toolchain.pabloS.ast.Accessors;
    1717import toolchain.pabloS.ast.Generators;
    18 import toolchain.pabloS.lang.PabloSBuiltinsUtil;
     18import static toolchain.pabloS.lang.PabloSBuiltinsUtil.isAdvance;
    1919
    20 public class AdvanceCombinerXFormer {
     20public class CombineAdvances {
    2121       
    22     private ASTNode ASTTree;
     22        static public ASTNode apply(ASTNode ASTree) {
     23                AdvanceCombinerVisitor combiner = new AdvanceCombinerVisitor();
     24                ASTree.accept(combiner);
     25                return ASTree;                          // root ASTree does not change
     26        }   
    2327   
    24     public AdvanceCombinerXFormer(ASTNode astTree) {
    25         this.ASTTree = astTree;
    26     }
    27    
    28     public void XForm() {
    29         AdvanceCombinerVisitor visitor = new AdvanceCombinerVisitor();       
    30         ASTTree.accept(visitor);
    31     }   
    32    
    33         private class AdvanceCombinerVisitor extends VoidVisitor.Default {
     28    static private class AdvanceCombinerVisitor extends VoidVisitor.Default {
    3429
     30        // what are these two methods doing in a visitor called AdvanceCombiner?
    3531                public void visitEnter(IfStmtNode node) {
    3632                    // Additional carry logic required to support carry combine within If stmts
     
    4339
    4440                public void visitLeave(FuncCallNode node) {
     41                        // consider doing this:
     42//                      if(isAdvance(node) && Accessors.funcCallArgCount(node)==1) {
     43//                              Accessors.funcCallArgsListNode(node).appendChild(integerConstant(1, node));
     44//                      }
     45                        // then you don't need switches below, just one if.
    4546                       
    46                         if(!isAdvanceOfAdvance(node)) {
    47                                 return;
     47                        if(isAdvanceOfAdvance(node)) { 
     48                                FuncCallNode child = (FuncCallNode) Accessors.funcCallArg(node,0);
     49                                combineAdvanceNodes(node, child);
     50                        }                       
     51                }       
     52
     53                private int advanceAmount(FuncCallNode node) {
     54                        assert isAdvance(node);
     55                        switch(Accessors.funcCallArgCount(node)) {
     56                        case 1:         return 1;
     57                        case 2:         return valueOf(Accessors.funcCallArg(node,  1));
     58                        default:        assert false;                   // programmer or compiler error? assert or exception?
     59                                                return 0;
    4860                        }
    49                                                        
    50                         ASTNode argsList = Accessors.funcCallArgsListNode((FuncCallNode) node);
    51                         FuncCallNode child = (FuncCallNode)argsList.child(0);
    52                        
    53                         int amount1 = advanceAmount(node);
    54                         int amount2 = advanceAmount(child);
    55                                                
    56                         translateAdvanceNode(node, child, amount1, amount2);
    5761                }               
    58         }
    59        
    60         private int valueOf(ASTNode node) {
    61                 //assert node instanceof IntegerConstantNode;
    62                 IntConstantToken token = (IntConstantToken) node.getToken();
    63                 return token.getValue();
    64         }
    65 
    66         private int advanceAmount(FuncCallNode node) {
    67                 assert PabloSBuiltinsUtil.isAdvance(node);
    68                 if(Accessors.funcCallArgsListNode(node).nChildren()==1) {
    69                         return 1;
    70                 }
    71                 assert Accessors.funcCallArgsListNode(node).nChildren()==2;
    72                 return valueOf(Accessors.funcCallArgsListNode(node).child(1));
    73         }       
    74        
    75         private boolean isAdvanceOfAdvance(ASTNode node) {
    76                
    77                 if(!(node instanceof FuncCallNode)) {
    78                         return false;
    79                 }
    80                
    81                 if(!PabloSBuiltinsUtil.isAdvance((FuncCallNode) node)) {
    82                         return false;
    83                 }                       
    84                
    85                 ASTNode argsList = Accessors.funcCallArgsListNode((FuncCallNode) node);
    86                
    87                 if(argsList.child(0) instanceof FuncCallNode) {
    88                         return PabloSBuiltinsUtil.isAdvance((FuncCallNode)argsList.child(0));
    89                 } else {
    90                         return false;
    91                 }
     62                // the following throws a ClassCastException if token is not an IntConstant.  Programmer or compiler error?
     63                private int valueOf(ASTNode node) {
     64                        IntConstantToken token = (IntConstantToken) node.getToken();
     65                        return token.getValue();
     66                }               
    9267               
    9368               
    94         }
    95        
    96         private void translateAdvanceNode(
    97                         FuncCallNode node,
    98                         FuncCallNode child,
    99                         int amount1, int amount2) {
    100                
    101                 node.replaceChild(      Accessors.funcCallArgsListNode(node),
    102                                                         Accessors.funcCallArgsListNode(child));
    103                
    104                 IntegerConstantNode integerConstantNode = Generators.makeIntegerConstantNode(amount1+amount2, node.getToken());
    105                 if(Accessors.funcCallArgsListNode(node).nChildren()==1) {
    106                         Accessors.funcCallArgsListNode(child).appendChild(integerConstantNode);
     69                private boolean isAdvanceOfAdvance(FuncCallNode node) {
     70                        if(!isAdvance(node)) {
     71                                return false;
     72                        }                       
     73                       
     74                        ASTNode child = Accessors.funcCallArg(node, 0);         // again, if #args==0 this will throw.  Programmer or compiler?
     75                        if(!(child instanceof FuncCallNode)) {
     76                                return false;
     77                        }
     78                        return isAdvance((FuncCallNode)child);
     79                }       
     80
     81                private void combineAdvanceNodes(FuncCallNode node, FuncCallNode child) {
     82                        int combinedAmount = advanceAmount(node) + advanceAmount(child);
     83                       
     84                        ASTNode newArgumentList = Accessors.funcCallArgsListNode(child);
     85                        ASTNode oldArgumentList = Accessors.funcCallArgsListNode(node);
     86                        node.replaceChild(oldArgumentList, newArgumentList);
     87                       
     88                        ASTNode amount = integerConstant(combinedAmount, node);
     89                       
     90                        // the following could be extracted, and maybe the line above, too.
     91                        switch(newArgumentList.nChildren()) {
     92                        case 1:
     93                                newArgumentList.appendChild(amount);
     94                                break;
     95                        case 2:
     96                                newArgumentList.replaceChild(1, amount);
     97                                break;
     98                        default:
     99                                assert false;                   // programmer or compiler error? assert or exception?
     100                                break;
     101                        }
    107102                }
    108                 assert Accessors.funcCallArgsListNode(node).nChildren()==2;
    109                 Accessors.funcCallArgsListNode(node).replaceChild(
    110                                 Accessors.funcCallArgsListNode(node).child(1),
    111                                 integerConstantNode);
     103                private IntegerConstantNode integerConstant(int n, ASTNode locationReference) {
     104                        return Generators.makeIntegerConstantNode(n, locationReference.getToken());
     105                }
    112106        }
    113107}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/ExpandAugmentedAssignments.java

    r3102 r3115  
    1212
    1313import pabloS.ast.*;
     14import pabloS.inputHandler.TextLocation;
    1415import pabloS.lexicalAnalyzer.Lextant;
    1516import pabloS.tokens.*;
     
    1718import toolchain.pabloS.ast.Generators;
    1819
    19 public class AugAssignXFormer {
    20 
    21         private static Map<Lextant, Lextant> AugAssignMap = new HashMap<Lextant, Lextant>();
     20public class ExpandAugmentedAssignments {
     21       
     22        private static Map<Lextant, Lextant> IncludedOperators = new HashMap<Lextant, Lextant>();
    2223       
    2324        static {
    24                 AugAssignMap.put(Lextant.AND_ASSIGN, Lextant.AND);
    25                 AugAssignMap.put(Lextant.OR_ASSIGN, Lextant.OR);
    26                 AugAssignMap.put(Lextant.XOR_ASSIGN, Lextant.XOR);
    27                 //AugAssignMap.put(Lextant.NOT_ASSIGN, Lextant.NOT);
     25                IncludedOperators.put(Lextant.AND_ASSIGN, Lextant.AND);
     26                IncludedOperators.put(Lextant.OR_ASSIGN, Lextant.OR);
     27                IncludedOperators.put(Lextant.XOR_ASSIGN, Lextant.XOR);
    2828        };
    2929       
    30         private ASTNode ASTree;
    31        
    32         public AugAssignXFormer(ASTNode ASTree) {
    33                 this.ASTree = ASTree;
    34         }
    35        
    36         public void XForm() {
    37                 VoidVisitor visitor = new AugAssignRemovalVisitor();
     30        static public ASTNode apply(ASTNode ASTree) {
     31                AugAssignRemovalVisitor visitor = new AugAssignRemovalVisitor();
    3832                ASTree.accept(visitor);
    39         }
     33                return ASTree;          // root ASTree does not change
     34        }   
    4035
    41         private class AugAssignRemovalVisitor extends VoidVisitor.Default {
     36
     37        static private class AugAssignRemovalVisitor extends VoidVisitor.Default {
    4238               
    4339                public void visitLeave(AssignNode node) {
     
    4541                }
    4642
    47                 public void visitLeave(LocalVarDeclNode node) {
    48                         if(Accessors.hasInitializationAssign(node)) {
    49                                 XFormAugAssign(node, Accessors.identifier(node), Accessors.rhs(node));
    50                         }
    51                 }
     43                // NOTE:  This transformation is valid only if lhs is not side-effecting.
     44                private void XFormAugAssign(ASTNode node, ASTNode lhs, ASTNode rhs) {
     45                        Token token = node.getToken();
     46                        if(isAugmentedAssignment(token)) {
     47                                LextantToken binaryOperatorToken = includedOperatorToken(token);
     48                                BinaryOperatorNode binaryOperatorNode = Generators.makeBinaryOperatorNode(lhs.deepCopy(), rhs, binaryOperatorToken);
    5249                               
    53                 private void XFormAugAssign(ASTNode node, ASTNode lhs, ASTNode rhs) {
    54                         if(isAugAssignLextant(node.getToken())) {
    55                                
    56                                 Lextant binaryOperatorLextant = getMappedLextant(node.getToken());
    57                                 String lexeme = binaryOperatorLextant.getPrimaryLexeme();
    58                                
    59                                 LextantToken binaryOperatorToken = LextantToken.make(node.getToken().getLocation(), lexeme, binaryOperatorLextant);
    60                                
    61                                 BinaryOperatorNode binaryOperatorNode = Generators.makeBinaryOperatorNode(lhs, rhs, binaryOperatorToken);
    62                                
    63                                 LextantToken assign = LextantToken.make(node.getToken().getLocation(),
    64                                                                                                                 Lextant.ASSIGN.getPrimaryLexeme(),
    65                                                                                                                 Lextant.ASSIGN);
    66                                 node.setToken(assign);                                 
     50                                changeTokenToAssign(node);                                     
    6751                                node.replaceChild(rhs, binaryOperatorNode);     
    6852                        }
    6953                }
    70                
    71                 private boolean isAugAssignLextant(Token token) {
    72                         for (Lextant key : AugAssignMap.keySet()) {
    73                                 if (token.isLextant(key)) {
    74                                         return true;
    75                                 }
    76                         }
    77                         return false;
     54
     55                private void changeTokenToAssign(ASTNode node) {
     56                        Token token = node.getToken();
     57                        LextantToken assign = makeLextantToken(token.getLocation(), Lextant.ASSIGN);
     58                        node.setToken(assign);
    7859                }
    7960
    80                 private Lextant getMappedLextant(Token token) {
    81                         for (Lextant key : AugAssignMap.keySet()) {
    82                                 if (token.isLextant(key)) {
    83                                         return AugAssignMap.get(key);
    84                                 }
    85                         }
    86                         throw new RuntimeException();
     61                private LextantToken includedOperatorToken(Token token) {
     62                        TextLocation location = token.getLocation();
     63                        Lextant binaryOperator = getIncludedOperator(token);
     64                       
     65                        return makeLextantToken(location, binaryOperator);
     66                }
     67
     68                private LextantToken makeLextantToken(TextLocation location, Lextant lextant) {
     69                        return LextantToken.make(location,
     70                                                                         lextant.getPrimaryLexeme(),
     71                                                                         lextant);
     72                }
     73               
     74                private boolean isAugmentedAssignment(Token token) {
     75                        return IncludedOperators.containsKey(lextantFor(token));
     76                }
     77               
     78                private Lextant getIncludedOperator(Token token) {
     79                        Lextant result = IncludedOperators.get(lextantFor(token));
     80                        assert result != null;
     81                        return result;
     82                }
     83
     84                private Lextant lextantFor(Token token) {
     85                        assert token instanceof LextantToken;
     86                        return ((LextantToken)token).getLextant();
    8787                }               
    88                
     88
     89// a more general approach, if ever there is an operator that is not based on a lextant:
     90//              private Lextant lextantFor2(Token token) {
     91//                      if (token instanceof LextantToken) {
     92//                              return ((LextantToken)token).getLextant();
     93//                      }
     94//                      else {
     95//                              return Lextant.NULL_LEXTANT;
     96//                      }
     97//              }               
    8998        }
    9099}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r3098 r3115  
    2020import pabloS.tokens.Token;
    2121import toolchain.pabloB.ast.Generators;
    22 import toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
     22import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    2323import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    2424import toolchain.pabloB.symbols.CarryInfoSetSymbol;
     
    4141
    4242       
    43         private AbstractCarrySetBuiltins2Lang carrySet2Lang;
     43        private CarrySetEncoder carrySet2Lang;
    4444       
    4545        /*
     
    5050         */
    5151 
    52     public PabloS2PabloBXFormer(toolchain.pabloB.symbols.SymbolTable pabloSSymbolTable, AbstractCarrySetBuiltins2Lang carrySet2Lang) {
     52    public PabloS2PabloBXFormer(toolchain.pabloB.symbols.SymbolTable pabloSSymbolTable, CarrySetEncoder carrySet2Lang) {
    5353        this.decoratedASTTree = null;
    5454        this.optDecoratedASTTree = null;
     
    125125                                               
    126126                                                        FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    127                                                                 new String [] {AbstractCarrySetBuiltins2Lang.CARRYSETBASENAME,
     127                                                                new String [] {CarrySetEncoder.CARRYSETBASENAME,
    128128                                                                                                carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
    129129                                                                                                locationToken,
     
    131131                                               
    132132                                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    133                                                                         new String [] {AbstractCarrySetBuiltins2Lang.CARRYSETBASENAME,
     133                                                                        new String [] {CarrySetEncoder.CARRYSETBASENAME,
    134134                                                                                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
    135135                                                                                                        locationToken,
     
    137137                                                       
    138138                                                        FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    139                                                                         new String [] {AbstractCarrySetBuiltins2Lang.CARRYSETBASENAME,
     139                                                                        new String [] {CarrySetEncoder.CARRYSETBASENAME,
    140140                                                                                                        carrySet2Lang.getCode(CarrySetBuiltins.SETCARRY)},
    141141                                                                                                        locationToken,
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/SurroundAssert0sWithIfs.java

    r3102 r3115  
    1212import toolchain.pabloS.ast.Accessors;
    1313import toolchain.pabloS.ast.Generators;
    14 import toolchain.pabloS.lang.AbstractPabloSBuiltins2Lang;
     14import toolchain.pabloS.lang.BuiltinEncoder;
    1515import toolchain.pabloS.lang.PabloSBuiltins;
    1616import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    1717
    18 public class AssertZeroXFormer {
    19         private ASTNode ASTree;
    20         private AbstractPabloSBuiltins2Lang builtins2Lang;
     18// ugh!  do pabloB programmers have to use a different arg order than pabloS??
     19//
     20//
     21// assert_0(errorStream, errorMsg) ->
     22//
     23// if(errorStream) {
     24//    encoded_assert_0(errorMsg, errorStream)
     25// }
     26//
     27// also, what is the encoded assert0 ?  If the if(errorStream) is done, then
     28// is it simply an "issue error" call?
     29//
     30public class SurroundAssert0sWithIfs {
     31        static public ASTNode apply(ASTNode ASTree, BuiltinEncoder encoder) {
     32                XFormer xformer = new XFormer(encoder);
     33                ASTree.accept(xformer);
     34                return ASTree;                          // root ASTree does not change
     35        } 
     36                               
     37        static private class XFormer extends VoidVisitor.Default {
     38                private final BuiltinEncoder encoder;
     39                private XFormer(BuiltinEncoder encoder) {
     40                        this.encoder = encoder;
     41                }
    2142
    22         public AssertZeroXFormer(ASTNode ASTree, AbstractPabloSBuiltins2Lang builtins2Lang) {
    23                 this.ASTree = ASTree;
    24                 this.builtins2Lang = builtins2Lang;
    25         }
    26        
    27         public ASTNode XForm() {
    28                 XFormer XFormer = new XFormer();
    29                 ASTree.accept(XFormer);
    30                 return ASTree;
    31         }
    32 
    33 //      class AssertCompiler(ast.NodeXFormer):
    34 //              def __init__(self):
    35 //                          self.assert_routine = ast.parse(error_routine).body[0].value
    36 //                        def xfrm(self, t):
    37 //                          return self.generic_visit(t)
    38 //                        def visit_Expr(self, node):
    39 //                          if isinstance(node.value, ast.Call):
    40 //                              if is_BuiltIn_Call(node.value, "assert_0", 2):
    41 //                                      err_stream = node.value.args[0]
    42 //                                      err_code = node.value.args[1]
    43 //                                      return ast.If(mkCall('bitblock::any', [err_stream]),
    44 //                                                    [ast.Expr(mkCall(self.assert_routine, [err_code, err_stream]))],
    45 //                                                    [])
    46 //                              else: return node
    47 //                          else: return node
    48                                
    49         private class XFormer extends VoidVisitor.Default {
    50                                
    51                 public XFormer () {}
    5243                               
    5344                public void visitEnter(FuncCallNode node) {
    5445                       
    55                         if (PabloSBuiltinsUtil.isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ASSERTZERO.pabloSName(), PabloSBuiltins.ASSERTZERO.argCount())) {
    56                                
     46                        if (isAssertZeroCall(node)) {
     47
     48                                // should this be exception?  Does grammar prevent programmer from doing this?
     49                                // i.e. are function calls allowed at the non-statement level?
    5750                                assert (node.getParent() instanceof BlockStmtNode);
    5851
    59                                 ASTNode errorStream = Accessors.funcCallArgsListNode(node).child(0);
    60                                 ASTNode errorCode = Accessors.funcCallArgsListNode(node).child(1);
     52                                ASTNode errorStream = Accessors.funcCallArg(node, 0);
     53                                ASTNode errorMsg    = Accessors.funcCallArg(node, 1);
    6154                               
    62                                 assert errorCode instanceof StringConstantNode;
     55                                // should this be exception?  Does grammar or typechecking prevent programmer from doing this?
     56                                assert errorMsg instanceof StringConstantNode;
    6357                                                               
    64                                 ASTNode assert0FuncCallNode
    65                                                 = Generators.makeFuncCallNode(builtins2Lang.getCode(PabloSBuiltins.ASSERTZERO),
    66                                                                                                                                 node.getToken(),                               
    67                                                                                                                                 new ASTNode [] {errorCode.deepCopy(), errorStream.deepCopy()});
     58                                ASTNode assert0Call
     59                                                = Generators.makeFuncCallNode(encoder.getCode(PabloSBuiltins.ASSERT_ZERO),
     60                                                                                                          node.getToken(),                             
     61                                                                                                          errorMsg,
     62                                                                                                          errorStream);         // note switched arguments
    6863                               
    69                                
    70                                 BlockStmtNode blockStmt = Generators.makeBlockStmtNode(node.getToken());
    71                                 blockStmt.appendChild(assert0FuncCallNode);
    72                                
    73                                 IfStmtNode ifStmtNode = Generators.makeIfStmtNode(node.getToken(),
     64                                BlockStmtNode blockStmt = Generators.makeBlockStmtNode(node.getToken(), assert0Call);
     65                                IfStmtNode ifStmt       = Generators.makeIfStmtNode(node.getToken(),
    7466                                                                                                                                        errorStream.deepCopy(),
    7567                                                                                                                                        blockStmt);
    7668                               
    77                                 node.updateSelf(ifStmtNode);
     69                                node.updateSelf(ifStmt);
    7870                        }       
     71                }
     72
     73                private boolean isAssertZeroCall(FuncCallNode node) {
     74                        return PabloSBuiltinsUtil.isCall(node,
     75                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     76                                        PabloSBuiltins.ASSERT_ZERO.pabloSName(),
     77                                        PabloSBuiltins.ASSERT_ZERO.argCount());
    7978                }               
    8079        }       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/AdvanceNCounterVisitor.java

    r3102 r3115  
    55 */
    66
    7 package toolchain.pabloS.semanticAnalyzer.visitors;
     7package toolchain.pabloS.semanticAnalyzer.visitors.carry;
    88
    99import pabloS.ast.*;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryCounterVisitor.java

    r3102 r3115  
    55 */
    66
    7 package toolchain.pabloS.semanticAnalyzer.visitors;
     7package toolchain.pabloS.semanticAnalyzer.visitors.carry;
    88
    99import pabloS.ast.*;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryInfoSetVisitor.java

    r3102 r3115  
    44 * @author Ken Herdy <ksherdy at sfu dot ca>
    55 */
    6 package toolchain.pabloS.semanticAnalyzer.visitors;
     6package toolchain.pabloS.semanticAnalyzer.visitors.carry;
    77
    88import pabloS.ast.*;
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryIntroXFormer.java

    r3102 r3115  
    1 package toolchain.pabloS.semanticAnalyzer.visitors;
     1package toolchain.pabloS.semanticAnalyzer.visitors.carry;
    22
    33import java.util.ArrayList;
     
    77import pabloS.tokens.LextantToken;
    88import pabloS.lexicalAnalyzer.Lextant;
    9 import toolchain.pabloB.lang.carrySet.AbstractCarrySetBuiltins2Lang;
     9import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    1010import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    1111import toolchain.pabloS.ast.Accessors;
    1212import toolchain.pabloS.ast.Generators;
    1313import toolchain.pabloS.lang.*;
    14 /*
    15  * WARNING: Optimizes on final block. Explicit translation to PabloB IDISA constant. Mask
    16  */
    1714
    1815/*
     
    6966               
    7067        private ASTNode ASTTree;       
    71         private AbstractPabloSBuiltins2Lang builtins2Lang;
    72         private AbstractCarrySetBuiltins2Lang carrySet2Lang;
     68        private BuiltinEncoder builtinEncoder;
     69        private CarrySetEncoder carrySetEncoder;
    7370       
    7471        private int carrySetDepth;
    7572        private String carrySetIdentifier;             
    7673       
    77     public CarryIntroXFormer(ASTNode node, AbstractPabloSBuiltins2Lang builtins2Lang, AbstractCarrySetBuiltins2Lang carrySet2Lang) {
     74    public CarryIntroXFormer(ASTNode node, BuiltinEncoder builtinEncoder, CarrySetEncoder carrySetEncoder) {
    7875        this.ASTTree = node;
    79         this.builtins2Lang = builtins2Lang;
    80         this.carrySet2Lang = carrySet2Lang;
     76        this.builtinEncoder  = builtinEncoder;
     77        this.carrySetEncoder = carrySetEncoder;
    8178    }   
    82    
     79
     80
     81    public void XForm(boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
     82        setCarrySetDepth(carrySetDepth);           
     83        setCarrySetIdentifier(CarrySetEncoder.CARRYSET_BASENAME_PREFIX + getCarrySetDepth());
     84       
     85        XFormer visitor = new XFormer();
     86                setFinalBlockMode(finalBlockMode);
     87                visitor.setCiMode(ciMode);
     88                ASTTree.accept(visitor);
     89    }             
     90    public void XForm(boolean finalBlockMode, int carrySetDepth) {
     91        XForm(finalBlockMode, true, carrySetDepth);
     92    }
     93    public void XForm(boolean finalBlockMode, boolean ciMode) {
     94        XForm(finalBlockMode, ciMode, 0);
     95    }                   
    8396    public void XForm(boolean finalBlockMode) {
    84         XForm(finalBlockMode, 0);
     97        XForm(finalBlockMode, true, 0);
    8598    }
    8699   
    87     public void XForm(boolean finalBlockMode, boolean ciMode) {
    88         XForm(finalBlockMode, ciMode, 0);
    89     }
    90        
    91     public void XForm(boolean finalBlockMode, int carrySetDepth) {
    92         setCarrySetDepth(carrySetDepth);           
    93         setCarrySetIdentifier(AbstractCarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
    94 
    95         XFormer visitor = new XFormer();
    96                 visitor.setFinalBlockMode(finalBlockMode);
    97                 ASTTree.accept(visitor);
    98     }                   
    99 
    100     public void XForm(boolean finalBlockMode, boolean ciMode, int carrySetDepth) {
    101         setCarrySetDepth(carrySetDepth);           
    102         setCarrySetIdentifier(AbstractCarrySetBuiltins2Lang.CARRYSET_BASENAME_PREFIX + Integer.toString(getCarrySetDepth()));
    103        
    104         XFormer visitor = new XFormer();
    105                 visitor.setFinalBlockMode(finalBlockMode);
    106                 visitor.setCiMode(ciMode);
    107                 ASTTree.accept(visitor);
    108     }     
    109    
     100    /////////////////////////////////////////////////////////////////
     101    // getters and setters
    110102        private int getCarrySetDepth() {
    111103                return carrySetDepth;
     
    123115                this.carrySetIdentifier = carrySetIdentifier;
    124116        }
    125 
     117       
     118    private Counter carryCount = new Counter(CarrySetBuiltins.GETCARRY);
     119        private Counter advanceNCount = new Counter(CarrySetBuiltins.PENDING64);
     120       
     121        private boolean finalBlockMode;
     122        protected boolean isFinalBlockMode() {
     123                return finalBlockMode;
     124        }
     125
     126        protected void setFinalBlockMode(boolean finalBlockMode) {
     127                this.finalBlockMode = finalBlockMode;
     128        }
     129       
    126130        private class XFormer extends VoidVisitor.Default {
    127131
     
    131135                //private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()};
    132136               
    133                 private boolean finalBlockMode;
    134137                private boolean ciMode;
    135138                //private boolean coMode;
    136139               
    137                 private int currentCarry;
    138                 private int currentAdvN;
    139140                //private int lastStmtCarries;
    140141       
    141142                XFormer(/*boolean finalBlockModeboolean ciMode , boolean coMode */) {
    142143                       
    143                         finalBlockMode = false;                                                 
     144                        setFinalBlockMode(false);                                                       
    144145                        ciMode = true;                 
    145146                        // this.coMode = coMode;
    146147                       
    147                         currentCarry = 0;
    148                         currentAdvN = 0;
     148                        carryCount.reset();
     149                        advanceNCount.reset();
    149150                        //this.lastStmtCarries = 0;                                     
    150151                }
    151 
    152152                protected boolean isCiMode() {
    153153                        return ciMode;
     
    158158                }
    159159
    160                 protected boolean isFinalBlockMode() {
    161                         return finalBlockMode;
    162                 }
    163 
    164                 protected void setFinalBlockMode(boolean finalBlockMode) {
    165                         this.finalBlockMode = finalBlockMode;
    166                 }
    167                
    168160                // xFormers
    169161               
     
    179171               
    180172                public void visitEnter(FuncDefNode node) {
    181                         this.currentCarry = 0;
    182                         this.currentAdvN = 0;
     173                        carryCount.reset();
     174                        advanceNCount.reset();
    183175                        //this.lastStmtCarries = 0;
    184176                       
     
    190182                               
    191183                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    192                                                 new String [] { getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYADJUST)},
     184                                                new String [] { getCarrySetIdentifier(), carrySetEncoder.getCode(CarrySetBuiltins.CARRYADJUST)},
    193185                                                                                node.getToken(),
    194186                                                                                carry1CountNode);
     
    206198                        FuncCallNode carryDeclareFuncCall
    207199                                                                = (FuncCallNode) Generators.makeFuncCallNode(
    208                                                                         carrySet2Lang.getCode(CarrySetBuiltins.CARRYDECLARE),
     200                                                                        carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE),
    209201                                                                        node.getToken(),
    210202                                                                        new ASTNode [] {carrySetIdentifierNode, carry1CountNode, carryNCountNode});
     
    216208                public void visitLeave(FuncDefNode node) {
    217209                        if(isFinalBlockMode()) {
    218                                 ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(builtins2Lang, node.getToken());
     210                                ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(builtinEncoder, node.getToken());
    219211                                Generators.appendParameter(node, EOFMaskParameter);
    220212                        }
     
    228220               
    229221                public void visitLeave(FuncCallNode node) {
    230                                
    231                         ASTNode replacementNode;
    232                        
    233                         ASTNode carryAtCallOrMask;
    234                         IntegerConstantNode currentCarry = Generators.makeIntegerConstantNode(this.currentCarry, node.getToken());
    235                        
    236                         ASTNode pending64CallOrMask;
    237                         IntegerConstantNode currentAdvN = Generators.makeIntegerConstantNode(this.currentAdvN, node.getToken());
    238 
    239                         //                  if self.carryin == "_ci":
    240                         //              carry_args = [mkCall(self.carryvar.id + "." + 'get_carry_in', [ast.Num(self.current_carry)]), ast.Num(self.current_carry)]
    241                         //              adv_n_args = [mkCall(self.carryvar.id + "." + 'get_pending64', [ast.Num(self.current_adv_n)]), ast.Num(self.current_adv_n)]
    242                         //          else:
    243                         //              carry_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_carry)]
    244                         //              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
    245                        
    246                         if(isCiMode()) {
    247                                 carryAtCallOrMask = Generators.makeFuncCallNode(
    248                                                 new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
    249                                                 node.getToken(),
    250                                                 currentCarry);
    251                                
    252                                 pending64CallOrMask = Generators.makeFuncCallNode(
    253                                                 new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.PENDING64)},
    254                                                 node.getToken(),
    255                                                 currentAdvN);
    256                         } else {
    257                                
    258                                 IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node.getToken());
    259                                 IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, node.getToken());
    260                                
    261                                 carryAtCallOrMask = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
    262                                                 node.getToken(),
    263                                                 fieldWidthNode, zeroConstantNode);
    264                                
    265                                 pending64CallOrMask = carryAtCallOrMask.deepCopy();
    266                         }
    267                                                
    268                         //                  if is_BuiltIn_Call(callnode, 'Advance', 1):         
    269                         //                    #CARRYSET
    270                         //                    rtn = self.carryvar.id + "." + "BitBlock_advance_ci_co"
    271                         //                    c = mkCall(rtn, callnode.args + carry_args)
    272                         //                    self.current_carry += 1
    273                         //                    return c
    274                        
    275                         if (PabloSBuiltinsUtil.isCall(node,
    276                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    277                                         PabloSBuiltins.ADVANCE.pabloSName(),
    278                                         PabloSBuiltins.ADVANCE.argCount())) {           
    279                                
    280                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    281                                
    282                                 replaceFuncCallWithCarryCallNode(node,
    283                                                 getCarrySetIdentifier(),
    284                                                 builtins2Lang.getCode(PabloSBuiltins.ADVANCE),
    285                                                 arguments,
    286                                                 carryAtCallOrMask,
    287                                                 currentCarry);
    288                                
    289                                 this.currentCarry += 1;
    290                         }
    291        
    292                         //      #CARRYSET
    293                         //      rtn = self.carryvar.id + "." + "BitBlock_scanthru_ci_co"
    294                         //      c = mkCall(rtn, callnode.args + carry_args)
    295                         //      self.current_carry += 1
    296                         //      return c                                                       
    297                        
    298                         else if (PabloSBuiltinsUtil.isCall(node,
    299                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    300                                         PabloSBuiltins.SCANTHRU.pabloSName(),
    301                                         PabloSBuiltins.SCANTHRU.argCount())) {
    302                                
    303                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    304                                
    305                                 replaceFuncCallWithCarryCallNode(node,
    306                                                 getCarrySetIdentifier(),
    307                                                 builtins2Lang.getCode(PabloSBuiltins.SCANTHRU),
    308                                                 arguments,
    309                                                 carryAtCallOrMask,
    310                                                 currentCarry);
    311                                 this.currentCarry += 1;
    312                         }
    313                                
    314                         //          elif is_BuiltIn_Call(callnode, 'AdvanceThenScanThru', 2):
    315                         //          #CARRYSET
    316                         //          rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
    317                         //          c = mkCall(rtn, callnode.args + carry_args)
    318                         //          self.current_carry += 1
    319                         //          return c                   
    320                        
    321                         else if (PabloSBuiltinsUtil.isCall(node,
    322                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    323                                         PabloSBuiltins.ADVANCETHENSCANTHRU.pabloSName(),
    324                                         PabloSBuiltins.ADVANCETHENSCANTHRU.argCount())) {
    325                                
    326                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    327                                
    328                                 replaceFuncCallWithCarryCallNode(node,
    329                                                 getCarrySetIdentifier(),
    330                                                 builtins2Lang.getCode(PabloSBuiltins.ADVANCETHENSCANTHRU),
    331                                                 arguments,
    332                                                 carryAtCallOrMask,
    333                                                 currentCarry);
    334                                 this.currentCarry += 1;
    335                         }               
    336        
    337                         //      elif is_BuiltIn_Call(callnode, 'SpanUpTo', 2):
    338                         //      #CARRYSET
    339                         //      rtn = self.carryvar.id + "." + "BitBlock_span_upto"
    340                         //      c = mkCall(rtn, callnode.args + carry_args)
    341                         //      self.current_carry += 1
    342                         //      return c
    343                        
    344                         else if (PabloSBuiltinsUtil.isCall(node,
    345                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    346                                         PabloSBuiltins.SPANUPTO.pabloSName(),
    347                                         PabloSBuiltins.SPANUPTO.argCount())) {
    348                                
    349                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    350                                
    351                                 replaceFuncCallWithCarryCallNode(node,
    352                                                 getCarrySetIdentifier(),
    353                                                 builtins2Lang.getCode(PabloSBuiltins.SPANUPTO),
    354                                                 arguments,
    355                                                 carryAtCallOrMask,
    356                                                 currentCarry);                         
    357                                 this.currentCarry += 1;
    358                         }               
    359                        
    360                         //              elif is_BuiltIn_Call(callnode, 'AdvanceThenScanTo', 2):
    361                         //      #CARRYSET
    362                         //      rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
    363                         //      if self.carryout == "":  scanclass = mkCall('simd_andc', [ast.Name('EOF_mask', ast.Load()), callnode.args[1]])
    364                         //      else: scanclass = mkCall('simd_not', [callnode.args[1]])
    365                         //      c = mkCall(rtn, [callnode.args[0], scanclass] + carry_args)
    366                         //      self.current_carry += 1
    367                         //          return c                   
    368                        
    369                         else if (PabloSBuiltinsUtil.isCall(node,
    370                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    371                                                 PabloSBuiltins.ADVANCETHENSCANTO.pabloSName(),
    372                                                 PabloSBuiltins.ADVANCETHENSCANTO.argCount())) {
    373                                
    374                                 ASTNode argNode = Accessors.funcCallArg(node, 1);
    375                                 if(isFinalBlockMode()) {
    376                                         replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);
    377                                 } else {
    378                                         replacementNode = Generators.makeSIMDNotFuncCall(argNode, builtins2Lang);
     222                        Context context = new Context(ciMode, finalBlockMode, builtinEncoder, carrySetEncoder, carrySetIdentifier);
     223                        boolean translated = false;
     224                        for(BuiltinTranslatorImp translator: BuiltinTranslatorImp.values()) {
     225                                if (translator.isCall(node)) {
     226                                        translator.action(node, carryCount, advanceNCount, context);
     227                                        translated = true;
     228                                        break;
    379229                                }
    380                                 Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);
    381                                
    382                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    383                                
    384                                 replaceFuncCallWithCarryCallNode(node,
    385                                                 getCarrySetIdentifier(),
    386                                                 builtins2Lang.getCode(PabloSBuiltins.ADVANCETHENSCANTHRU),
    387                                                 arguments,
    388                                                 carryAtCallOrMask,
    389                                                 currentCarry);
    390                                 this.currentCarry += 1;
    391                         }               
    392                        
    393                         //          elif is_BuiltIn_Call(callnode, 'InclusiveSpan', 2):
    394                         //            #CARRYSET
    395                         //      #      rtn = self.carryvar.id + "." + "BitBlock_span_upto"
    396                         //      #      c = mkCall('simd_or', [mkCall(rtn, callnode.args + carry_args), callnode.args[1]])
    397                         //            rtn = self.carryvar.id + "." + "BitBlock_inclusive_span"
    398                         //            c = mkCall(rtn, callnode.args + carry_args)
    399                         //            self.current_carry += 1
    400                         //            return c
    401        
    402                         else if (PabloSBuiltinsUtil.isCall(node,
    403                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    404                                                 PabloSBuiltins.INCLUSIVESPAN.pabloSName(),
    405                                                 PabloSBuiltins.INCLUSIVESPAN.argCount())) {
    406                                
    407                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    408                                 replaceFuncCallWithCarryCallNode(node,
    409                                                 getCarrySetIdentifier(),
    410                                                 builtins2Lang.getCode(PabloSBuiltins.INCLUSIVESPAN),
    411                                                 arguments,
    412                                                 carryAtCallOrMask,
    413                                                 currentCarry);
    414                                 this.currentCarry += 1;
    415                         }                               
    416                        
    417                         //          elif is_BuiltIn_Call(callnode, 'ExclusiveSpan', 2):
    418                         //            #CARRYSET
    419                         //      #      rtn = self.carryvar.id + "." + "BitBlock_span_upto"
    420                         //      #      c = mkCall('simd_andc', [mkCall(rtn, callnode.args + carry_args), callnode.args[0]])
    421                         //            rtn = self.carryvar.id + "." + "BitBlock_exclusive_span"
    422                         //            c = mkCall(rtn, callnode.args + carry_args)
    423                         //            self.current_carry += 1
    424                         //            return c
    425        
    426                         else if (PabloSBuiltinsUtil.isCall(node,
    427                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    428                                         PabloSBuiltins.EXCLUSIVESPAN.pabloSName(),
    429                                         PabloSBuiltins.EXCLUSIVESPAN.argCount())) {
    430                                
    431                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    432                                 replaceFuncCallWithCarryCallNode(node,
    433                                                 getCarrySetIdentifier(),
    434                                                 builtins2Lang.getCode(PabloSBuiltins.EXCLUSIVESPAN),
    435                                                 arguments,
    436                                                 carryAtCallOrMask,
    437                                                 currentCarry);
    438                                 this.currentCarry += 1;
    439                         }                                               
    440                        
    441                         //          elif is_BuiltIn_Call(callnode, 'ScanTo', 2):
    442                         //            # Modified Oct. 9, 2011 to directly use BitBlock_scanthru, eliminating duplication
    443                         //            # in having a separate BitBlock_scanto routine.
    444                         //            #CARRYSET
    445                         //            rtn = self.carryvar.id + "." + "BitBlock_scanthru_ci_co"
    446                         //            if self.carryout == "":  scanclass = mkCall('simd_andc', [ast.Name('EOF_mask', ast.Load()), callnode.args[1]])
    447                         //            else: scanclass = mkCall('simd_not', [callnode.args[1]])
    448                         //            c = mkCall(rtn, [callnode.args[0], scanclass] + carry_args)
    449                         //            self.current_carry += 1
    450                         //            return c
    451        
    452                         else if (PabloSBuiltinsUtil.isCall(node,
    453                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    454                                                 PabloSBuiltins.SCANTO.pabloSName(),
    455                                                 PabloSBuiltins.SCANTO.argCount())) {
    456                                
    457                                 ASTNode argNode = Accessors.funcCallArg(node, 1);
    458                                 if(isFinalBlockMode()) {
    459                                         replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);                                                                   
    460                                 } else {
    461                                         replacementNode = Generators.makeSIMDNotFuncCall(argNode, builtins2Lang);
    462                                 }
    463                                 Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);
    464                                
    465                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    466                                
    467                                 replaceFuncCallWithCarryCallNode(node,
    468                                                 getCarrySetIdentifier(),
    469                                                 builtins2Lang.getCode(PabloSBuiltins.SCANTHRU),
    470                                                 arguments,
    471                                                 carryAtCallOrMask,
    472                                                 currentCarry);
    473                                 this.currentCarry += 1;
    474                         }                                                               
    475                        
    476                         //          elif is_BuiltIn_Call(callnode, 'ScanToFirst', 1):
    477                         //            #CARRYSET
    478                         //            rtn = self.carryvar.id + "." + "BitBlock_scantofirst"
    479                         //            #if self.carryout == "":  carry_args = [ast.Name('EOF_mask', ast.Load())] + carry_args
    480                         //            c = mkCall(rtn, callnode.args + carry_args)
    481                         //            self.current_carry += 1
    482                         //            return c
    483 
    484                         else if (PabloSBuiltinsUtil.isCall(node,
    485                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    486                                                 PabloSBuiltins.SCANTOFIRST.pabloSName(),
    487                                                 PabloSBuiltins.SCANTOFIRST.argCount())) {
    488 
    489                                 // TODO - verify
    490                                 /*
    491                                 ASTNode argNode = Accessors.funcCallArg(node, 0);
    492                                 if(isFinalBlockMode()) {
    493                                         replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);                                                                   
    494                                 } else {
    495                                         replacementNode = Generators.makeSIMDNotFuncCall(argNode, builtins2Lang);
    496                                 }
    497                                 Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);
    498                                 */
    499                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    500                                
    501                                 replaceFuncCallWithCarryCallNode(node,
    502                                                 getCarrySetIdentifier(),
    503                                                 builtins2Lang.getCode(PabloSBuiltins.SCANTOFIRST),
    504                                                 arguments,
    505                                                 carryAtCallOrMask,
    506                                                 currentCarry);
    507                                 this.currentCarry += 1;
    508                         }                                                                               
    509        
    510                         //          elif is_BuiltIn_Call(callnode, 'Advance32', 1):     
    511                         //            #CARRYSET
    512                         //            rtn = self.carryvar.id + "." + "BitBlock_advance_n_<32>"
    513                         //            c = mkCall(rtn, callnode.args + adv_n_args)
    514                         //            self.current_adv_n += 1
    515                         //            return c
    516                         else if (PabloSBuiltinsUtil.isCall(node,
    517                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    518                                                 PabloSBuiltins.ADVANCE32.pabloSName(),
    519                                                 PabloSBuiltins.ADVANCE32.argCount())) {
    520                                 // TODO - verify implementation.
    521                                
    522                                 //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    523                                
    524                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    525                                
    526                                 replaceFuncCallWithCarryCallNode(node,
    527                                                 getCarrySetIdentifier(),
    528                                                 builtins2Lang.getCode(PabloSBuiltins.ADVANCE32),
    529                                                 arguments,
    530                                                 pending64CallOrMask,
    531                                                 currentAdvN);
    532                                 this.currentAdvN += 1;
    533                         }                       
    534                        
    535                         //          if is_BuiltIn_Call(callnode, 'Advance', 2):         
    536                         //            #CARRYSET
    537                         //            rtn = self.carryvar.id + "." + "BitBlock_advance_n_<%i>" % callnode.args[1].n
    538                         //            c = mkCall(rtn, [callnode.args[0]] + adv_n_args)
    539                         //            self.current_adv_n += 1
    540                         //            return c         
    541                         else if (PabloSBuiltinsUtil.isCall(node,
    542                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    543                                                 PabloSBuiltins.ADVANCEN.pabloSName(),
    544                                                 PabloSBuiltins.ADVANCEN.argCount())) {                                 
    545                                
    546                                 ASTNode formatValue = Accessors.funcCallArg(node, 1);
    547                                 String value = Accessors.integerConstantLexeme((IntegerConstantNode)formatValue);
    548                                
    549                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    550                                
    551                                 String formattedAdvanceN = String.format(builtins2Lang.getCode(PabloSBuiltins.ADVANCEN), value);
    552                                
    553                                 replaceFuncCallWithCarryCallNode(node,
    554                                                 getCarrySetIdentifier(),
    555                                                 formattedAdvanceN,
    556                                                 arguments.subList(0, arguments.size()-1),
    557                                                 pending64CallOrMask,
    558                                                 currentAdvN);           
    559                                 this.currentAdvN += 1;                 
    560                         }                                       
    561                
    562                         else if (PabloSBuiltinsUtil.isCall(node,
    563                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    564                                                 PabloSBuiltins.ATEOF.pabloSName(),
    565                                                 PabloSBuiltins.ATEOF.argCount())) {
    566                                  
    567                                 if(isFinalBlockMode()) {
    568                                         ASTNode argNode = Accessors.funcCallArg(node, 0);
    569                                         replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    570                                 } else {                               
    571                                        
    572                                         IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node.getToken());
    573                                         IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, node.getToken());
    574                                        
    575                                         replacementNode = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
    576                                                                                 node.getToken(),
    577                                                                                 fieldWidthNode, zeroConstantNode);                                     
    578                                 }
    579                                 node.updateSelf(replacementNode);
    580                         }                                       
    581        
    582                         //          elif is_BuiltIn_Call(callnode, 'inFile', 1):
    583                         //            if self.carryout != "": 
    584                         //              # Non final block: inFile(x) = x.
    585                         //              return callnode.args[0]
    586                         //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    587                         else if (PabloSBuiltinsUtil.isCall(node,
    588                                                 PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    589                                                 PabloSBuiltins.INFILE.pabloSName(),
    590                                                 PabloSBuiltins.INFILE.argCount())) {
    591                                
    592                                 if(isFinalBlockMode()) {                                       
    593                                         ASTNode argNode = Accessors.funcCallArg(node, 0);
    594                                         replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, builtins2Lang);
    595                                 } else {
    596                                         replacementNode = Accessors.funcCallArg(node,0);
    597                                 }
    598                                 node.updateSelf(replacementNode);
    599                         }                       
    600                        
    601                         //                      Deprecated - New bitblock iterators replace StreamScan.
    602                         //                     
    603                         //              elif is_BuiltIn_Call(callnode, 'StreamScan', 2):
    604                         //                      rtn = "StreamScan"           
    605                         //                      c = mkCall(rtn, [ast.Name('(ScanBlock *) &' + callnode.args[0].id, ast.Load()),
    606                         //                                                 ast.Name('sizeof(BitBlock)/sizeof(ScanBlock)', ast.Load()),
    607                         //                                                 ast.Name(callnode.args[1].id, ast.Load())])
    608                         //              return c                                       
    609                         //
    610                         //                      else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.STREAMSCAN.pabloName(), NoCarry.STREAMSCAN.argCount())) {
    611                         //                              replacementNode = Generators.makeFuncCallNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
    612                         //                             
    613                         //                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.FuncCallArg(node, 0)), node.getToken());
    614                         //                              ASTNode arg1 = Generators.makeIdentifierNode("sizeof(BitBlock)/sizeof(ScanBlock)", node.getToken());
    615                         //                              ASTNode arg2 = Accessors.FuncCallArg(node, 1);
    616                         //                             
    617                         //                              replacementNode.appendChild(arg0);
    618                         //                              replacementNode.appendChild(arg1);
    619                         //                              replacementNode.appendChild(arg2);
    620                         //                      }
    621                                                
    622                         //                  else:
    623                         //                    #dump_Call(callnode)
    624                         //                    return callnode
    625                         else if (PabloSBuiltinsUtil.isCall(node,
    626                                         PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    627                                         PabloSBuiltins.MASK.pabloSName(),
    628                                         PabloSBuiltins.MASK.argCount())) {
    629                                
    630                                         IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(0, node.getToken());
    631                                         IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, node.getToken());
    632                                        
    633                                         replacementNode = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
    634                                                 node.getToken(),
    635                                                 fieldWidthNode, zeroConstantNode);
    636                                        
    637                                         node.updateSelf(replacementNode);
    638                         }
    639                         else {
     230                        }
     231                       
     232                        if(!translated) {
    640233                                // do nothing // TODO - allow calls to pass ?
    641                         }
    642                        
    643                 }
     234                        }                                                                                                                       
     235                }
     236               
     237                //              if self.carryin == "_ci":
     238                //              carry_args = [mkCall(self.carryvar.id + "." + 'get_carry_in', [ast.Num(self.current_carry)]), ast.Num(self.current_carry)]
     239                //              adv_n_args = [mkCall(self.carryvar.id + "." + 'get_pending64', [ast.Num(self.current_adv_n)]), ast.Num(self.current_adv_n)]
     240                //          else:
     241                //              carry_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_carry)]
     242                //              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
     243               
     244               
    644245               
    645246                //      def visit_If(self, ifNode):
     
    658259                        assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) illegal within an if statement \n";
    659260                       
    660                         int carryBase = this.currentCarry;
     261                        int carryBase = carryCount.value();
    661262                        int carryCount = (new CarryCounterVisitor(node)).carry1Count();
    662263                                               
     
    678279                        // else part, append CarryDequeueEnqueue call
    679280                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    680                                                                 new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     281                                                                new String [] {getCarrySetIdentifier(), carrySetEncoder.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
    681282                                                                node.getToken(),
    682283                                                                carryBaseNode, carryCountNode);
     
    705306                        if(isFinalBlockMode()) {
    706307                                ASTNode whileConditionNode = Accessors.whileTest(node);
    707                                 ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(whileConditionNode, builtins2Lang);
     308                                ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(whileConditionNode, builtinEncoder);
    708309                                node.replaceChild(whileConditionNode, replacementNode);                                 
    709310                        }
    710311                       
    711                         int carryBase           = this.currentCarry;
     312                        int carryBase           = carryCount.value();
    712313                        int carry1Count         = (new CarryCounterVisitor(node)).carry1Count();                       
    713314                        int carryNCount         = (new CarryCounterVisitor(node)).carryNCount();
     
    744345                       
    745346                        WhileStmtNode innerWhile = node.deepCopy();
    746                         CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtins2Lang, carrySet2Lang);
    747                         xFormer.XForm(finalBlockMode, false, (getCarrySetDepth() + 1));
     347                        CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtinEncoder, carrySetEncoder);
     348                        xFormer.XForm(isFinalBlockMode(), false, (getCarrySetDepth() + 1));     
    748349                       
    749350                        IdentifierNode localCarrySetIdentifierNode = Generators.makeIdentifierNode(
     
    753354                        /*
    754355                        CompoundIdentifierNode localCarrySetArrayIdentifierNode = Generators.makeCompoundIdentifierNode(
    755                                         new String [] {xFormer.getCarrySetIdentifier(), CarrySetBuiltins2Lang.CARRYQARRAYNAME},
     356                                        new String [] {xFormer.context.getCarrySetIdentifier(), CarrySetBuiltins2Lang.CARRYQARRAYNAME},
    756357                                        node.getToken());
    757358                        */
     
    759360                        FuncCallNode carryDeclareFuncCall
    760361                                                                = (FuncCallNode) Generators.makeFuncCallNode(
    761                                                                         carrySet2Lang.getCode(CarrySetBuiltins.CARRYDECLARE),
     362                                                                        carrySetEncoder.getCode(CarrySetBuiltins.CARRYDECLARE),
    762363                                                                        node.getToken(),
    763364                                                                        localCarrySetIdentifierNode, carry1CountNode, carryNCountNode);
     
    766367
    767368                        FuncCallNode carryLocalCombine = (FuncCallNode) Generators.makeFuncCallNode(
    768                                         carrySet2Lang.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE),
     369                                        carrySetEncoder.getCode(CarrySetBuiltins.LOCALCARRYCOMBINE),
    769370                                        node.getToken(),
    770371                                        carrySetIdentifierNode, localCarrySetIdentifierNode, carryBaseNode, carry1CountNode);
     
    794395                       
    795396                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    796                                         new String [] {carrySetIdentifier, carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     397                                        new String [] {carrySetIdentifier, carrySetEncoder.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
    797398                                                                        node.getToken(),
    798399                                                                        carryBaseNode, carry1CountNode);
     
    813414                // Helpers
    814415               
    815                 /*
    816                  * Makes CarrySet builtin call. Advance(X) => carry_set_n.Advance(
    817                  */
    818                 private void replaceFuncCallWithCarryCallNode(FuncCallNode node,
    819                                 String carryIdentifier, String carryBuiltin,
    820                                 List<ASTNode> arguments,
    821                                 ASTNode call, IntegerConstantNode carry) {
    822                                
    823                                 FuncCallNode replacementNode;
    824        
    825                         List<ASTNode> args = new ArrayList<ASTNode>();
    826                                                                        
    827                         for(ASTNode arg : arguments) {
    828                                 args.add(arg);
    829                         }       
    830                         args.add(call);
    831                         args.add(carry);
    832                        
    833                         replacementNode = Generators.makeFuncCallNode(
    834                                         new String [] {carryIdentifier, carryBuiltin},
    835                                         node.getToken(),
    836                                         args);
    837                        
    838                         node.updateSelf(replacementNode);
    839                 }
     416
    840417               
    841418                /*
     
    852429                       
    853430                        FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
    854                                         new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYRANGE)},
    855                                                                         lhs.getToken(),
     431                                        new String [] {getCarrySetIdentifier(), carrySetEncoder.getCode(CarrySetBuiltins.CARRYRANGE)},
     432                                                                        lhs,
    856433                                                                        carryBaseNode, carryCountNode);
    857434                       
     
    861438                }
    862439        }
     440        /*
     441         * Makes CarrySet builtin call.
     442         * e.g. Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carry
     443         */
     444        static void replaceFuncCallWithCarryCallNode(FuncCallNode node,
     445                        String carryIdentifier, String carryBuiltin,
     446                        List<ASTNode> arguments,
     447                        ASTNode call, IntegerConstantNode carry) {
     448
     449                List<ASTNode> args = new ArrayList<ASTNode>(arguments);
     450                args.add(call);
     451                args.add(carry);
     452               
     453                FuncCallNode replacementNode = Generators.makeFuncCallNode(
     454                                new String [] {carryIdentifier, carryBuiltin},
     455                                node,
     456                                args);
     457               
     458                node.updateSelf(replacementNode);
     459        }
    863460}       
Note: See TracChangeset for help on using the changeset viewer.