Changeset 3208 for proto/pabloj/trunk


Ignore:
Timestamp:
May 28, 2013, 3:16:53 PM (6 years ago)
Author:
ksherdy
Message:

Moved -a bit block alignment and -d dump statements visitors from PabloS to PabloB. Updated Accessors 'name()' rountine in PabloB.Accessors. A similar solution is needed in PabloS.Accessors.

Location:
proto/pabloj/trunk/src
Files:
4 added
1 deleted
7 edited
1 copied
3 moved

Legend:

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

    r3192 r3208  
    2626import toolchain.pabloB.codeGenerator.visitors.AbstractUnparser;
    2727import toolchain.pabloB.codeGenerator.visitors.Unparser;
    28 import toolchain.pabloB.lang.carrySet.CarrySetBuiltins2C;
    29 import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    30 import toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
     28
    3129import toolchain.pabloB.symbols.SymbolTable;
    32 import toolchain.pabloS.lang.*;
    33 import toolchain.pabloS.semanticAnalyzer.Transformer;
     30//import toolchain.pabloS.lang.*;
    3431import toolchain.pabloS.semanticAnalyzer.visitors.PabloS2PabloBXFormer;
    3532import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryInfoSetVisitor;
     
    5855               
    5956                // Transformation configurations to support multiple backends
    60                 BuiltinEncoder builtins2Lang            = null;
    61                 CarrySetEncoder carrySet2Lang           = null;
     57                toolchain.pabloS.lang.BuiltinEncoder pabloSbuiltins2Lang  = null;
     58                toolchain.pabloB.lang.BuiltinEncoder pabloBBuiltins2Lang  = null;
    6259                AbstractUnparser unparser                       = null;
    6360               
     61                toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySet2Lang = null;
     62                               
    6463                if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
    65             builtins2Lang = new PabloSBuiltins2C();
    66             carrySet2Lang = new CarrySetBuiltins2C();
     64            pabloSbuiltins2Lang = new toolchain.pabloS.lang.PabloSBuiltins2C();
     65            pabloBBuiltins2Lang = new toolchain.pabloB.lang.PabloBBuiltins2C();
     66            carrySet2Lang = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2C();
    6767                        unparser      = new Unparser(new IDISABuiltin2C());                     
    68                        
    6968                } else if(applicationConfiguration.targetLang.contentEquals(Configuration.CPPLANG)) {
    70                         builtins2Lang = new PabloSBuiltins2CPP();
    71                         carrySet2Lang = new CarrySetBuiltins2CPP();
     69                        pabloSbuiltins2Lang = new toolchain.pabloS.lang.PabloSBuiltins2CPP();
     70                        pabloBBuiltins2Lang = new toolchain.pabloB.lang.PabloBBuiltins2CPP();
     71                        carrySet2Lang = new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP();
    7272                        unparser          = new Unparser(new IDISABuiltin2CPP());
    7373                } /*else if(applicationConfiguration.targetLang.contentEquals(Configuration.LLVM)) {  // default C++
     
    8181               
    8282                if(applicationConfiguration.isPabloSSource) {
    83                         pabloS.ast.ASTNode pabloAST = ASTGenerator.buildPabloSAST(applicationConfiguration.pabloSFile);
     83                        pabloS.ast.ASTNode pabloSAST = ASTGenerator.buildPabloSAST(applicationConfiguration.pabloSFile);
    8484       
    8585                        //pabloB.ast.ASTNode syntaxTree = Parser.parsePabloB(applicationConfiguration.pabloBFile);
     
    8787                        // Gather carry information set
    8888                        // TODO - refactor - carry_count, advance_n_count, add symbol table to root node
    89                         CarryInfoSetVisitor carryInfoSetVisitor = new CarryInfoSetVisitor(pabloAST, symbolTable); 
     89                        CarryInfoSetVisitor carryInfoSetVisitor = new CarryInfoSetVisitor(pabloSAST, symbolTable); 
    9090                        carryInfoSetVisitor.visit();
    9191                       
    9292                        // Replace PabloS builtins and Carry Set builtins with target language strings.
    93                         Transformer pabloSXFormer = new Transformer(pabloAST);
    94                         pabloSXFormer.setBuiltins2Lang(builtins2Lang);
     93                        toolchain.pabloS.semanticAnalyzer.Transformer pabloSXFormer = new toolchain.pabloS.semanticAnalyzer.Transformer(pabloSAST);
     94                        pabloSXFormer.setBuiltins2Lang(pabloSbuiltins2Lang);
    9595                        pabloSXFormer.setCarrySet2Lang(carrySet2Lang);
    96        
     96
    9797                        // Transform PabloS global functions in non-final block mode
    9898                        pabloSXFormer.setFinalBlockMode(false);
     
    108108               
    109109                } else if (applicationConfiguration.isPabloBSource) {
    110                        
     110
    111111                        pabloBAST = ASTGenerator.buildPabloBAST(applicationConfiguration.pabloBFile);
     112
    112113                }
    113                
    114                 // PabloB AST Transforms
    115                
     114       
     115        // PabloB AST Transforms
     116        toolchain.pabloB.semanticAnalyzer.Transformer pabloBXFormer = new toolchain.pabloB.semanticAnalyzer.Transformer(pabloBAST);
     117        pabloBXFormer.setBuiltins2Lang(pabloBBuiltins2Lang);
     118       
     119        if(applicationConfiguration.addAssertBitBlockAlignStmts) {
     120            pabloBXFormer.setAddAssertBitBlockAlignStmts(true);
     121        }
     122       
     123        if(applicationConfiguration.addDumpStmts) {
     124            pabloBXFormer.setAddDumpStmts(true);
     125        } 
     126        pabloBAST = pabloBXFormer.xForm();
     127       
     128       
    116129                // Set up file paths
    117130                String outputDirectory          = FileUtil.ensureEndsWith(applicationConfiguration.outputDirectory, File.separator);
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3192 r3208  
    132132        ////////////////////////////////////////////////////////////////////////////
    133133       
     134    public static IdentifierNode identifier(LocalVarDeclNode node) {
     135        ASTNode child = node.child(1);
     136        assert child instanceof IdentifierNode;
     137        return (IdentifierNode)node.child(1);
     138    }   
     139   
    134140        public static ASTNode lhs(LocalVarDeclNode node) {
    135141                return node.child(1);
     
    142148       
    143149        public static String assignOperatorLexeme(LocalVarDeclNode node) {
    144                 return node.getToken().getLexeme();
     150                return node.getToken().getPrintableLexeme();
    145151        }       
    146152       
     
    165171
    166172        public static String assignOperatorLexeme(AssignNode node) {
    167                 return node.getToken().getLexeme();
     173                return node.getToken().getPrintableLexeme();
    168174        }
    169175               
     
    172178        ////////////////////////////////////////////////////////////////////////////           
    173179        public static String integerConstantLexeme(IntegerConstantNode node) {
    174                 return node.getToken().getLexeme();
     180                return node.getToken().getPrintableLexeme();
    175181        }                       
    176182
     
    179185        ////////////////////////////////////////////////////////////////////////////           
    180186        public static String stringConstantLexeme(StringConstantNode node) {
    181                 return node.getToken().getLexeme();
     187                return node.getToken().getPrintableLexeme();
    182188        }               
    183189       
     
    201207        }       
    202208       
    203         ////////////////////////////////////////////////////////////////////////////
    204         // IdentifierNode
    205         ////////////////////////////////////////////////////////////////////////////
    206         public static String name(ASTNode node) {
    207                 assert node instanceof IdentifierNode;
    208                 return node.getToken().getLexeme();
    209         }
     209    ////////////////////////////////////////////////////////////////////////////
     210    // Name
     211    ////////////////////////////////////////////////////////////////////////////
     212    public static String name(ASTNode node) {
     213        assert ((node instanceof IdentifierNode) || (node instanceof CompoundIdentifierNode));
     214       
     215        if(node instanceof IdentifierNode) {
     216            return name((IdentifierNode)node);
     217        } else {
     218            return name((CompoundIdentifierNode)node);
     219        }
     220    }
     221
     222    ////////////////////////////////////////////////////////////////////////////
     223    // IdentifierNode
     224    ////////////////////////////////////////////////////////////////////////////
     225    private static String name(IdentifierNode node) {
     226       
     227        return node.getToken().getPrintableLexeme();
     228    }
     229
     230    ////////////////////////////////////////////////////////////////////////////
     231    // CompoundIdentifierNode
     232    ////////////////////////////////////////////////////////////////////////////
     233    private static String name(CompoundIdentifierNode node) {
     234       
     235        StringBuilder builder = new StringBuilder();
     236       
     237        for(int i=0;i<node.getChildren().size()-1;i++) {
     238            builder.append(node.child(i).getToken().getPrintableLexeme());
     239            builder.append(node.getToken().getPrintableLexeme());
     240        }
     241       
     242        builder.append(node.child(node.getChildren().size()-1).getToken().getPrintableLexeme());
     243       
     244        return builder.toString();
     245    }
     246
    210247
    211248/* TODO Update init section and remove 
     
    226263        ////////////////////////////////////////////////////////////////////////////
    227264        public static String structName(StructDeclNode node) {
    228         String name = new String();
    229         name = Accessors.name(node.child(0));
    230         return name;
     265        return Accessors.name(node.child(0));
    231266        }
    232267
     
    252287        ////////////////////////////////////////////////////////////////////////////
    253288        public static String structName(StructTypeNode node) {
    254         String name = new String();
    255         name = Accessors.name(node.child(0));
    256         return name;
     289        return Accessors.name(node.child(0));
    257290        }       
    258291
    259292        public static String structTypeLexeme(StructTypeNode node) {           
    260                 return node.getToken().getLexeme();
     293                return node.getToken().getPrintableLexeme();
    261294        }       
    262295               
     
    265298        ////////////////////////////////////////////////////////////////////////////
    266299        public static String fieldWidthLexeme(FieldWidthNode node) {           
    267                 return node.child(0).getToken().getLexeme();
     300                return node.child(0).getToken().getPrintableLexeme();
    268301        }       
    269302
     
    272305        ////////////////////////////////////////////////////////////////////////////   
    273306        public static String bitFieldLexeme(BitFieldTypeNode node) {           
    274                 return node.getToken().getLexeme();
     307                return node.getToken().getPrintableLexeme();
    275308        }       
    276309
     
    279312        ////////////////////////////////////////////////////////////////////////////   
    280313        public static String bitBlockLexeme(BitBlockTypeNode node) {           
    281                 return node.getToken().getLexeme();
     314                return node.getToken().getPrintableLexeme();
    282315        }       
    283316       
     
    286319        ////////////////////////////////////////////////////////////////////////////   
    287320        public static String voidLexeme(VoidTypeNode node) {           
    288                 return node.getToken().getLexeme();
     321                return node.getToken().getPrintableLexeme();
    289322        }       
    290323
     
    293326        ////////////////////////////////////////////////////////////////////////////           
    294327        public static String boolLexeme(BoolTypeNode node) {           
    295                 return node.getToken().getLexeme();
     328                return node.getToken().getPrintableLexeme();
    296329        }       
    297330       
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3192 r3208  
    1515import pabloB.tokens.IntConstantToken;
    1616import pabloB.tokens.LextantToken;
     17import pabloB.tokens.StringConstantToken;
    1718import pabloB.tokens.Token;
    1819import pabloB.ast.IdentifierNode;
     20import pabloB.inputHandler.Locator;
    1921import pabloB.lexicalAnalyzer.LexicalType;
    2022import pabloB.tokens.IdentifierToken;
     
    2426import pabloB.ast.FuncCallNode;
    2527import pabloB.lexicalAnalyzer.Lextant;
     28
    2629import toolchain.pabloB.ast.Accessors;
    2730
     
    341344        }       
    342345
    343        
     346    public static StringConstantNode makeStringConstantNode(String string, Locator locator) {
     347        StringConstantToken newToken = makeStringConstantToken(string, locator);
     348        return new StringConstantNode(newToken);
     349    }
     350       
     351    public static StringConstantToken makeStringConstantToken(String string, Locator locator) {
     352        return StringConstantToken.make(LexicalType.STRING, locator.getLocation(), string);
     353    }
    344354}
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/PabloBBuiltin.java

    r3207 r3208  
    1 /*
    2  * PabloB builtins.
    3  *
    4  * @author Ken Herdy <ksherdy at sfu dot ca>
    5  */
     1  package toolchain.pabloB.lang;
    62
    7 package toolchain.pabloB.lang;
     3  import java.util.ArrayList;
     4import java.util.List;
    85
    9 public enum PabloBBuiltins {
     6import toolchain.pabloB.lang.PabloBBuiltin;
    107
    11         /*
    12     ADVANCE(Carry.One, "Advance", 1),
    13     SCANTOFIRST(Carry.One, "ScanToFirst", 1),
    14     SCANTHRU(Carry.One, "ScanThru", 2),
    15     SCANTO(Carry.One, "ScanTo", 2),
    16     ADVANCETHENSCANTHRU(Carry.One, "AdvanceThenScanThru", 2),
    17     ADVANCETHENSCANTO(Carry.One, "AdvanceThenScanTo", 2),
    18     SPANUPTO(Carry.One, "SpanUpTo", 2),
    19     INCLUSIVESPAN(Carry.One, "InclusiveSpan", 2),
    20     EXCLUSIVESPAN(Carry.One, "ExclusiveSpan", 2),   
     8  public enum PabloBBuiltin {
    219
    22     ADVANCE32(Carry.N, "Advance32", 1),
    23     ADVANCEN(Carry.N, "Advance", 2),
    24 
    25     MASK(Carry.None, "Mask", 1),
    26     MASKFW(Carry.None, "Mask", 2),
    27    
    28     ATEOF(Carry.None, "atEOF", 1),
    29     INFILE(Carry.None, "inFile", 1),
    30     ASSERTZERO(Carry.None, "assert_0", 2),     
    31     EOFMASK(Carry.None, "EOF_mask", 0), // deprecated
    32        
    33     PRINTBITBLOCK(Carry.None, "PrintBitBlock", 1),
    34     ASSERTBITBLOCKALIGN(Carry.None, "AssertBitBlockAlign", 1);
    35    
    36     public enum Carry{One, N, None};   
    37    
    38     private final Carry type;
    39         private final String pabloName;
    40         private final int argCount;
    41        
    42         private Builtins(Carry type, String pabloName, int argCount) {
    43                 this.type = type;
    44                 this.pabloName = pabloName;
    45                 this.argCount = argCount;
    46         }
    47        
    48         public String pabloName() { return this.pabloName; }
    49         public int argCount() { return this.argCount; }
    50 
    51         public static List<Builtins> carryOneOperations () {
    52                
    53                 ArrayList<Builtins> carryN = new ArrayList<Builtins>();
    54                
    55                 for (Builtins operation : Builtins.values()) {
    56                         if (Carry.One == operation.type) {
    57                                 carryN.add(operation);
    58                         }
    59                 }
    60                
    61                 return carryN;
    62         }       
    63        
    64         public static List<Builtins> carryNOperations () {
    65                
    66                 ArrayList<Builtins> carryN = new ArrayList<Builtins>();
    67                
    68                 for (Builtins operation : Builtins.values()) {
    69                         if (Carry.N == operation.type) {
    70                                 carryN.add(operation);
    71                         }
    72                 }
    73                
    74                 return carryN;
    75         }
    76         */
    77 }
     10      PRINT_BITBLOCK("PrintBitBlock",CarryType.None, 1),
     11      ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign",CarryType.None, 1);
     12     
     13      public enum CarryType{One, N, None};   
     14     
     15      private final CarryType type;
     16      private final String name;
     17      private final int argCount;
     18     
     19      private PabloBBuiltin(String name, CarryType type, int argCount) {
     20          this.type = type;
     21          this.name = name;
     22          this.argCount = argCount;
     23      }
     24     
     25      public String pabloBName() { return this.name; }
     26      public int argCount() { return this.argCount; }
     27      public final CarryType getCarryType() { return type; }
     28     
     29      public static List<PabloBBuiltin> carryOneOperations () {
     30         
     31          ArrayList<PabloBBuiltin> carryOne = new ArrayList<PabloBBuiltin>();
     32         
     33          for (PabloBBuiltin operation : PabloBBuiltin.values()) {
     34              if (CarryType.One == operation.type) {
     35                  carryOne.add(operation);
     36              }
     37          }
     38         
     39          return carryOne;
     40      }   
     41     
     42      public static List<PabloBBuiltin> carryNOperations () {
     43         
     44          ArrayList<PabloBBuiltin> carryN = new ArrayList<PabloBBuiltin>();
     45         
     46          for (PabloBBuiltin operation : PabloBBuiltin.values()) {
     47              if (CarryType.N == operation.type) {
     48                  carryN.add(operation);
     49              }
     50          }
     51         
     52          return carryN;
     53      }
     54     
     55  }
  • proto/pabloj/trunk/src/toolchain/pabloB/semanticAnalyzer/Transformer.java

    r3115 r3208  
    99import pabloB.ast.ASTNode;
    1010import toolchain.pabloB.lang.*;
    11 import toolchain.pabloB.lang.carrySet.*;
     11import toolchain.pabloB.semanticAnalyzer.visitors.AddAlignmentAssertions;
     12import toolchain.pabloB.semanticAnalyzer.visitors.AddAssignmentPrints;
     13import toolchain.pabloB.lang.BuiltinEncoder;
    1214
    1315public class Transformer {
     
    1719        //private SymbolTable symbolTable;
    1820       
    19         private AbstractPabloBBuiltins2Lang builtins2Lang;
    20         private CarrySetEncoder carrySet2Lang;
     21        private BuiltinEncoder builtinEncoder;
     22       
     23    private boolean addDumpStmts;
     24    private boolean addAssertBitBlockAlignStmts;       
    2125       
    2226        //////////////////////////////////////////////////////////////
     
    4751                ASTNode decoratedTree = ASTTree.deepCopy();
    4852
    49 //              Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
    50 //              bitwiseToIDISA.XForm();                 
     53        if(addingAssignmentPrints()) {
     54            decoratedTree = AddAssignmentPrints.apply(decoratedTree, getBuiltinEncoder());
     55        }
     56        if(addingAlignmentAssertions()) {
     57            decoratedTree = AddAlignmentAssertions.apply(decoratedTree, getBuiltinEncoder()); 
     58        }               
    5159                                                                               
    5260                return decoratedTree;
     
    5462        }
    5563
    56         public AbstractPabloBBuiltins2Lang getBuiltins2Lang() {
    57                 return this.builtins2Lang;
    58         }
     64    public boolean addingAssignmentPrints() {
     65        return addDumpStmts;
     66    }
    5967
    60         public void setBuiltins2Lang(AbstractPabloBBuiltins2Lang builtins2Lang) {
    61                 this.builtins2Lang = builtins2Lang;
    62         }
     68    public void setAddDumpStmts(boolean addDumpStmts) {
     69        this.addDumpStmts = addDumpStmts;
     70    }
    6371
    64         public CarrySetEncoder getCarrySet2Lang() {
    65                 return carrySet2Lang;
    66         }
     72    public boolean addingAlignmentAssertions() {
     73        return addDumpStmts;
     74    }
    6775
    68         public void setCarrySet2Lang(CarrySetEncoder carrySet2Lang) {
    69                 this.carrySet2Lang = carrySet2Lang;
    70         }
     76    public void setAddAssertBitBlockAlignStmts(boolean addAssertBitBlockAlignStmts) {
     77        this.addAssertBitBlockAlignStmts = addAssertBitBlockAlignStmts;
     78    }   
     79   
     80    public BuiltinEncoder getBuiltinEncoder() {
     81        return this.builtinEncoder;
     82    }
     83
     84    public void setBuiltins2Lang(BuiltinEncoder builtins2Lang) {
     85        this.builtinEncoder = builtins2Lang;
     86    }
    7187
    7288}               
  • proto/pabloj/trunk/src/toolchain/pabloB/semanticAnalyzer/visitors/AddAlignmentAssertions.java

    r3203 r3208  
    88 */
    99
    10 package toolchain.pabloS.semanticAnalyzer.visitors;
     10package toolchain.pabloB.semanticAnalyzer.visitors;
    1111
    12 import pabloS.ast.*;
    13 import toolchain.pabloS.ast.Accessors;
    14 import toolchain.pabloS.ast.Generators;
    15 import toolchain.pabloS.ast.Mutators;
    16 import toolchain.pabloS.lang.BuiltinEncoder;
    17 import toolchain.pabloS.lang.PabloSBuiltins;
     12import pabloB.ast.*;
     13import toolchain.pabloB.ast.Accessors;
     14import toolchain.pabloB.ast.Generators;
     15import toolchain.pabloB.ast.Mutators;
     16import toolchain.pabloB.lang.BuiltinEncoder;
     17import toolchain.pabloB.lang.PabloBBuiltin;
    1818
    1919public class AddAlignmentAssertions {
     
    4848
    4949                private FuncCallNode makeAssertAlignCall(ASTNode node, ASTNode lhs) {
    50                         String assertAlign = encoder.getCode(PabloSBuiltins.ASSERT_BITBLOCK_ALIGN);
     50                        String assertAlign = encoder.getCode(PabloBBuiltin.ASSERT_BITBLOCK_ALIGN);
    5151                        return Generators.makeFuncCallNode(assertAlign, node.getToken(), lhs);
    5252                }
  • proto/pabloj/trunk/src/toolchain/pabloB/semanticAnalyzer/visitors/AddAssignmentPrints.java

    r3203 r3208  
    88 */
    99
    10 package toolchain.pabloS.semanticAnalyzer.visitors;
     10package toolchain.pabloB.semanticAnalyzer.visitors;
    1111
    12 import pabloS.ast.*;
    13 import toolchain.pabloS.ast.Accessors;
    14 import toolchain.pabloS.ast.Generators;
    15 import toolchain.pabloS.ast.Mutators;
    16 import toolchain.pabloS.lang.BuiltinEncoder;
    17 import toolchain.pabloS.lang.PabloSBuiltins;
     12import pabloB.ast.*;
     13import toolchain.pabloB.ast.Accessors;
     14import toolchain.pabloB.ast.Generators;
     15import toolchain.pabloB.ast.Mutators;
     16import toolchain.pabloB.lang.BuiltinEncoder;
     17import toolchain.pabloB.lang.PabloBBuiltin;
    1818
    1919public class AddAssignmentPrints {
     
    4545                // other methods
    4646                private void addPrintStatement(ASTNode node, ASTNode lhs) {
    47                         FuncCallNode printCall = makePrintCall(node, lhs.deepCopy());   // deepCopy
     47                    FuncCallNode printCall = makePrintCall(node, lhs.deepCopy());       // deepCopy
    4848                        Mutators.insertStatementAfter(node, printCall);                         
    4949                }
    5050
    5151                private FuncCallNode makePrintCall(ASTNode node, ASTNode argument) {
    52                         String printBitblockCode = encoder.getCode(PabloSBuiltins.PRINT_BITBLOCK);
    53                         return Generators.makeFuncCallNode(printBitblockCode, node.getToken(), argument);
     52                        String printBitblockCode = encoder.getCode(PabloBBuiltin.PRINT_BITBLOCK);
     53                        ASTNode label = Generators.makeStringConstantNode(Accessors.name(argument), node);
     54                        return Generators.makeFuncCallNode(printBitblockCode, node.getToken(), label, argument);
    5455                }
    5556        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3203 r3208  
    44import java.util.List;
    55
    6 public enum PabloSBuiltins {
     6public enum PabloSBuiltin {
    77
    88        // // TODO - Update explicit arg types
    99    ADVANCE("Advance", CarryType.One, 1),
    10     SCANTOFIRST("ScanToFirst", CarryType.One, 1),
    11     SCANTHRU("ScanThru", CarryType.One, 2),
    12     SCANTO("ScanTo", CarryType.One, 2),
    13     ADVANCETHENSCANTHRU("AdvanceThenScanThru", CarryType.One, 2),
    14     ADVANCETHENSCANTO("AdvanceThenScanTo", CarryType.One, 2),
    15     SPANUPTO("SpanUpTo", CarryType.One, 2),
    16     INCLUSIVESPAN("InclusiveSpan", CarryType.One, 2),
    17     EXCLUSIVESPAN("ExclusiveSpan", CarryType.One, 2),   
     10    SCANTO_FIRST("ScanToFirst", CarryType.One, 1),
     11    SCAN_THRU("ScanThru", CarryType.One, 2),
     12    SCAN_TO("ScanTo", CarryType.One, 2),
     13    ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, 2),
     14    ADVANCE_THEN_SCAN_TO("AdvanceThenScanTo", CarryType.One, 2),
     15    SPAN_UP_TO("SpanUpTo", CarryType.One, 2),
     16    INCLUSIVE_SPAN("InclusiveSpan", CarryType.One, 2),
     17    EXCLUSIVE_SPAN("ExclusiveSpan", CarryType.One, 2),   
    1818   
    19     ADVANCEN("Advance", CarryType.N, 2),   
    20     ADVANCE32("Advance32", CarryType.N, 1),
     19    ADVANCE_N("Advance", CarryType.N, 2),   
     20    ADVANCE_32("Advance32", CarryType.N, 1),
    2121
    2222    MASK("Mask", CarryType.None, 2),   
    23     ATEOF("atEOF", CarryType.None, 1),
    24     INFILE("inFile", CarryType.None, 1),
     23    AT_EOF("atEOF", CarryType.None, 1),
     24    IN_FILE("inFile", CarryType.None, 1),
    2525    ASSERT_ZERO("assert_0", CarryType.None, 2),
    26     EOFMASK("EOF_mask", CarryType.None, 0), // deprecated
    27        
    28     PRINT_BITBLOCK("PrintBitBlock", CarryType.None, 1),
    29     ASSERT_BITBLOCK_ALIGN("AssertBitBlockAlign", CarryType.None, 1);
    30    
     26    EOF_MASK("EOF_mask", CarryType.None, 0); // deprecated
     27
    3128    public enum CarryType{One, N, None};   
    3229   
     
    3532        private final int argCount;
    3633       
    37         private PabloSBuiltins(String name, CarryType type, int argCount) {
     34        private PabloSBuiltin(String name, CarryType type, int argCount) {
    3835                this.type = type;
    3936                this.name = name;
     
    4441        public int argCount() { return this.argCount; }
    4542        public final CarryType getCarryType() { return type; }
     43        public final boolean isCarryOne() { return type == CarryType.One; }
     44        public final boolean isCarryN() { return type == CarryType.N; }
    4645       
    47         public static List<PabloSBuiltins> carryOneOperations () {
     46        public static List<PabloSBuiltin> carryOneOperations () {
    4847               
    49                 ArrayList<PabloSBuiltins> carryOne = new ArrayList<PabloSBuiltins>();
     48                ArrayList<PabloSBuiltin> carryOne = new ArrayList<PabloSBuiltin>();
    5049               
    51                 for (PabloSBuiltins operation : PabloSBuiltins.values()) {
     50                for (PabloSBuiltin operation : PabloSBuiltin.values()) {
    5251                        if (CarryType.One == operation.type) {
    5352                                carryOne.add(operation);
     
    5857        }       
    5958       
    60         public static List<PabloSBuiltins> carryNOperations () {
     59        public static List<PabloSBuiltin> carryNOperations () {
    6160               
    62                 ArrayList<PabloSBuiltins> carryN = new ArrayList<PabloSBuiltins>();
     61                ArrayList<PabloSBuiltin> carryN = new ArrayList<PabloSBuiltin>();
    6362               
    64                 for (PabloSBuiltins operation : PabloSBuiltins.values()) {
     63                for (PabloSBuiltin operation : PabloSBuiltin.values()) {
    6564                        if (CarryType.N == operation.type) {
    6665                                carryN.add(operation);
    6766                        }
    6867                }
    69                
    7068                return carryN;
    7169        }
    72 
    73        
    7470}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2C.java

    r3206 r3208  
    3030        pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error"); 
    3131        pabloS2CCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    32        
    33         pabloS2CCode.put(PabloSBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
    34         pabloS2CCode.put(PabloSBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");
    35                
     32
    3633        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
    3734                if(!pabloS2CCode.containsKey(builtin)) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2CPP.java

    r3206 r3208  
    4141        pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error");       
    4242        pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    43        
    44         pabloS2CPPCode.put(PabloSBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
    45         pabloS2CPPCode.put(PabloSBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");       
    4643               
    4744        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/Transformer.java

    r3192 r3208  
    88
    99import toolchain.pabloS.lang.*;
     10import toolchain.pabloB.lang.carrySet.CarrySetEncoder;
    1011import toolchain.pabloS.semanticAnalyzer.visitors.CombineAdvances;
    11 import toolchain.pabloS.semanticAnalyzer.visitors.AddAlignmentAssertions;
    1212import toolchain.pabloS.semanticAnalyzer.visitors.SurroundAssert0sWithIfs;
    1313import toolchain.pabloS.semanticAnalyzer.visitors.ExpandAugmentedAssignments;
    1414import toolchain.pabloS.semanticAnalyzer.visitors.ConvertBitwiseBooleanToIDISACalls;
    15 import toolchain.pabloS.semanticAnalyzer.visitors.AddAssignmentPrints;
    16 import toolchain.pabloS.semanticAnalyzer.visitors.InitializeStreamDefaults;
    1715import toolchain.pabloS.semanticAnalyzer.visitors.carry.CarryIntroXFormer;
    1816
     
    2321        //private SymbolTable symbolTable;
    2422       
    25         private toolchain.pabloS.lang.BuiltinEncoder builtinEncoder;
    26         private toolchain.pabloB.lang.carrySet.CarrySetEncoder carrySet2Lang;
     23        private BuiltinEncoder builtinEncoder;
     24        private CarrySetEncoder carrySet2Lang;
    2725        private boolean finalBlockMode;
    28        
    29         private boolean addDumpStmts;
    30         private boolean addAssertBitBlockAlignStmts;
    3126       
    3227        //////////////////////////////////////////////////////////////
     
    5045                this.setBuiltins2Lang(new PabloSBuiltins2CPP());
    5146                this.setCarrySet2Lang(new toolchain.pabloB.lang.carrySet.CarrySetBuiltins2CPP());
    52                
    53                 this.setAddDumpStmts(false);
    54                 this.setAddAssertBitBlockAlignStmts(false);
    5547                this.setFinalBlockMode(false);
    5648        }
     
    6254                pabloS.ast.ASTNode decoratedTree = ASTTree.deepCopy();
    6355
    64                 if(addingAssignmentPrints()) {
    65                         decoratedTree = AddAssignmentPrints.apply(decoratedTree, getBuiltinEncoder());
    66                 }
    67                 if(addingAlignmentAssertions()) {
    68                         decoratedTree = AddAlignmentAssertions.apply(decoratedTree, getBuiltinEncoder()); 
    69                 }                       
     56               
    7057               
    7158                decoratedTree = ExpandAugmentedAssignments.apply(decoratedTree);
     
    8067        }
    8168
    82         public boolean addingAssignmentPrints() {
    83                 return addDumpStmts;
    84         }
    85 
    86         public void setAddDumpStmts(boolean addDumpStmts) {
    87                 this.addDumpStmts = addDumpStmts;
    88         }
    89 
    90         public boolean addingAlignmentAssertions() {
    91                 return addAssertBitBlockAlignStmts;
    92         }
    93 
    94         public void setAddAssertBitBlockAlignStmts(boolean addAssertBitBlockAlignStmts) {
    95                 this.addAssertBitBlockAlignStmts = addAssertBitBlockAlignStmts;
    96         }
    97 
    9869        public BuiltinEncoder getBuiltinEncoder() {
    9970                return this.builtinEncoder;
     
    10475        }
    10576
    106         public toolchain.pabloB.lang.carrySet.CarrySetEncoder getCarrySet2Lang() {
     77        public CarrySetEncoder getCarrySet2Lang() {
    10778                return carrySet2Lang;
    10879        }
Note: See TracChangeset for help on using the changeset viewer.