Changeset 3206


Ignore:
Timestamp:
May 28, 2013, 9:31:26 AM (6 years ago)
Author:
shermer
Message:

Renaming of PabloSBuiltins -> PabloSBuiltin.
Also renaming of individual builtins.

Location:
proto/pabloj/trunk
Files:
14 edited
1 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/.settings/org.eclipse.core.resources.prefs

    r3192 r3206  
     1#Tue May 28 09:06:18 PDT 2013
    12eclipse.preferences.version=1
    23encoding//input/test/pabloS/proto/parabix2_pablo_r2797.py=utf-8
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3192 r3206  
    244244        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, BuiltinEncoder encoder) {
    245245                Locator location = (Locator)node;
    246                 ASTNode eofMask = makeIdentifierNode(encoder.getCode(PabloSBuiltins.EOFMASK), location);
     246                ASTNode eofMask = makeIdentifierNode(encoder.getCode(PabloSBuiltin.EOF_MASK), location);
    247247                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.AND.Name(), location, arguments(node, eofMask));
    248248        }               
     
    254254                List<ASTNode> args = new ArrayList<ASTNode>();
    255255                args.add(node);
    256                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
     256                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken()));
    257257                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
    258258        }       
     
    260260        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, BuiltinEncoder builtins2Lang) {
    261261                List<ASTNode> args = new ArrayList<ASTNode>();
    262                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
     262                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), node.getToken()));
    263263                args.add(node);
    264264                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
     
    278278                Token streamTypeToken = Generators.makeLextantToken(Lextant.STREAM, locator);
    279279                StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
    280                 IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), locator);
     280                IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltin.EOF_MASK), locator);
    281281               
    282282                parameterNode.appendChild(streamTypeNode);
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/BuiltinEncoder.java

    r3115 r3206  
    22
    33public abstract class BuiltinEncoder {
    4         public abstract String getCode(PabloSBuiltins builtin);
     4        public abstract String getCode(PabloSBuiltin builtin);
    55}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3203 r3206  
    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
     26    EOF_MASK("EOF_mask", CarryType.None, 0), // deprecated
    2727       
    2828    PRINT_BITBLOCK("PrintBitBlock", CarryType.None, 1),
     
    3535        private final int argCount;
    3636       
    37         private PabloSBuiltins(String name, CarryType type, int argCount) {
     37        private PabloSBuiltin(String name, CarryType type, int argCount) {
    3838                this.type = type;
    3939                this.name = name;
     
    4444        public int argCount() { return this.argCount; }
    4545        public final CarryType getCarryType() { return type; }
     46        public final boolean isCarryOne() { return type == CarryType.One; }
     47        public final boolean isCarryN() { return type == CarryType.N; }
    4648       
    47         public static List<PabloSBuiltins> carryOneOperations () {
     49        public static List<PabloSBuiltin> carryOneOperations () {
    4850               
    49                 ArrayList<PabloSBuiltins> carryOne = new ArrayList<PabloSBuiltins>();
     51                ArrayList<PabloSBuiltin> carryOne = new ArrayList<PabloSBuiltin>();
    5052               
    51                 for (PabloSBuiltins operation : PabloSBuiltins.values()) {
     53                for (PabloSBuiltin operation : PabloSBuiltin.values()) {
    5254                        if (CarryType.One == operation.type) {
    5355                                carryOne.add(operation);
     
    5860        }       
    5961       
    60         public static List<PabloSBuiltins> carryNOperations () {
     62        public static List<PabloSBuiltin> carryNOperations () {
    6163               
    62                 ArrayList<PabloSBuiltins> carryN = new ArrayList<PabloSBuiltins>();
     64                ArrayList<PabloSBuiltin> carryN = new ArrayList<PabloSBuiltin>();
    6365               
    64                 for (PabloSBuiltins operation : PabloSBuiltins.values()) {
     66                for (PabloSBuiltin operation : PabloSBuiltin.values()) {
    6567                        if (CarryType.N == operation.type) {
    6668                                carryN.add(operation);
    6769                        }
    6870                }
    69                
    7071                return carryN;
    7172        }
    72 
    73        
    7473}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2C.java

    r3134 r3206  
    66public class PabloSBuiltins2C extends BuiltinEncoder {
    77       
    8         private static Map<PabloSBuiltins, String> pabloS2CCode;
     8        private static Map<PabloSBuiltin, String> pabloS2CCode;
    99       
    1010    static {
    1111       
    12         pabloS2CCode = new HashMap<PabloSBuiltins, String>();
     12        pabloS2CCode = new HashMap<PabloSBuiltin, String>();
    1313       
    14         pabloS2CCode.put(PabloSBuiltins.ADVANCE,"BitBlock_advance_ci_co");
    15         pabloS2CCode.put(PabloSBuiltins.SCANTOFIRST, "BitBlock_scantofirst");
    16         pabloS2CCode.put(PabloSBuiltins.SCANTHRU, "BitBlock_scanthru_ci_co");
    17         pabloS2CCode.put(PabloSBuiltins.SCANTO, "BitBlock_scanto_ci_co");
    18         pabloS2CCode.put(PabloSBuiltins.ADVANCETHENSCANTHRU, "BitBlock_advance_then_scanthru");
    19         pabloS2CCode.put(PabloSBuiltins.ADVANCETHENSCANTO, "BitBlock_advance_then_scanto");
    20         pabloS2CCode.put(PabloSBuiltins.SPANUPTO, "BitBlock_span_upto");
    21         pabloS2CCode.put(PabloSBuiltins.INCLUSIVESPAN, "BitBlock_inclusive_span");
    22         pabloS2CCode.put(PabloSBuiltins.EXCLUSIVESPAN, "BitBlock_exclusive_span");   
     14        pabloS2CCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
     15        pabloS2CCode.put(PabloSBuiltin.SCANTO_FIRST, "BitBlock_scantofirst");
     16        pabloS2CCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
     17        pabloS2CCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
     18        pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, "BitBlock_advance_then_scanthru");
     19        pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, "BitBlock_advance_then_scanto");
     20        pabloS2CCode.put(PabloSBuiltin.SPAN_UP_TO, "BitBlock_span_upto");
     21        pabloS2CCode.put(PabloSBuiltin.INCLUSIVE_SPAN, "BitBlock_inclusive_span");
     22        pabloS2CCode.put(PabloSBuiltin.EXCLUSIVE_SPAN, "BitBlock_exclusive_span");   
    2323
    24         pabloS2CCode.put(PabloSBuiltins.ADVANCE32, "BitBlock_advance_n_<%s>");
    25         pabloS2CCode.put(PabloSBuiltins.ADVANCEN, "BitBlock_advance_n_<%s>");
     24        pabloS2CCode.put(PabloSBuiltin.ADVANCE_32, "BitBlock_advance_n_<%s>");
     25        pabloS2CCode.put(PabloSBuiltin.ADVANCE_N, "BitBlock_advance_n_<%s>");
    2626
    27         pabloS2CCode.put(PabloSBuiltins.MASK, "Mask");
    28         pabloS2CCode.put(PabloSBuiltins.ATEOF, "atEOF");
    29         pabloS2CCode.put(PabloSBuiltins.INFILE, "inFile");
    30         pabloS2CCode.put(PabloSBuiltins.ASSERT_ZERO, "assert_0_error");
    31         pabloS2CCode.put(PabloSBuiltins.EOFMASK, "EOF_mask");
     27        pabloS2CCode.put(PabloSBuiltin.MASK, "Mask");
     28        pabloS2CCode.put(PabloSBuiltin.AT_EOF, "atEOF");
     29        pabloS2CCode.put(PabloSBuiltin.IN_FILE, "inFile");
     30        pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error"); 
     31        pabloS2CCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    3232       
    33         pabloS2CCode.put(PabloSBuiltins.PRINT_BITBLOCK, "print_register<BitBlock>");
    34         pabloS2CCode.put(PabloSBuiltins.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");       
     33        pabloS2CCode.put(PabloSBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
     34        pabloS2CCode.put(PabloSBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");
    3535               
    36         for(PabloSBuiltins builtin : PabloSBuiltins.values()) {
     36        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
    3737                if(!pabloS2CCode.containsKey(builtin)) {
    3838                                throw new RuntimeException("PabloS builtin to C mapping not unimplemented in :" + PabloSBuiltins2C.class.getSimpleName());
     
    4242
    4343        @Override
    44         public String getCode(PabloSBuiltins builtin) {
     44        public String getCode(PabloSBuiltin builtin) {
    4545                return pabloS2CCode.get(builtin);
    4646        }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2CPP.java

    r3115 r3206  
    1717public class PabloSBuiltins2CPP extends BuiltinEncoder {
    1818
    19         private static Map<PabloSBuiltins, String> pabloS2CPPCode;
     19        private static Map<PabloSBuiltin, String> pabloS2CPPCode;
    2020       
    2121    static {
    2222       
    23         pabloS2CPPCode = new HashMap<PabloSBuiltins, String>();
     23        pabloS2CPPCode = new HashMap<PabloSBuiltin, String>();
    2424       
    25         pabloS2CPPCode.put(PabloSBuiltins.ADVANCE,"BitBlock_advance_ci_co");
    26         pabloS2CPPCode.put(PabloSBuiltins.SCANTOFIRST, "BitBlock_scantofirst");
    27         pabloS2CPPCode.put(PabloSBuiltins.SCANTHRU, "BitBlock_scanthru_ci_co");
    28         pabloS2CPPCode.put(PabloSBuiltins.SCANTO, "BitBlock_scanto_ci_co");
    29         pabloS2CPPCode.put(PabloSBuiltins.ADVANCETHENSCANTHRU, "BitBlock_advance_then_scanthru");
    30         pabloS2CPPCode.put(PabloSBuiltins.ADVANCETHENSCANTO, "BitBlock_advance_then_scanto");
    31         pabloS2CPPCode.put(PabloSBuiltins.SPANUPTO, "BitBlock_span_upto");
    32         pabloS2CPPCode.put(PabloSBuiltins.INCLUSIVESPAN, "BitBlock_inclusive_span");
    33         pabloS2CPPCode.put(PabloSBuiltins.EXCLUSIVESPAN, "BitBlock_exclusive_span");   
     25        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
     26        pabloS2CPPCode.put(PabloSBuiltin.SCANTO_FIRST, "BitBlock_scantofirst");
     27        pabloS2CPPCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
     28        pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
     29        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, "BitBlock_advance_then_scanthru");
     30        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, "BitBlock_advance_then_scanto");
     31        pabloS2CPPCode.put(PabloSBuiltin.SPAN_UP_TO, "BitBlock_span_upto");
     32        pabloS2CPPCode.put(PabloSBuiltin.INCLUSIVE_SPAN, "BitBlock_inclusive_span");
     33        pabloS2CPPCode.put(PabloSBuiltin.EXCLUSIVE_SPAN, "BitBlock_exclusive_span");   
    3434
    35         pabloS2CPPCode.put(PabloSBuiltins.ADVANCE32, "BitBlock_advance_n_<%s>");
    36         pabloS2CPPCode.put(PabloSBuiltins.ADVANCEN, "BitBlock_advance_n_<%s>");
     35        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_32, "BitBlock_advance_n_<%s>");
     36        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_N, "BitBlock_advance_n_<%s>");
    3737
    38         pabloS2CPPCode.put(PabloSBuiltins.MASK, "Mask");
    39         pabloS2CPPCode.put(PabloSBuiltins.ATEOF, "atEOF");
    40         pabloS2CPPCode.put(PabloSBuiltins.INFILE, "inFile");
    41         pabloS2CPPCode.put(PabloSBuiltins.ASSERT_ZERO, "assert_0_error");       
    42         pabloS2CPPCode.put(PabloSBuiltins.EOFMASK, "EOF_mask");
     38        pabloS2CPPCode.put(PabloSBuiltin.MASK, "Mask");
     39        pabloS2CPPCode.put(PabloSBuiltin.AT_EOF, "atEOF");
     40        pabloS2CPPCode.put(PabloSBuiltin.IN_FILE, "inFile");
     41        pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error");       
     42        pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    4343       
    44         pabloS2CPPCode.put(PabloSBuiltins.PRINT_BITBLOCK, "print_register<BitBlock>");
    45         pabloS2CPPCode.put(PabloSBuiltins.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");     
     44        pabloS2CPPCode.put(PabloSBuiltin.PRINT_BITBLOCK, "print_register<BitBlock>");
     45        pabloS2CPPCode.put(PabloSBuiltin.ASSERT_BITBLOCK_ALIGN, "assert_bitblock_align");       
    4646               
    47         for(PabloSBuiltins builtin : PabloSBuiltins.values()) {
     47        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
    4848                if(!pabloS2CPPCode.containsKey(builtin)) {
    4949                                throw new RuntimeException("PabloS builtin to CPP mapping not unimplemented in :" + PabloSBuiltins2CPP.class.getSimpleName());
     
    5252    }
    5353   
    54         public String getCode(PabloSBuiltins builtin) {                 
     54        public String getCode(PabloSBuiltin builtin) {                 
    5555                return pabloS2CPPCode.get(builtin);
    5656        }
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinsUtil.java

    r3143 r3206  
    1414    public static boolean isMask(FuncCallNode node) { // Advance(X) || Advance(X,n)
    1515               
    16                 if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.MASK.pabloSName(), PabloSBuiltins.MASK.argCount())) {
     16                if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.MASK.pabloSName(), PabloSBuiltin.MASK.argCount())) {
    1717                    return true;
    1818                }       
     
    2222    public static boolean isAdvance(FuncCallNode node) { // Advance(X) || Advance(X,n)
    2323       
    24         if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName(), PabloSBuiltins.ADVANCE.argCount()) ||
    25                         isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName(), PabloSBuiltins.ADVANCEN.argCount())) {
     24        if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.ADVANCE.pabloSName(), PabloSBuiltin.ADVANCE.argCount()) ||
     25                        isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.ADVANCE.pabloSName(), PabloSBuiltin.ADVANCE_N.argCount())) {
    2626            return true;
    2727        }
     
    3131    public static boolean isAdvanceN(FuncCallNode node) { // Advance(X) || Advance(X,n)
    3232       
    33         if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName(), PabloSBuiltins.ADVANCEN.argCount())) {
     33        if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.ADVANCE.pabloSName(), PabloSBuiltin.ADVANCE_N.argCount())) {
    3434            return true;
    3535        }
     
    3939    public static boolean isBuiltinOperations(ASTNode node) {
    4040       
    41                 for (PabloSBuiltins builtin : PabloSBuiltins.values()) {   
     41                for (PabloSBuiltin builtin : PabloSBuiltin.values()) {   
    4242                if (isQualifiedName(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName())) {
    4343                    return true;
     
    4949    public static boolean isCarryOne(FuncCallNode node) {
    5050       
    51                 for (PabloSBuiltins carryOneOperation : PabloSBuiltins.carryOneOperations()) {                         
     51                for (PabloSBuiltin carryOneOperation : PabloSBuiltin.carryOneOperations()) {                           
    5252                        @SuppressWarnings("unused")
    5353                        int argCount = Accessors.funcCallArgCount((FuncCallNode)node);
     
    6161    public static boolean isCarryN(FuncCallNode node) {
    6262
    63         for (PabloSBuiltins carryNOperation : PabloSBuiltins.carryNOperations()) {
     63        for (PabloSBuiltin carryNOperation : PabloSBuiltin.carryNOperations()) {
    6464                    if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloSName(), carryNOperation.argCount())){
    6565                        return true;
     
    7676       
    7777    public static boolean isBuiltInCall(FuncCallNode node) {
    78         for (PabloSBuiltins builtin : PabloSBuiltins.values()) {   
     78        for (PabloSBuiltin builtin : PabloSBuiltin.values()) {   
    7979            if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName(), builtin.argCount())) {
    8080                return true;
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/AddAlignmentAssertions.java

    r3115 r3206  
    1515import toolchain.pabloS.ast.Mutators;
    1616import toolchain.pabloS.lang.BuiltinEncoder;
    17 import toolchain.pabloS.lang.PabloSBuiltins;
     17import toolchain.pabloS.lang.PabloSBuiltin;
    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(PabloSBuiltin.ASSERT_BITBLOCK_ALIGN);
    5151                        return Generators.makeFuncCallNode(assertAlign, node.getToken(), lhs);
    5252                }
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/AddAssignmentPrints.java

    r3115 r3206  
    1515import toolchain.pabloS.ast.Mutators;
    1616import toolchain.pabloS.lang.BuiltinEncoder;
    17 import toolchain.pabloS.lang.PabloSBuiltins;
     17import toolchain.pabloS.lang.PabloSBuiltin;
    1818
    1919public class AddAssignmentPrints {
     
    5050
    5151                private FuncCallNode makePrintCall(ASTNode node, ASTNode argument) {
    52                         String printBitblockCode = encoder.getCode(PabloSBuiltins.PRINT_BITBLOCK);
     52                        String printBitblockCode = encoder.getCode(PabloSBuiltin.PRINT_BITBLOCK);
    5353                        return Generators.makeFuncCallNode(printBitblockCode, node.getToken(), argument);
    5454                }
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/InitializeStreamDefaults.java

    r3192 r3206  
    1616import toolchain.pabloS.ast.Accessors;
    1717import toolchain.pabloS.ast.Generators;
    18 import toolchain.pabloS.lang.PabloSBuiltins;
     18import toolchain.pabloS.lang.PabloSBuiltin;
    1919
    2020
     
    4949                                IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(fieldWidth, node);
    5050
    51                                 FuncCallNode mask = Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
     51                                FuncCallNode mask = Generators.makeFuncCallNode(PabloSBuiltin.MASK.pabloSName(),
    5252                                                node.getToken(),
    5353                                                arguments(fieldWidthNode, zeroConstantNode));
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/SurroundAssert0sWithIfs.java

    r3143 r3206  
    1414import toolchain.pabloS.ast.Generators;
    1515import toolchain.pabloS.lang.BuiltinEncoder;
    16 import toolchain.pabloS.lang.PabloSBuiltins;
     16import toolchain.pabloS.lang.PabloSBuiltin;
    1717import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    1818
     
    5959                                                               
    6060                                ASTNode assert0Call
    61                                                 = Generators.makeFuncCallNode(encoder.getCode(PabloSBuiltins.ASSERT_ZERO),
     61                                                = Generators.makeFuncCallNode(encoder.getCode(PabloSBuiltin.ASSERT_ZERO),
    6262                                                                                                          locator,                             
    6363                                                                                                          errorMsg,
     
    7676                        return PabloSBuiltinsUtil.isCall(node,
    7777                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
    78                                         PabloSBuiltins.ASSERT_ZERO.pabloSName(),
    79                                         PabloSBuiltins.ASSERT_ZERO.argCount());
     78                                        PabloSBuiltin.ASSERT_ZERO.pabloSName(),
     79                                        PabloSBuiltin.ASSERT_ZERO.argCount());
    8080                }               
    8181        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/BuiltinTranslator.java

    r3192 r3206  
    1010import toolchain.pabloS.ast.Accessors;
    1111import toolchain.pabloS.ast.Generators;
    12 import toolchain.pabloS.lang.PabloSBuiltins;
    13 import toolchain.pabloS.lang.PabloSBuiltins.CarryType;
     12import toolchain.pabloS.lang.PabloSBuiltin;
     13import toolchain.pabloS.lang.PabloSBuiltin.CarryType;
    1414import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    1515
    1616public enum BuiltinTranslator {
    17         ADVANCE(PabloSBuiltins.ADVANCE),
    18         SCANTHRU(PabloSBuiltins.SCANTHRU),
    19         ADVANCETHENSCANTHRU(PabloSBuiltins.ADVANCETHENSCANTHRU),
    20         SPANUPTO(PabloSBuiltins.SPANUPTO),
    21         INCLUSIVESPAN(PabloSBuiltins.INCLUSIVESPAN),
    22         EXCLUSIVESPAN(PabloSBuiltins.EXCLUSIVESPAN),
    23         SCANTOFIRST(PabloSBuiltins.SCANTOFIRST),                        // TODO: verify that this is basicAction and not scanToAction
    24         ADVANCE32(PabloSBuiltins.ADVANCE32),
     17        ADVANCE(PabloSBuiltin.ADVANCE),
     18        SCANTHRU(PabloSBuiltin.SCAN_THRU),
     19        ADVANCETHENSCANTHRU(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU),
     20        SPANUPTO(PabloSBuiltin.SPAN_UP_TO),
     21        INCLUSIVESPAN(PabloSBuiltin.INCLUSIVE_SPAN),
     22        EXCLUSIVESPAN(PabloSBuiltin.EXCLUSIVE_SPAN),
     23        SCANTOFIRST(PabloSBuiltin.SCANTO_FIRST),                        // TODO: verify that this is basicAction and not scanToAction
     24        ADVANCE32(PabloSBuiltin.ADVANCE_32),
    2525                //advance32 came with this in its action, commented out:                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);         
    26         ADVANCEN(PabloSBuiltins.ADVANCEN, Action.ADVANCEN_ACTION),
    27         ATEOF(PabloSBuiltins.ATEOF, Action.ATEOF_ACTION),
    28         INFILE(PabloSBuiltins.INFILE, Action.INFILE_ACTION),
    29         MASK(PabloSBuiltins.MASK, Action.MASK_ACTION),
    30         SCANTO(PabloSBuiltins.SCANTO, Action.SCANTO_ACTION),
    31         ADVANCETHENSCANTO(PabloSBuiltins.ADVANCETHENSCANTO, Action.ADVANCE_THEN_SCANTO_ACTION);
     26        ADVANCEN(PabloSBuiltin.ADVANCE_N, Action.ADVANCEN_ACTION),
     27        ATEOF(PabloSBuiltin.AT_EOF, Action.ATEOF_ACTION),
     28        INFILE(PabloSBuiltin.IN_FILE, Action.INFILE_ACTION),
     29        MASK(PabloSBuiltin.MASK, Action.MASK_ACTION),
     30        SCANTO(PabloSBuiltin.SCAN_TO, Action.SCANTO_ACTION),
     31        ADVANCETHENSCANTO(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, Action.ADVANCE_THEN_SCANTO_ACTION);
    3232
    3333        private enum Action {
     
    4040                MASK_ACTION;
    4141        }
    42         private PabloSBuiltins builtin;
     42        private PabloSBuiltin builtin;
    4343        private boolean usesAdvanceNCounter;
    4444        private BuiltinTranslator.Action actionSelector;
    4545       
    4646       
    47         private BuiltinTranslator(PabloSBuiltins builtin, Action actionSelector) {
     47        private BuiltinTranslator(PabloSBuiltin builtin, Action actionSelector) {
    4848                this.builtin = builtin;
    4949                this.usesAdvanceNCounter = (builtin.getCarryType()==CarryType.N);       
    5050                this.actionSelector = actionSelector;
    5151        }               
    52         private BuiltinTranslator(PabloSBuiltins builtin) {
     52        private BuiltinTranslator(PabloSBuiltin builtin) {
    5353                this(builtin, Action.CARRY_ACTION);
    5454        }
    5555       
    5656       
    57         protected PabloSBuiltins getBuiltin() {
     57        protected PabloSBuiltin getBuiltin() {
    5858                return builtin;
    5959        }
     
    8282                case MASK_ACTION:               maskAction(node, counter, context);         break;
    8383               
    84                 case SCANTO_ACTION:                 scanToAction(node, PabloSBuiltins.SCANTHRU, counter, context);   break;
    85                 case ADVANCE_THEN_SCANTO_ACTION:    scanToAction(node, PabloSBuiltins.ADVANCETHENSCANTHRU, counter, context);   break;         
     84                case SCANTO_ACTION:                 scanToAction(node, PabloSBuiltin.SCAN_THRU, counter, context);   break;
     85                case ADVANCE_THEN_SCANTO_ACTION:    scanToAction(node, PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, counter, context);   break;               
    8686                }
    8787        }
     
    9191        }
    9292       
    93         public void carryAction(FuncCallNode node, Counter counter, Context context, PabloSBuiltins translation) {
     93        public void carryAction(FuncCallNode node, Counter counter, Context context, PabloSBuiltin translation) {
    9494                List<ASTNode> arguments = Accessors.funcCallArgsList(node);
    9595               
     
    103103                counter.increment();
    104104        }               
    105         public void scanToAction(FuncCallNode node, PabloSBuiltins translation, Counter counter, Context context) {
     105        public void scanToAction(FuncCallNode node, PabloSBuiltin translation, Counter counter, Context context) {
    106106                ASTNode argument = Accessors.funcCallArg(node, 1);
    107107                translateArgument(context, argument);
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryInfoSetVisitor.java

    r3115 r3206  
    1010import toolchain.pabloB.symbols.SymbolTable;
    1111import toolchain.pabloS.ast.Accessors;
    12 import toolchain.pabloS.lang.PabloSBuiltins;
     12import toolchain.pabloS.lang.PabloSBuiltin;
    1313import toolchain.pabloS.lang.PabloSBuiltinsUtil;
    1414
     
    4141                       
    4242                        if(PabloSBuiltinsUtil.isCarryOne(node)) {
    43                                 if (PabloSBuiltinsUtil.isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.SCANTOFIRST.pabloSName(), PabloSBuiltins.SCANTOFIRST.argCount())) {
     43                                if (PabloSBuiltinsUtil.isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltin.SCANTO_FIRST.pabloSName(), PabloSBuiltin.SCANTO_FIRST.argCount())) {
    4444                                        ((CarryInfoSetSymbol)symbolTable.get(key)).addCarry1(1);
    4545                                } else {
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/Context.java

    r3133 r3206  
    77import toolchain.pabloS.ast.Generators;
    88import toolchain.pabloS.lang.BuiltinEncoder;
    9 import toolchain.pabloS.lang.PabloSBuiltins;
     9import toolchain.pabloS.lang.PabloSBuiltin;
    1010
    1111// immutable
     
    5757                return getCarrySetEncoder().getCode(carrySetBuiltin);
    5858        }
    59         public final String getCode(PabloSBuiltins builtin) {
     59        public final String getCode(PabloSBuiltin builtin) {
    6060                return getBuiltinEncoder().getCode(builtin);
    6161        }
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/Counter.java

    r3133 r3206  
    66import toolchain.pabloB.lang.carrySet.CarrySetBuiltins;
    77import toolchain.pabloS.ast.Generators;
    8 import toolchain.pabloS.lang.PabloSBuiltins;
     8import toolchain.pabloS.lang.PabloSBuiltin;
    99
    1010
     
    4444                IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(1, locator);
    4545               
    46                 return Generators.makeFuncCallNode(PabloSBuiltins.MASK.pabloSName(),
     46                return Generators.makeFuncCallNode(PabloSBuiltin.MASK.pabloSName(),
    4747                                locator,
    4848                                fieldWidthNode, zeroConstantNode);
Note: See TracChangeset for help on using the changeset viewer.