Changeset 2971


Ignore:
Timestamp:
Mar 24, 2013, 9:49:05 PM (5 years ago)
Author:
ksherdy
Message:

Renamed builtins. Added bitwise builtins. Progress towards function signature definitions.

Location:
proto/pabloj/trunk/src/compilers
Files:
1 added
1 deleted
16 edited
7 moved

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/compilers/pabloB/lang/PabloBBuiltins.java

    r2956 r2971  
    11package compilers.pabloB.lang;
    22
    3 public enum Builtins {
     3public enum PabloBBuiltins {
    44
    55        /*
  • proto/pabloj/trunk/src/compilers/pabloB/lang/PabloBBuiltins2Lang.java

    r2956 r2971  
    11package compilers.pabloB.lang;
    22
    3 public abstract class Builtins2Lang {
    4         public abstract String getCode(Builtins builtin);
     3public abstract class PabloBBuiltins2Lang {
     4        public abstract String getCode(PabloBBuiltins builtin);
    55}
  • proto/pabloj/trunk/src/compilers/pabloB/lang/carrySet/CarrySetBuiltins2CPP.java

    r2963 r2971  
    11/*
    2  * Maps carry set builtins to C++ (Macro style).
     2 * Maps carry set builtins to C++ macro name.
    33 *
    44 * @author <ksherdy at sfu dot ca>
    5  *
    65 */
    76
  • proto/pabloj/trunk/src/compilers/pabloB/lang/carrySet/CarrySetBuiltins2Lang.java

    r2963 r2971  
    88
    99public abstract class CarrySetBuiltins2Lang {
     10       
    1011        public abstract String getCode(CarrySetBuiltins op);
    1112       
    1213        public static final String CARRYSET_BASENAME_PREFIX             = "carry_set_";
    1314        public static final String CARRYSETBASENAME                             = CARRYSET_BASENAME_PREFIX + "0";
    14         //public static final String LOCALCARRYQNAME                            = "subcarryQ";
    1515        public static final String CARRYQARRAYNAME                              = "cq";
    16         public static   String CARRYSETDECLAREFORMATSTRING                      = null;
    1716       
    1817}
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/IDISABitBlockBuiltins.java

    r2956 r2971  
    22 * IDISA BitBlock builtins.
    33 *
    4  * TODO - Add IDISA support as needed.
     4 * Add IDISA builtins as needed.
    55 *
    66 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    99package compilers.pabloB.lang.idisa;
    1010
    11 public enum BitBlock {
     11public enum IDISABitBlockBuiltins {
    1212
    1313        ANY("any", 1),
     
    1818        private int argCount;
    1919       
    20         private BitBlock(String lexeme, int argCount) {
     20        private IDISABitBlockBuiltins(String lexeme, int argCount) {
    2121                this.lexeme = lexeme;
    2222                this.argCount = argCount;
  • proto/pabloj/trunk/src/compilers/pabloB/lang/idisa/IDISASIMDBuiltins.java

    r2970 r2971  
    22 * IDISA SIMD builtins.
    33 *
    4  * TODO - Add IDISA support as needed.
     4 * Unary        r = simd<w>::op(a)
     5 * Binary       r = simd<w>::op(a, b)
     6 * Ternary  r = simd<w>::op(a, b, c)
    57 *
    68 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    911package compilers.pabloB.lang.idisa;
    1012
    11 public enum SIMD {
     13public enum IDISASIMDBuiltins {
    1214       
    13         // No field width operations form simd_op(a,b)
    14         // Unary operations   form r = simd<w>::op(a)
    15         // Binary operations  form r = simd<w>::op(a, b)
    16         // Ternary operations form r = simd<w>::op(a, b, c)
    17 
    18         // No field width
    19         NOR("nor",2),
    20         NOT("not",1),
    21         ANDC("andc",2),
    22         OR("or",2),
    23         XOR("xor",2),
    24         AND("and",2),   
    25                
    26         // Binary
    27         ADD("add",2),
    28         SUB("sub",2),
    29         MUL("mul",2),
    30         EQ("eq",2),
    31         GT("gt",2),
    32         UGT("ugt",2),
    33         LT("lt",2),
    34         ULT("ult",2),
    35         MAX("max",2),
    36         UMAX("umax",2),
    37         MIN("min",2),
    38         UMIN("umin",2),
    39         SLL("sll",2),
    40         SRL("srl",2),
    41         SRA("sra",2),
     15        ADD("add",1,2),
     16        SUB("sub",1,2),
     17        MUL("mul",1,2),
     18        EQ("eq",1,2),
     19        GT("gt",1,2),
     20        UGT("ugt",1,2),
     21        LT("lt",1,2),
     22        ULT("ult",1,2),
     23        MAX("max",1,2),
     24        UMAX("umax",1,2),
     25        MIN("min",1,2),
     26        UMIN("umin",1,2),
     27        SLL("sll",1,2),
     28        SRL("srl",1,2),
     29        SRA("sra",1,2),
    4230       
    43         // Constants
    44         CONSTANT("constant", 0);
     31        CONSTANT("constant",1,1);
    4532       
    46         private String lexeme;
     33        private String name;
     34        private int fieldWidth;
    4735        private int argCount;
    4836       
    49         private SIMD(String lexeme, int argCount) {
    50                 this.lexeme = lexeme;
     37        private IDISASIMDBuiltins(String name, int fieldWidth, int argCount) {
     38                this.name = name;
     39                this.fieldWidth = fieldWidth;
    5140                this.argCount = argCount;
    5241        }
     
    5443        private static final String SIMD = "simd";
    5544       
    56         public String IDISALexeme() { return (SIMD + "_" + lexeme); }
    57         public String IDISALexeme(String fieldWidth) { return (SIMD + "<" + fieldWidth + ">::" + lexeme); }
    58         public String IDISAConstantLexeme(String fieldWidth, String constant) {
    59                 return (SIMD + "<" + fieldWidth + ">::" + CONSTANT.lexeme + "<" + constant +">");
    60         }
     45        public String Name(String fieldWidth) { return (SIMD + "<" + fieldWidth + ">::" + name); }
     46        public int getFieldWidth() { return fieldWidth; }
    6147        public int argCount() { return argCount; }
    6248               
  • proto/pabloj/trunk/src/compilers/pabloB/semanticAnalyzer/Transformer.java

    r2965 r2971  
    1818        //private SymbolTable symbolTable;
    1919       
    20         private Builtins2Lang builtins2Lang;
     20        private PabloBBuiltins2Lang builtins2Lang;
    2121        private CarrySetBuiltins2Lang carrySet2Lang;
    2222       
     
    5555        }
    5656
    57         public Builtins2Lang getBuiltins2Lang() {
     57        public PabloBBuiltins2Lang getBuiltins2Lang() {
    5858                return this.builtins2Lang;
    5959        }
    6060
    61         public void setBuiltins2Lang(Builtins2Lang builtins2Lang) {
     61        public void setBuiltins2Lang(PabloBBuiltins2Lang builtins2Lang) {
    6262                this.builtins2Lang = builtins2Lang;
    6363        }
  • proto/pabloj/trunk/src/compilers/pabloS/ast/Generators.java

    r2970 r2971  
    1515import java.util.List;
    1616
    17 import compilers.pabloB.lang.idisa.SIMD;
    18 import compilers.pabloS.lang.Builtins;
    19 import compilers.pabloS.lang.Builtins2Lang;
     17import compilers.pabloB.lang.idisa.IDISASIMDBitwiseBuiltins;
     18import compilers.pabloS.lang.PabloSBuiltins;
     19import compilers.pabloS.lang.PabloSBuiltins2Lang;
    2020
    2121import pabloS.lexicalAnalyzer.LexicalType;
     
    232232        }
    233233       
    234         public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
    235                 List<ASTNode> args = new ArrayList<ASTNode>();
    236                 args.add(node);
    237                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    238                 return Generators.makeFuncCallNode(SIMD.AND.IDISALexeme(), node.getToken(), args);
    239         }
    240 
    241         public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
    242                 List<ASTNode> args = new ArrayList<ASTNode>();
    243                 args.add(node);
    244                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    245                 return Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(), node.getToken(), args);
    246         }       
    247 
    248         public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
    249                 List<ASTNode> args = new ArrayList<ASTNode>();
    250                 args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
    251                 args.add(node);
    252                 return Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(), node.getToken(), args);
     234        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     235                List<ASTNode> args = new ArrayList<ASTNode>();
     236                args.add(node);
     237                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
     238                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.AND.Name(), node.getToken(), args);
     239        }
     240
     241        public static FuncCallNode makeSIMDAndCEOFMaskFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     242                List<ASTNode> args = new ArrayList<ASTNode>();
     243                args.add(node);
     244                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
     245                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
     246        }       
     247
     248        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     249                List<ASTNode> args = new ArrayList<ASTNode>();
     250                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), node.getToken()));
     251                args.add(node);
     252                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(), node.getToken(), args);
    253253        }               
    254254       
    255         public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
    256                 List<ASTNode> args = new ArrayList<ASTNode>();
    257                 args.add(node);
    258                 return Generators.makeFuncCallNode(SIMD.NOT.IDISALexeme(), node.getToken(), args);
     255        public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, PabloSBuiltins2Lang builtins2Lang) {
     256                List<ASTNode> args = new ArrayList<ASTNode>();
     257                args.add(node);
     258                return Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.NOT.Name(), node.getToken(), args);
    259259        }               
    260260       
    261         public static ParameterNode makeEOFMaskParameter(Builtins2Lang builtins2Lang, Token locationToken) {
     261        public static ParameterNode makeEOFMaskParameter(PabloSBuiltins2Lang builtins2Lang, Token locationToken) {
    262262               
    263263                Token parameterNodeToken = Generators.makeLextantToken(Lextant.STREAM, locationToken);
     
    266266                Token streamTypeToken = Generators.makeLextantToken(Lextant.STREAM, locationToken);
    267267                StreamTypeNode streamTypeNode = new StreamTypeNode(streamTypeToken);
    268                 IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), locationToken);
     268                IdentifierNode identifierNode = Generators.makeIdentifierNode(builtins2Lang.getCode(PabloSBuiltins.EOFMASK), locationToken);
    269269               
    270270                parameterNode.appendChild(streamTypeNode);
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltins.java

    r2956 r2971  
    44import java.util.List;
    55
    6 public enum Builtins {
     6public enum PabloSBuiltins {
    77
    8     ADVANCE(CarryType.One, "Advance", 1),
    9     SCANTOFIRST(CarryType.One, "ScanToFirst", 1),
    10     SCANTHRU(CarryType.One, "ScanThru", 2),
    11     SCANTO(CarryType.One, "ScanTo", 2),
    12     ADVANCETHENSCANTHRU(CarryType.One, "AdvanceThenScanThru", 2),
    13     ADVANCETHENSCANTO(CarryType.One, "AdvanceThenScanTo", 2),
    14     SPANUPTO(CarryType.One, "SpanUpTo", 2),
    15     INCLUSIVESPAN(CarryType.One, "InclusiveSpan", 2),
    16     EXCLUSIVESPAN(CarryType.One, "ExclusiveSpan", 2),   
     8    ADVANCE(Type.One, "Advance", 1),
     9    SCANTOFIRST(Type.One, "ScanToFirst", 1),
     10    SCANTHRU(Type.One, "ScanThru", 2),
     11    SCANTO(Type.One, "ScanTo", 2),
     12    ADVANCETHENSCANTHRU(Type.One, "AdvanceThenScanThru", 2),
     13    ADVANCETHENSCANTO(Type.One, "AdvanceThenScanTo", 2),
     14    SPANUPTO(Type.One, "SpanUpTo", 2),
     15    INCLUSIVESPAN(Type.One, "InclusiveSpan", 2),
     16    EXCLUSIVESPAN(Type.One, "ExclusiveSpan", 2),   
    1717
    18     ADVANCE32(CarryType.N, "Advance32", 1),
    19     ADVANCEN(CarryType.N, "Advance", 2),
     18    ADVANCE32(Type.N, "Advance32", 1),
     19    ADVANCEN(Type.N, "Advance", 2),
    2020
    21     MASK(CarryType.None, "Mask", 1),
    22     MASKFW(CarryType.None, "Mask", 2),
     21    MASK(Type.None, "Mask", 1),
     22    MASKFW(Type.None, "MaskFW", 2),
    2323   
    24     ATEOF(CarryType.None, "atEOF", 1),
    25     INFILE(CarryType.None, "inFile", 1),
    26     ASSERTZERO(CarryType.None, "assert_0", 2), 
    27     EOFMASK(CarryType.None, "EOF_mask", 0), // deprecated
     24    ATEOF(Type.None, "atEOF", 1),
     25    INFILE(Type.None, "inFile", 1),
     26    ASSERTZERO(Type.None, "assert_0", 2),       
     27    EOFMASK(Type.None, "EOF_mask", 0), // deprecated
    2828       
    29     PRINTBITBLOCK(CarryType.None, "PrintBitBlock", 1),
    30     ASSERTBITBLOCKALIGN(CarryType.None, "AssertBitBlockAlign", 1);
     29    PRINTBITBLOCK(Type.None, "PrintBitBlock", 1),
     30    ASSERTBITBLOCKALIGN(Type.None, "AssertBitBlockAlign", 1);
    3131   
    32     public enum CarryType{One, N, None};   
     32    private enum Type{One, N, None};   
    3333   
    34     private final CarryType carryType;
     34    private final Type type;
    3535        private final String pabloSName;
    3636        private final int argCount;
    3737       
    38         private Builtins(CarryType carryType, String pabloSName, int argCount) {
    39                 this.carryType = carryType;
     38        private PabloSBuiltins(Type type, String pabloSName, int argCount) {
     39                this.type = type;
    4040                this.pabloSName = pabloSName;
    4141                this.argCount = argCount;
     
    4545        public int argCount() { return this.argCount; }
    4646
    47         public static List<Builtins> carryOneOperations () {
     47        public static List<PabloSBuiltins> carryOneOperations () {
    4848               
    49                 ArrayList<Builtins> carryN = new ArrayList<Builtins>();
     49                ArrayList<PabloSBuiltins> carryOne = new ArrayList<PabloSBuiltins>();
    5050               
    51                 for (Builtins operation : Builtins.values()) {
    52                         if (CarryType.One == operation.carryType) {
    53                                 carryN.add(operation);
     51                for (PabloSBuiltins operation : PabloSBuiltins.values()) {
     52                        if (Type.One == operation.type) {
     53                                carryOne.add(operation);
    5454                        }
    5555                }
    5656               
    57                 return carryN;
     57                return carryOne;
    5858        }       
    5959       
    60         public static List<Builtins> carryNOperations () {
     60        public static List<PabloSBuiltins> carryNOperations () {
    6161               
    62                 ArrayList<Builtins> carryN = new ArrayList<Builtins>();
     62                ArrayList<PabloSBuiltins> carryN = new ArrayList<PabloSBuiltins>();
    6363               
    64                 for (Builtins operation : Builtins.values()) {
    65                         if (CarryType.N == operation.carryType) {
     64                for (PabloSBuiltins operation : PabloSBuiltins.values()) {
     65                        if (Type.N == operation.type) {
    6666                                carryN.add(operation);
    6767                        }
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltins2CPP.java

    r2970 r2971  
    1515import java.util.Map;
    1616
    17 import compilers.pabloB.lang.idisa.SIMD;
     17import compilers.pabloB.lang.idisa.IDISASIMDBuiltins;
    1818
    19 public class PabloSBuiltins2CPP extends Builtins2Lang {
     19public class PabloSBuiltins2CPP extends PabloSBuiltins2Lang {
    2020
    21         private static Map<Builtins, String> pabloS2CPPCode;
     21        private static Map<PabloSBuiltins, String> pabloS2CPPCode;
    2222       
    2323    static {
    2424       
    25         pabloS2CPPCode = new HashMap<Builtins, String>();
     25        pabloS2CPPCode = new HashMap<PabloSBuiltins, String>();
    2626       
    27         pabloS2CPPCode.put(Builtins.ADVANCE,"BitBlock_advance_ci_co");
    28         pabloS2CPPCode.put(Builtins.SCANTOFIRST, "BitBlock_scantofirst");
    29         pabloS2CPPCode.put(Builtins.SCANTHRU, "BitBlock_scanthru_ci_co");
    30         pabloS2CPPCode.put(Builtins.SCANTO, "BitBlock_scanto_ci_co");
    31         pabloS2CPPCode.put(Builtins.ADVANCETHENSCANTHRU, "BitBlock_advance_then_scanthru");
    32         pabloS2CPPCode.put(Builtins.ADVANCETHENSCANTO, "BitBlock_advance_then_scanto");
    33         pabloS2CPPCode.put(Builtins.SPANUPTO, "BitBlock_span_upto");
    34         pabloS2CPPCode.put(Builtins.INCLUSIVESPAN, "BitBlock_inclusive_span");
    35         pabloS2CPPCode.put(Builtins.EXCLUSIVESPAN, "BitBlock_exclusive_span");   
     27        pabloS2CPPCode.put(PabloSBuiltins.ADVANCE,"BitBlock_advance_ci_co");
     28        pabloS2CPPCode.put(PabloSBuiltins.SCANTOFIRST, "BitBlock_scantofirst");
     29        pabloS2CPPCode.put(PabloSBuiltins.SCANTHRU, "BitBlock_scanthru_ci_co");
     30        pabloS2CPPCode.put(PabloSBuiltins.SCANTO, "BitBlock_scanto_ci_co");
     31        pabloS2CPPCode.put(PabloSBuiltins.ADVANCETHENSCANTHRU, "BitBlock_advance_then_scanthru");
     32        pabloS2CPPCode.put(PabloSBuiltins.ADVANCETHENSCANTO, "BitBlock_advance_then_scanto");
     33        pabloS2CPPCode.put(PabloSBuiltins.SPANUPTO, "BitBlock_span_upto");
     34        pabloS2CPPCode.put(PabloSBuiltins.INCLUSIVESPAN, "BitBlock_inclusive_span");
     35        pabloS2CPPCode.put(PabloSBuiltins.EXCLUSIVESPAN, "BitBlock_exclusive_span");   
    3636
    37         pabloS2CPPCode.put(Builtins.ADVANCE32, "BitBlock_advance_n_<%s>");
    38         pabloS2CPPCode.put(Builtins.ADVANCEN, "BitBlock_advance_n_<%s>");
     37        pabloS2CPPCode.put(PabloSBuiltins.ADVANCE32, "BitBlock_advance_n_<%s>");
     38        pabloS2CPPCode.put(PabloSBuiltins.ADVANCEN, "BitBlock_advance_n_<%s>");
    3939
    40         pabloS2CPPCode.put(Builtins.MASK, SIMD.CONSTANT.IDISAConstantLexeme("%s", "1"));
    41         pabloS2CPPCode.put(Builtins.MASKFW, SIMD.CONSTANT.IDISAConstantLexeme("%s", "%s"));
     40        pabloS2CPPCode.put(PabloSBuiltins.MASK, "Mask");
     41        pabloS2CPPCode.put(PabloSBuiltins.MASKFW, "Mask");
    4242       
    43         pabloS2CPPCode.put(Builtins.ATEOF, "atEOF");
    44         pabloS2CPPCode.put(Builtins.INFILE, "inFile");
    45         pabloS2CPPCode.put(Builtins.ASSERTZERO, "assert_0_error");     
    46         pabloS2CPPCode.put(Builtins.EOFMASK, "EOF_mask");
     43        pabloS2CPPCode.put(PabloSBuiltins.ATEOF, "atEOF");
     44        pabloS2CPPCode.put(PabloSBuiltins.INFILE, "inFile");
     45        pabloS2CPPCode.put(PabloSBuiltins.ASSERTZERO, "assert_0_error");       
     46        pabloS2CPPCode.put(PabloSBuiltins.EOFMASK, "EOF_mask");
    4747       
    48         pabloS2CPPCode.put(Builtins.PRINTBITBLOCK, "print_register<BitBlock>");
    49         pabloS2CPPCode.put(Builtins.ASSERTBITBLOCKALIGN, "ASSERT_BITBLOCK_ALIGN");     
     48        pabloS2CPPCode.put(PabloSBuiltins.PRINTBITBLOCK, "print_register<BitBlock>");
     49        pabloS2CPPCode.put(PabloSBuiltins.ASSERTBITBLOCKALIGN, "assert_bitblock_align");       
    5050               
    51         for(Builtins builtin : Builtins.values()) {
     51        for(PabloSBuiltins builtin : PabloSBuiltins.values()) {
    5252                if(!pabloS2CPPCode.containsKey(builtin)) {
    5353                                throw new RuntimeException("PabloS builtin to CPP mapping not unimplemented in :" + PabloSBuiltins2CPP.class.getSimpleName());
     
    5656    }
    5757   
    58         public String getCode(Builtins builtin) {                       
     58        public String getCode(PabloSBuiltins builtin) {                 
    5959                return pabloS2CPPCode.get(builtin);
    6060        }
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltins2Lang.java

    r2956 r2971  
    11package compilers.pabloS.lang;
    22
    3 public abstract class Builtins2Lang {
    4         public abstract String getCode(Builtins builtin);
     3public abstract class PabloSBuiltins2Lang {
     4        public abstract String getCode(PabloSBuiltins builtin);
    55}
  • proto/pabloj/trunk/src/compilers/pabloS/lang/PabloSBuiltinsUtil.java

    r2956 r2971  
    77import pabloS.ast.*;
    88
    9 public class BuiltinsUtil {
     9public class PabloSBuiltinsUtil {
    1010   
    1111    public static final String BUILTIN_PACKAGE_NAME = "pablo";
     
    2525   
    2626        // Advance(X)
    27         if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloSName())
     27        if (isQualifiedName(nameNode, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName())
    2828                && ArgsListNode.nChildren() == 1) { // TODO - update this check to include argument types, refactor to drop arg count
    2929            return true;
     
    3131
    3232        // Advance(X,n)
    33         if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloSName())
     33        if (isQualifiedName(nameNode, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ADVANCE.pabloSName())
    3434                && ArgsListNode.nChildren() == 2) {     // TODO - update this check to include argument types, refactor to drop arg count
    3535                        return true;
     
    4141    public static boolean isBuiltinOperations(ASTNode node) {
    4242       
    43                 for (Builtins builtin : Builtins.values()) {   
    44                 if (isQualifiedName(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName())) {
     43                for (PabloSBuiltins builtin : PabloSBuiltins.values()) {   
     44                if (isQualifiedName(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName())) {
    4545                    return true;
    4646                }               
     
    5252    public static boolean isCarryOne(ASTNode node) {
    5353       
    54                 for (Builtins carryOneOperation : Builtins.carryOneOperations()) {                     
     54                for (PabloSBuiltins carryOneOperation : PabloSBuiltins.carryOneOperations()) {                         
    5555                               
    5656                        ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
    5757                        int argCount = Accessors.funcCallArgCount((FuncCallNode)node);
    5858                       
    59                         if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloSName())
     59                        if (isQualifiedName(identifier, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryOneOperation.pabloSName())
    6060                                && argCount == carryOneOperation.argCount()) {
    6161                    return true;
     
    6767    public static boolean isCarryN(ASTNode node) {
    6868               
    69                 for (Builtins carryNOperation : Builtins.carryNOperations()) {
     69                for (PabloSBuiltins carryNOperation : PabloSBuiltins.carryNOperations()) {
    7070                        ASTNode identifier = Accessors.funcCallIdentifier((FuncCallNode) node);
    7171                        int argCount = Accessors.funcCallArgCount((FuncCallNode) node);
    7272                       
    73                 if (isQualifiedName(identifier, BuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloSName())
     73                if (isQualifiedName(identifier, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, carryNOperation.pabloSName())
    7474                        && argCount == carryNOperation.argCount()) {
    7575                        return true;
     
    9999        ASTNode nameNode = Accessors.funcCallIdentifier(fNode);
    100100
    101         for (Builtins builtin : Builtins.values()) {
    102             if (isQualifiedName(nameNode, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName())) {
     101        for (PabloSBuiltins builtin : PabloSBuiltins.values()) {
     102            if (isQualifiedName(nameNode, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName())) {
    103103                return true;
    104104            }
     
    116116    public static boolean isBuiltInCall(ASTNode node) {
    117117       
    118         for (Builtins builtin : Builtins.values()) {   
    119             if (isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName(), builtin.argCount())) {
     118        for (PabloSBuiltins builtin : PabloSBuiltins.values()) {   
     119            if (isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, builtin.pabloSName(), builtin.argCount())) {
    120120                return true;
    121121            }
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/Transformer.java

    r2970 r2971  
    2323        //private SymbolTable symbolTable;
    2424       
    25         private compilers.pabloS.lang.Builtins2Lang builtins2Lang;
     25        private compilers.pabloS.lang.PabloSBuiltins2Lang builtins2Lang;
    2626        private compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang carrySet2Lang;
    2727        private boolean finalBlockMode;
     
    110110        }
    111111
    112         public Builtins2Lang getBuiltins2Lang() {
     112        public PabloSBuiltins2Lang getBuiltins2Lang() {
    113113                return this.builtins2Lang;
    114114        }
    115115
    116         public void setBuiltins2Lang(Builtins2Lang builtins2Lang) {
     116        public void setBuiltins2Lang(PabloSBuiltins2Lang builtins2Lang) {
    117117                this.builtins2Lang = builtins2Lang;
    118118        }
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AdvanceCombinerXFormer.java

    r2970 r2971  
    1414import compilers.pabloS.ast.Accessors;
    1515import compilers.pabloS.ast.Generators;
    16 import compilers.pabloS.lang.BuiltinsUtil;
     16import compilers.pabloS.lang.PabloSBuiltinsUtil;
    1717
    1818import pabloS.tokens.*;
     
    6565
    6666        private int advanceAmount(FuncCallNode node) {
    67                 assert BuiltinsUtil.isAdvance(node);
     67                assert PabloSBuiltinsUtil.isAdvance(node);
    6868                if(Accessors.funcCallArgsListNode(node).nChildren()==1) {
    6969                        return 1;
     
    7474       
    7575        private boolean isAdvanceOfAdvance(ASTNode node) {
    76                 if(!BuiltinsUtil.isAdvance(node)) {
     76                if(!PabloSBuiltinsUtil.isAdvance(node)) {
    7777                        return false;
    7878                }                       
     
    8080                ASTNode argsList = Accessors.funcCallArgsListNode((FuncCallNode) node);
    8181               
    82                 return BuiltinsUtil.isAdvance(argsList.child(0));
     82                return PabloSBuiltinsUtil.isAdvance(argsList.child(0));
    8383        }
    8484       
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AdvanceNCounterVisitor.java

    r2952 r2971  
    88
    99import pabloS.ast.*;
    10 import compilers.pabloS.lang.BuiltinsUtil;
     10import compilers.pabloS.lang.PabloSBuiltinsUtil;
    1111
    1212public class AdvanceNCounterVisitor {
     
    3131
    3232                public void visitLeave(FuncCallNode node) {
    33                         if(BuiltinsUtil.isCarryN(node)) {
     33                        if(PabloSBuiltinsUtil.isCarryN(node)) {
    3434                            this.advNCount += 1;
    3535                        }
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AssertBitBlockAlignStmtsXFormer.java

    r2970 r2971  
    1313import compilers.pabloS.ast.Accessors;
    1414import compilers.pabloS.ast.Generators;
    15 import compilers.pabloS.lang.Builtins;
    16 import compilers.pabloS.lang.Builtins2Lang;
     15import compilers.pabloS.lang.PabloSBuiltins;
     16import compilers.pabloS.lang.PabloSBuiltins2Lang;
    1717
    1818public class AssertBitBlockAlignStmtsXFormer {
    1919        private ASTNode ASTree;
    2020       
    21         private Builtins2Lang builtins2Lang;
     21        private PabloSBuiltins2Lang builtins2Lang;
    2222       
    23         public AssertBitBlockAlignStmtsXFormer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
     23        public AssertBitBlockAlignStmtsXFormer(ASTNode ASTree, PabloSBuiltins2Lang builtins2Lang) {
    2424                this.ASTree = ASTree;
    2525                this.builtins2Lang = builtins2Lang;
     
    4646                private void addAssertBitBlockAssignStmt(ASTNode node, ASTNode lhs) {
    4747                        FuncCallNode printRegisterStmt =
    48                                         Generators.makeFuncCallNode(  builtins2Lang.getCode(Builtins.ASSERTBITBLOCKALIGN),
     48                                        Generators.makeFuncCallNode(  builtins2Lang.getCode(PabloSBuiltins.ASSERTBITBLOCKALIGN),
    4949                                                                                                                        node.getToken(),
    5050                                                                                                                        new ASTNode [] {lhs});
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/AssertZeroXFormer.java

    r2952 r2971  
    1212import compilers.pabloS.ast.Accessors;
    1313import compilers.pabloS.ast.Generators;
    14 import compilers.pabloS.lang.Builtins;
    15 import compilers.pabloS.lang.Builtins2Lang;
    16 import compilers.pabloS.lang.BuiltinsUtil;
     14import compilers.pabloS.lang.PabloSBuiltins;
     15import compilers.pabloS.lang.PabloSBuiltins2Lang;
     16import compilers.pabloS.lang.PabloSBuiltinsUtil;
    1717
    1818public class AssertZeroXFormer {
    1919        private ASTNode ASTree;
    20         private Builtins2Lang builtins2Lang;
     20        private PabloSBuiltins2Lang builtins2Lang;
    2121
    22         public AssertZeroXFormer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
     22        public AssertZeroXFormer(ASTNode ASTree, PabloSBuiltins2Lang builtins2Lang) {
    2323                this.ASTree = ASTree;
    2424                this.builtins2Lang = builtins2Lang;
     
    5353                public void visitEnter(FuncCallNode node) {
    5454                       
    55                         if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ASSERTZERO.pabloSName(), Builtins.ASSERTZERO.argCount())) {
     55                        if (PabloSBuiltinsUtil.isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.ASSERTZERO.pabloSName(), PabloSBuiltins.ASSERTZERO.argCount())) {
    5656                               
    5757                                assert (node.getParent() instanceof BlockStmtNode);
     
    6363                                                               
    6464                                ASTNode assert0FuncCallNode
    65                                                 = Generators.makeFuncCallNode(builtins2Lang.getCode(Builtins.ASSERTZERO),
     65                                                = Generators.makeFuncCallNode(builtins2Lang.getCode(PabloSBuiltins.ASSERTZERO),
    6666                                                                                                                                node.getToken(),                               
    6767                                                                                                                                new ASTNode [] {errorCode.deepCopy(), errorStream.deepCopy()});
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/Bitwise2IDISAXFormer.java

    r2970 r2971  
    1111import pabloS.tokens.Token;
    1212
    13 import compilers.pabloB.lang.idisa.BitBlock;
    14 import compilers.pabloB.lang.idisa.SIMD;
     13import compilers.pabloB.lang.idisa.IDISABitBlockBuiltins;
     14import compilers.pabloB.lang.idisa.IDISASIMDBitwiseBuiltins;
    1515import compilers.pabloS.ast.Accessors;
    1616import compilers.pabloS.ast.Generators;
     
    4949                                FuncCallNode funcCallNode = null;
    5050                                if(token.isLextant(Lextant.OR)) {
    51                                         funcCallNode = Generators.makeFuncCallNode(SIMD.OR.IDISALexeme(),
     51                                        funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.OR.Name(),
    5252                                                                                                                                token,
    5353                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
     
    5555                                       
    5656                                        if (Accessors.rhs(node).getToken().isLextant(Lextant.NOT)) {                                           
    57                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(),
     57                                                funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(),
    5858                                                                                                                                        token,
    5959                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node).child(0)});
    6060                                        } else if(Accessors.lhs(node).getToken().isLextant(Lextant.NOT)) {
    61                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(),
     61                                                funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.ANDC.Name(),
    6262                                                                                                                                        token,
    6363                                                                                                                                        new ASTNode [] {Accessors.rhs(node), Accessors.lhs(node).child(0)});
    6464                                        } else {
    65                                                 funcCallNode = Generators.makeFuncCallNode(SIMD.AND.IDISALexeme(),
     65                                                funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.AND.Name(),
    6666                                                                                                                                        token,
    6767                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});                                             
     
    6969                                       
    7070                                } else if (token.isLextant(Lextant.XOR)){
    71                                         funcCallNode = Generators.makeFuncCallNode(SIMD.XOR.IDISALexeme(),
     71                                        funcCallNode = Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.XOR.Name(),
    7272                                                                                                                                token,
    7373                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
     
    8989
    9090                                FuncCallNode FuncCallNode =
    91                                                 Generators.makeFuncCallNode(SIMD.NOT.IDISALexeme(),
     91                                                Generators.makeFuncCallNode(IDISASIMDBitwiseBuiltins.NOT.Name(),
    9292                                                                                                                                op,
    9393                                                                                                                                new ASTNode [] {Accessors.operand(node)});                     
     
    108108                public void visitLeave(IfStmtNode node) {
    109109                        ASTNode ifTest = Accessors.ifTest(node);                       
    110                         String FuncName = BitBlock.ANY.IDISALexeme();
     110                        String FuncName = IDISABitBlockBuiltins.ANY.IDISALexeme();
    111111                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest});
    112112                        node.replaceChild(ifTest, FuncCallNode);
     
    121121                                                                                                                               
    122122                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
    123                                         BitBlock.ANY.IDISALexeme(),
     123                                        IDISABitBlockBuiltins.ANY.IDISALexeme(),
    124124                                        node.getToken(),
    125125                                        new ASTNode [] {whileTest});                           
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryCounterVisitor.java

    r2967 r2971  
    88
    99import pabloS.ast.*;
    10 import compilers.pabloS.lang.BuiltinsUtil;
     10import compilers.pabloS.lang.PabloSBuiltinsUtil;
    1111
    1212public class CarryCounterVisitor {
     
    3838                               
    3939                public void visitLeave(FuncCallNode node) {
    40                         if(BuiltinsUtil.isCarryOne(node)) {
     40                        if(PabloSBuiltinsUtil.isCarryOne(node)) {
    4141                            carry1Count += 1;
    4242                        }                       
     
    5252                               
    5353                public void visitLeave(FuncCallNode node) {
    54                         if(BuiltinsUtil.isCarryN(node)) {
     54                        if(PabloSBuiltinsUtil.isCarryN(node)) {
    5555                            carryNCount += 1;
    5656                        }                       
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryInfoSetVisitor.java

    r2967 r2971  
    1111import compilers.pabloB.symbols.SymbolTable;
    1212import compilers.pabloS.ast.Accessors;
    13 import compilers.pabloS.lang.Builtins;
    14 import compilers.pabloS.lang.BuiltinsUtil;
     13import compilers.pabloS.lang.PabloSBuiltins;
     14import compilers.pabloS.lang.PabloSBuiltinsUtil;
    1515import pabloS.ast.*;
    1616
     
    4242                public void visitLeave(FuncCallNode node) {
    4343                       
    44                         if(BuiltinsUtil.isCarryOne(node)) {
    45                                 if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloSName(), Builtins.SCANTOFIRST.argCount())) {
     44                        if(PabloSBuiltinsUtil.isCarryOne(node)) {
     45                                if (PabloSBuiltinsUtil.isCall(node, PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME, PabloSBuiltins.SCANTOFIRST.pabloSName(), PabloSBuiltins.SCANTOFIRST.argCount())) {
    4646                                        ((CarryInfoSetSymbol)symbolTable.get(key)).addCarry1(1);
    4747                                } else {
     
    5050                        }
    5151                       
    52                         if(BuiltinsUtil.isCarryN(node)) {
    53                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    54                                 String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
    55                                 ((CarryInfoSetSymbol)symbolTable.get(key)).addCarryN(Integer.parseInt(value));
     52                        if(PabloSBuiltinsUtil.isCarryN(node)) {
     53                        //      List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     54                        //      String value = Accessors.integerConstantLexeme((IntegerConstantNode)arguments.get(1));
     55                        //      ((CarryInfoSetSymbol)symbolTable.get(key)).addCarryN(Integer.parseInt(value));
    5656                        }
    5757                       
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2970 r2971  
    1010import compilers.pabloB.lang.carrySet.CarrySetBuiltins;
    1111import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
    12 import compilers.pabloB.lang.idisa.SIMD;
     12import compilers.pabloB.lang.idisa.IDISASIMDBuiltins;
    1313import compilers.pabloS.ast.Accessors;
    1414import compilers.pabloS.ast.Generators;
     
    6868               
    6969        private ASTNode ASTTree;       
    70         private Builtins2Lang builtins2Lang;
     70        private PabloSBuiltins2Lang builtins2Lang;
    7171        private CarrySetBuiltins2Lang carrySet2Lang;
    7272       
     
    7474        private String carrySetIdentifier;             
    7575       
    76     public CarryIntroXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {
     76    public CarryIntroXFormer(ASTNode node, PabloSBuiltins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {
    7777        this.ASTTree = node;
    7878        this.builtins2Lang = builtins2Lang;
     
    258258                                                new ASTNode [] {currentAdvN});
    259259                        } else {
    260                                 carryAtCallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("1", "0"), node.getToken());
    261                                 pending64CallOrConstant = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("1", "0"), node.getToken());
     260                                IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
     261                                carryAtCallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});
     262                                pending64CallOrConstant = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});
    262263                        }
    263264                                               
     
    269270                        //                    return c
    270271                       
    271                         if (BuiltinsUtil.isCall(node,
    272                                         BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    273                                         Builtins.ADVANCE.pabloSName(),
    274                                         Builtins.ADVANCE.argCount())) {         
    275                                
    276                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    277                                
    278                                 replaceFuncCallWithCarryCallNode(node,
    279                                                 getCarrySetIdentifier(),
    280                                                 builtins2Lang.getCode(Builtins.ADVANCE),
     272                        if (PabloSBuiltinsUtil.isCall(node,
     273                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     274                                        PabloSBuiltins.ADVANCE.pabloSName(),
     275                                        PabloSBuiltins.ADVANCE.argCount())) {           
     276                               
     277                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     278                               
     279                                replaceFuncCallWithCarryCallNode(node,
     280                                                getCarrySetIdentifier(),
     281                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCE),
    281282                                                arguments,
    282283                                                carryAtCallOrConstant,
     
    292293                        //      return c                                                       
    293294                       
    294                         else if (BuiltinsUtil.isCall(node,
    295                                         BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    296                                         Builtins.SCANTHRU.pabloSName(),
    297                                         Builtins.SCANTHRU.argCount())) {
    298                                
    299                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    300                                
    301                                 replaceFuncCallWithCarryCallNode(node,
    302                                                 getCarrySetIdentifier(),
    303                                                 builtins2Lang.getCode(Builtins.SCANTHRU),
     295                        else if (PabloSBuiltinsUtil.isCall(node,
     296                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     297                                        PabloSBuiltins.SCANTHRU.pabloSName(),
     298                                        PabloSBuiltins.SCANTHRU.argCount())) {
     299                               
     300                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     301                               
     302                                replaceFuncCallWithCarryCallNode(node,
     303                                                getCarrySetIdentifier(),
     304                                                builtins2Lang.getCode(PabloSBuiltins.SCANTHRU),
    304305                                                arguments,
    305306                                                carryAtCallOrConstant,
     
    315316                        //          return c                   
    316317                       
    317                         else if (BuiltinsUtil.isCall(node,
    318                                         BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    319                                         Builtins.ADVANCETHENSCANTHRU.pabloSName(),
    320                                         Builtins.ADVANCETHENSCANTHRU.argCount())) {
    321                                
    322                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    323                                
    324                                 replaceFuncCallWithCarryCallNode(node,
    325                                                 getCarrySetIdentifier(),
    326                                                 builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     318                        else if (PabloSBuiltinsUtil.isCall(node,
     319                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     320                                        PabloSBuiltins.ADVANCETHENSCANTHRU.pabloSName(),
     321                                        PabloSBuiltins.ADVANCETHENSCANTHRU.argCount())) {
     322                               
     323                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     324                               
     325                                replaceFuncCallWithCarryCallNode(node,
     326                                                getCarrySetIdentifier(),
     327                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCETHENSCANTHRU),
    327328                                                arguments,
    328329                                                carryAtCallOrConstant,
     
    338339                        //      return c
    339340                       
    340                         else if (BuiltinsUtil.isCall(node,
    341                                         BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    342                                         Builtins.SPANUPTO.pabloSName(),
    343                                         Builtins.SPANUPTO.argCount())) {
    344                                
    345                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    346                                
    347                                 replaceFuncCallWithCarryCallNode(node,
    348                                                 getCarrySetIdentifier(),
    349                                                 builtins2Lang.getCode(Builtins.SPANUPTO),
     341                        else if (PabloSBuiltinsUtil.isCall(node,
     342                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     343                                        PabloSBuiltins.SPANUPTO.pabloSName(),
     344                                        PabloSBuiltins.SPANUPTO.argCount())) {
     345                               
     346                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     347                               
     348                                replaceFuncCallWithCarryCallNode(node,
     349                                                getCarrySetIdentifier(),
     350                                                builtins2Lang.getCode(PabloSBuiltins.SPANUPTO),
    350351                                                arguments,
    351352                                                carryAtCallOrConstant,
     
    363364                        //          return c                   
    364365                       
    365                         else if (BuiltinsUtil.isCall(node,
    366                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    367                                                 Builtins.ADVANCETHENSCANTO.pabloSName(),
    368                                                 Builtins.ADVANCETHENSCANTO.argCount())) {
     366                        else if (PabloSBuiltinsUtil.isCall(node,
     367                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     368                                                PabloSBuiltins.ADVANCETHENSCANTO.pabloSName(),
     369                                                PabloSBuiltins.ADVANCETHENSCANTO.argCount())) {
    369370                               
    370371                                ASTNode argNode = Accessors.funcCallArg(node, 1);
     
    380381                                replaceFuncCallWithCarryCallNode(node,
    381382                                                getCarrySetIdentifier(),
    382                                                 builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     383                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCETHENSCANTHRU),
    383384                                                arguments,
    384385                                                carryAtCallOrConstant,
     
    396397                        //            return c
    397398       
    398                         else if (BuiltinsUtil.isCall(node,
    399                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    400                                                 Builtins.INCLUSIVESPAN.pabloSName(),
    401                                                 Builtins.INCLUSIVESPAN.argCount())) {
    402                                
    403                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    404                                 replaceFuncCallWithCarryCallNode(node,
    405                                                 getCarrySetIdentifier(),
    406                                                 builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
     399                        else if (PabloSBuiltinsUtil.isCall(node,
     400                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     401                                                PabloSBuiltins.INCLUSIVESPAN.pabloSName(),
     402                                                PabloSBuiltins.INCLUSIVESPAN.argCount())) {
     403                               
     404                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     405                                replaceFuncCallWithCarryCallNode(node,
     406                                                getCarrySetIdentifier(),
     407                                                builtins2Lang.getCode(PabloSBuiltins.INCLUSIVESPAN),
    407408                                                arguments,
    408409                                                carryAtCallOrConstant,
     
    420421                        //            return c
    421422       
    422                         else if (BuiltinsUtil.isCall(node,
    423                                         BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    424                                         Builtins.EXCLUSIVESPAN.pabloSName(),
    425                                         Builtins.EXCLUSIVESPAN.argCount())) {
    426                                
    427                                 List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    428                                 replaceFuncCallWithCarryCallNode(node,
    429                                                 getCarrySetIdentifier(),
    430                                                 builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
     423                        else if (PabloSBuiltinsUtil.isCall(node,
     424                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     425                                        PabloSBuiltins.EXCLUSIVESPAN.pabloSName(),
     426                                        PabloSBuiltins.EXCLUSIVESPAN.argCount())) {
     427                               
     428                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     429                                replaceFuncCallWithCarryCallNode(node,
     430                                                getCarrySetIdentifier(),
     431                                                builtins2Lang.getCode(PabloSBuiltins.EXCLUSIVESPAN),
    431432                                                arguments,
    432433                                                carryAtCallOrConstant,
     
    446447                        //            return c
    447448       
    448                         else if (BuiltinsUtil.isCall(node,
    449                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    450                                                 Builtins.SCANTO.pabloSName(),
    451                                                 Builtins.SCANTO.argCount())) {
     449                        else if (PabloSBuiltinsUtil.isCall(node,
     450                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     451                                                PabloSBuiltins.SCANTO.pabloSName(),
     452                                                PabloSBuiltins.SCANTO.argCount())) {
    452453                               
    453454                                ASTNode argNode = Accessors.funcCallArg(node, 1);
     
    463464                                replaceFuncCallWithCarryCallNode(node,
    464465                                                getCarrySetIdentifier(),
    465                                                 builtins2Lang.getCode(Builtins.SCANTHRU),
     466                                                builtins2Lang.getCode(PabloSBuiltins.SCANTHRU),
    466467                                                arguments,
    467468                                                carryAtCallOrConstant,
     
    478479                        //            return c
    479480
    480                         else if (BuiltinsUtil.isCall(node,
    481                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    482                                                 Builtins.SCANTOFIRST.pabloSName(),
    483                                                 Builtins.SCANTOFIRST.argCount())) {
     481                        else if (PabloSBuiltinsUtil.isCall(node,
     482                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     483                                                PabloSBuiltins.SCANTOFIRST.pabloSName(),
     484                                                PabloSBuiltins.SCANTOFIRST.argCount())) {
    484485
    485486                                // TODO - verify
     
    497498                                replaceFuncCallWithCarryCallNode(node,
    498499                                                getCarrySetIdentifier(),
    499                                                 builtins2Lang.getCode(Builtins.SCANTOFIRST),
     500                                                builtins2Lang.getCode(PabloSBuiltins.SCANTOFIRST),
    500501                                                arguments,
    501502                                                carryAtCallOrConstant,
     
    510511                        //            self.current_adv_n += 1
    511512                        //            return c
    512                         else if (BuiltinsUtil.isCall(node,
    513                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    514                                                 Builtins.ADVANCE32.pabloSName(),
    515                                                 Builtins.ADVANCE32.argCount())) {
     513                        else if (PabloSBuiltinsUtil.isCall(node,
     514                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     515                                                PabloSBuiltins.ADVANCE32.pabloSName(),
     516                                                PabloSBuiltins.ADVANCE32.argCount())) {
    516517                                // TODO - verify implementation.
    517518                               
     
    522523                                replaceFuncCallWithCarryCallNode(node,
    523524                                                getCarrySetIdentifier(),
    524                                                 builtins2Lang.getCode(Builtins.ADVANCE32),
     525                                                builtins2Lang.getCode(PabloSBuiltins.ADVANCE32),
    525526                                                arguments,
    526527                                                pending64CallOrConstant,
     
    535536                        //            self.current_adv_n += 1
    536537                        //            return c         
    537                         else if (BuiltinsUtil.isCall(node,
    538                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    539                                                 Builtins.ADVANCEN.pabloSName(),
    540                                                 Builtins.ADVANCEN.argCount())) {                                       
     538                        else if (PabloSBuiltinsUtil.isCall(node,
     539                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     540                                                PabloSBuiltins.ADVANCEN.pabloSName(),
     541                                                PabloSBuiltins.ADVANCEN.argCount())) {                                 
    541542                               
    542543                                ASTNode formatValue = Accessors.funcCallArg(node, 1);
     
    545546                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
    546547                               
    547                                 String formattedAdvanceN = String.format(builtins2Lang.getCode(Builtins.ADVANCEN), value);
     548                                String formattedAdvanceN = String.format(builtins2Lang.getCode(PabloSBuiltins.ADVANCEN), value);
    548549                               
    549550                                replaceFuncCallWithCarryCallNode(node,
     
    556557                        }                                       
    557558               
    558                         else if (BuiltinsUtil.isCall(node,
    559                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    560                                                 Builtins.ATEOF.pabloSName(),
    561                                                 Builtins.ATEOF.argCount())) {
     559                        else if (PabloSBuiltinsUtil.isCall(node,
     560                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     561                                                PabloSBuiltins.ATEOF.pabloSName(),
     562                                                PabloSBuiltins.ATEOF.argCount())) {
    562563                                 
    563564                                if(isFinalBlockMode()) {
    564565                                        ASTNode argNode = Accessors.funcCallArg(node, 0);
    565566                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    566                                 } else {
    567                                         replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.IDISAConstantLexeme("1", "0"), node.getToken());                                   
     567                                } else {                                       
     568                                        IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
     569                                        replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});                                   
    568570                                }
    569571                                node.updateSelf(replacementNode);
     
    575577                        //              return callnode.args[0]
    576578                        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
    577                         else if (BuiltinsUtil.isCall(node,
    578                                                 BuiltinsUtil.BUILTIN_PACKAGE_NAME,
    579                                                 Builtins.INFILE.pabloSName(),
    580                                                 Builtins.INFILE.argCount())) {
     579                        else if (PabloSBuiltinsUtil.isCall(node,
     580                                                PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     581                                                PabloSBuiltins.INFILE.pabloSName(),
     582                                                PabloSBuiltins.INFILE.argCount())) {
    581583                               
    582584                                if(isFinalBlockMode()) {                                       
     
    613615                        //                    #dump_Call(callnode)
    614616                        //                    return callnode
     617                        else if (PabloSBuiltinsUtil.isCall(node,
     618                                        PabloSBuiltinsUtil.BUILTIN_PACKAGE_NAME,
     619                                        PabloSBuiltins.MASK.pabloSName(),
     620                                        PabloSBuiltins.MASK.argCount())) {
     621                               
     622                                        ASTNode fieldWidth = Accessors.funcCallArg(node, 0);
     623                                        ASTNode value = Accessors.funcCallArg(node, 1);
     624                               
     625                                        IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
     626                                        replacementNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name("1"), node.getToken(), new ASTNode [] {zero});                           
     627                                       
     628                                        node.updateSelf(replacementNode);
     629                        }
    615630                        else {
    616631                                // do nothing // TODO - allow calls to pass ?
     
    754769                        //          return ast.If(new_test, whileNode.body + [inner_while], else_part)
    755770                       
    756                        
    757771                        // if condition
    758772                        ASTNode ifTest = Accessors.whileTest(node).deepCopy();
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/DumpAssignStmtsXFormer.java

    r2970 r2971  
    1313import compilers.pabloS.ast.Accessors;
    1414import compilers.pabloS.ast.Generators;
    15 import compilers.pabloS.lang.Builtins;
    16 import compilers.pabloS.lang.Builtins2Lang;
     15import compilers.pabloS.lang.PabloSBuiltins;
     16import compilers.pabloS.lang.PabloSBuiltins2Lang;
    1717
    1818public class DumpAssignStmtsXFormer {
    1919        private ASTNode ASTree;
    20         private Builtins2Lang builtins2Lang;
     20        private PabloSBuiltins2Lang builtins2Lang;
    2121       
    22         public DumpAssignStmtsXFormer(ASTNode ASTree, Builtins2Lang builtins2Lang) {
     22        public DumpAssignStmtsXFormer(ASTNode ASTree, PabloSBuiltins2Lang builtins2Lang) {
    2323                this.ASTree = ASTree;
    2424                this.builtins2Lang = builtins2Lang;
     
    4545                private void addDumpStmt(ASTNode node, ASTNode lhs) {
    4646                        FuncCallNode printRegisterStmt =
    47                                         Generators.makeFuncCallNode(  builtins2Lang.getCode(Builtins.PRINTBITBLOCK),
     47                                        Generators.makeFuncCallNode(  builtins2Lang.getCode(PabloSBuiltins.PRINTBITBLOCK),
    4848                                                                                                                        node.getToken(),
    4949                                                                                                                        new ASTNode [] {lhs});
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/InitStreamDefaultsXFormer.java

    r2970 r2971  
    1515import pabloS.tokens.Token;
    1616
    17 import compilers.pabloB.lang.idisa.BitBlock;
    18 import compilers.pabloB.lang.idisa.SIMD;
     17import compilers.pabloB.lang.idisa.IDISABitBlockBuiltins;
     18import compilers.pabloB.lang.idisa.IDISASIMDBuiltins;
    1919import compilers.pabloS.ast.Accessors;
    2020import compilers.pabloS.ast.Generators;
     
    4646                                if(type instanceof StreamTypeNode) {
    4747                                       
    48                                         String fieldWidth = "0";
     48                                        String fieldWidth = "1";
    4949                                       
    5050                                        if(Accessors.hasFieldWidth((StreamTypeNode)type)) {
     
    5252                                        }
    5353                                       
    54                                         String name = SIMD.CONSTANT.IDISAConstantLexeme(fieldWidth,"0");
    55                                         FuncCallNode funcCallNode = Generators.makeFuncCallNode(name, node.getToken());
     54                                        IntegerConstantNode zero = Generators.makeIntegerConstantNode(0, node.getToken());
     55                                        FuncCallNode funcCallNode = Generators.makeFuncCallNode(IDISASIMDBuiltins.CONSTANT.Name(fieldWidth), node.getToken(), new ASTNode [] {zero});
    5656                                       
    5757                                        LocalVarDeclNode localVarDeclNode = Generators.makeLocalVarDeclNode(type, identifier, funcCallNode, node.getToken());
Note: See TracChangeset for help on using the changeset viewer.