Changeset 3211 for proto/pabloj


Ignore:
Timestamp:
May 28, 2013, 10:08:40 PM (6 years ago)
Author:
shermer
Message:

Work towards a typechecker:
Added signatures for the PabloSBuiltins.
Made a StreamType? factory that dispenses pre-made instances depending on fieldWidth.
Changed grammar to use said factory and to allow no qualifed names with more than two identifiers.

Location:
proto/pabloj/trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r3192 r3211  
    139139        integerConstant                 ->      INTEGER_CONST {@value = @@value;} ;
    140140        stringConstant                  ->      STRING | SQ_STRING ;   
    141         compoundIdentifier              #-> identifier (DOT^ identifier)*;
     141        compoundIdentifier              #-> identifier (DOT^ identifier)?;
    142142        identifier                              ->      IDENTIFIER ;
    143143    funcCallRest                        ->      LROUND^ funcCallArgList RROUND ;
     
    156156
    157157        streamType                      ->              STREAM fieldWidthSpecifier! {   @fieldWidth = @:value;
    158                                                                                                                                 @type = {{ new StreamType(%?) }} , @fieldWidth ;
     158                                                                                                                                @type = {{ StreamType.STREAM(%?) }} , @fieldWidth ;
    159159                                                                                                                } ;
    160160                                       
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3192 r3211  
    10061006                        allChildren.add(child);
    10071007                }
    1008                 while( nowReading.isLextant(Lextant.DOT) ) {
     1008                if( nowReading.isLextant(Lextant.DOT) ) {
    10091009                        result.setToken(nowReading);
    10101010                        expect(Lextant.DOT);
     
    12311231                        StreamTypeNode temp_24 = (StreamTypeNode)temp_22;
    12321232                        int temp_23 = temp_24.getFieldWidth();
    1233                         temp_21.setType(  new StreamType(temp_23)  );
     1233                        temp_21.setType(  StreamType.STREAM(temp_23)  );
    12341234                }
    12351235                if(allowCompression) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3210 r3211  
    11package toolchain.pabloS.lang;
    22
    3 import java.util.ArrayList;
    43import java.util.HashMap;
    5 import java.util.List;
    64import java.util.Map;
    75
     6import toolchain.pabloS.lang.signatures.FunctionSignature;
     7import toolchain.pabloS.lang.type.PrimitiveType;
     8import static toolchain.pabloS.lang.type.StreamType.STREAM;
     9
    810public enum PabloSBuiltin {
     11    ADVANCE(               "Advance",             CarryType.One, sig_S_S()  ),
     12    SCAN_TO_FIRST(         "ScanToFirst",         CarryType.One, sig_S_S()  ),
     13    SCAN_THRU(             "ScanThru",            CarryType.One, sig_SS_S() ),
     14    SCAN_TO(               "ScanTo",              CarryType.One, sig_SS_S() ),
     15    SPAN_UP_TO(            "SpanUpTo",            CarryType.One, sig_SS_S() ),
     16    INCLUSIVE_SPAN(        "InclusiveSpan",       CarryType.One, sig_SS_S() ),
     17    EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, sig_SS_S() ),
     18    ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, sig_SS_S()  ),
     19    ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, sig_SS_S()  ),
     20   
     21    ADVANCE_N(    "Advance",   CarryType.N,    sig_SI_S() ),   
     22    ADVANCE_32(   "Advance32", CarryType.N,    sig_S_S()  ),
    923
    10         // // TODO - Update explicit arg types
    11     ADVANCE("Advance", CarryType.One, 1),
    12     SCANTO_FIRST("ScanToFirst", CarryType.One, 1),
    13     SCAN_THRU("ScanThru", CarryType.One, 2),
    14     SCAN_TO("ScanTo", CarryType.One, 2),
    15     ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, 2),
    16     ADVANCE_THEN_SCAN_TO("AdvanceThenScanTo", CarryType.One, 2),
    17     SPAN_UP_TO("SpanUpTo", CarryType.One, 2),
    18     INCLUSIVE_SPAN("InclusiveSpan", CarryType.One, 2),
    19     EXCLUSIVE_SPAN("ExclusiveSpan", CarryType.One, 2),   
    20    
    21     ADVANCE_N("Advance", CarryType.N, 2),   
    22     ADVANCE_32("Advance32", CarryType.N, 1),
    23 
    24     MASK("Mask", CarryType.None, 2),   
    25     AT_EOF("atEOF", CarryType.None, 1),
    26     IN_FILE("inFile", CarryType.None, 1),
    27     ASSERT_ZERO("assert_0", CarryType.None, 2),
    28     EOF_MASK("EOF_mask", CarryType.None, 0), // deprecated
    29     NULL_BUILTIN("NULL", CarryType.None, 0);
     24    MASK(         "Mask",      CarryType.None, sig_SS_S() ),   
     25    AT_EOF(       "atEOF",     CarryType.None, sig_S_S()  ),
     26    IN_FILE(      "inFile",    CarryType.None, sig_S_S()  ),
     27    ASSERT_ZERO(  "assert_0",  CarryType.None, sig_ST_V() ),   
     28    EOF_MASK(     "EOF_mask",  CarryType.None, sig_I_S()  ), // deprecated
     29    NULL_BUILTIN( "NULL",      CarryType.None, sig_V_V()  );
    3030
    3131    public enum CarryType{One, N, None};   
    3232   
    33     private final CarryType type;
     33    private final CarryType carryType;
    3434        private final String name;
    35         private final int argCount;
     35        @SuppressWarnings("unused")
     36        private final FunctionSignature signature;
    3637       
    37         private PabloSBuiltin(String name, CarryType type, int argCount) {
    38                 this.type = type;
     38        private PabloSBuiltin(String name, CarryType carryType, int argCount) {
     39                this.carryType = carryType;
    3940                this.name = name;
    40                 this.argCount = argCount;
     41                this.signature = null;
    4142        }
    42 
     43        private PabloSBuiltin(String name, CarryType carryType, FunctionSignature signature) {
     44                this.name = name;
     45                this.carryType = carryType;
     46                this.signature = signature;
     47        }
     48       
     49        /////////////////////////////////////////////////////////////////
     50        // signature encoding:
     51        //      sig_S_S         (STREAM(1)) -> STREAM(1)
     52        //  sig_SS_S    (STREAM(1), STREAM(1)) -> STREAM(1)
     53        //  sig_SI_S    (STREAM(1), INTEGER) -> STREAM(1)
     54        //  sig_ST_V    (STREAM(1), STRING) -> VOID
     55        //  sig_I_S             (INTEGER) -> STREAM(1)
     56        //  sig_V_V             (VOID) -> VOID
     57        /////////////////////////////////////////////////////////////////
     58        static private FunctionSignature sig_S_S() {
     59                return new FunctionSignature(STREAM(1), STREAM(1));
     60        }
     61        static private FunctionSignature sig_SS_S() {
     62                return new FunctionSignature(STREAM(1), STREAM(1), STREAM(1));
     63        }
     64        static private FunctionSignature sig_SI_S() {
     65                return new FunctionSignature(STREAM(1), PrimitiveType.INTEGER, STREAM(1));
     66        }
     67        static private FunctionSignature sig_ST_V() {
     68                return new FunctionSignature(STREAM(1), PrimitiveType.STRING, PrimitiveType.VOID);
     69        }
     70        static private FunctionSignature sig_I_S() {
     71                return new FunctionSignature(PrimitiveType.INTEGER, STREAM(1));
     72        }
     73        static private FunctionSignature sig_V_V() {
     74                return new FunctionSignature(PrimitiveType.VOID, PrimitiveType.VOID);
     75        }
     76       
     77        /////////////////////////////////////////////////////////////////
     78        // forName(String)  mechanism
     79        /////////////////////////////////////////////////////////////////
    4380        static private Map<String, PabloSBuiltin> builtinForName = new HashMap<String, PabloSBuiltin>();
    4481        static {
     
    4784                }
    4885        }
    49         public String pabloSName() { return this.name; }
    50         public int argCount() { return this.argCount; }
    51         public final CarryType getCarryType() { return type; }
    52         public final boolean isCarry1() { return type == CarryType.One; }
    53         public final boolean isCarryN() { return type == CarryType.N; }
    54        
    55         public static List<PabloSBuiltin> carryOneOperations () {
    56                
    57                 ArrayList<PabloSBuiltin> carryOne = new ArrayList<PabloSBuiltin>();
    58                
    59                 for (PabloSBuiltin operation : PabloSBuiltin.values()) {
    60                         if (CarryType.One == operation.type) {
    61                                 carryOne.add(operation);
    62                         }
    63                 }
    64                
    65                 return carryOne;
    66         }       
    67        
    68         public static List<PabloSBuiltin> carryNOperations () {
    69                
    70                 ArrayList<PabloSBuiltin> carryN = new ArrayList<PabloSBuiltin>();
    71                
    72                 for (PabloSBuiltin operation : PabloSBuiltin.values()) {
    73                         if (CarryType.N == operation.type) {
    74                                 carryN.add(operation);
    75                         }
    76                 }
    77                 return carryN;
    78         }
    79 
    8086        public static PabloSBuiltin forName(String builtinName) {
    8187                if(builtinForName.containsKey(builtinName)) {
     
    8490                return NULL_BUILTIN;
    8591        }
     92       
     93        /////////////////////////////////////////////////////////////////
     94        // queries
     95        /////////////////////////////////////////////////////////////////
     96        public String pabloSName() { return this.name; }
     97        public final CarryType getCarryType() { return carryType; }
     98        public final boolean isCarry1() { return carryType == CarryType.One; }
     99        public final boolean isCarryN() { return carryType == CarryType.N; }
     100
    86101}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2C.java

    r3208 r3211  
    1313       
    1414        pabloS2CCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
    15         pabloS2CCode.put(PabloSBuiltin.SCANTO_FIRST, "BitBlock_scantofirst");
     15        pabloS2CCode.put(PabloSBuiltin.SCAN_TO_FIRST, "BitBlock_scantofirst");
    1616        pabloS2CCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
    1717        pabloS2CCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
     
    3030        pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error"); 
    3131        pabloS2CCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
     32        pabloS2CCode.put(PabloSBuiltin.NULL_BUILTIN, "null_builtin_error");
    3233
    3334        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2CPP.java

    r3208 r3211  
    2424       
    2525        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
    26         pabloS2CPPCode.put(PabloSBuiltin.SCANTO_FIRST, "BitBlock_scantofirst");
     26        pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO_FIRST, "BitBlock_scantofirst");
    2727        pabloS2CPPCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
    2828        pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
     
    4141        pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error");       
    4242        pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
     43        pabloS2CPPCode.put(PabloSBuiltin.NULL_BUILTIN, "null_builtin_error");
     44       
    4345               
    4446        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/signatures/FunctionSignature.java

    r3137 r3211  
    5252                }
    5353                for(int i=0; i<paramTypes.length; i++) {
    54                         if(!unifiable(paramTypes[i], types.get(i))) {
     54                        if(!assignableTo(paramTypes[i], types.get(i))) {
    5555                                return false;
    5656                        }
     
    7777                }
    7878        };
    79        
    8079        public static FunctionSignature nullInstance() {
    8180                return neverMatchedSignature;
    8281        }
     82       
    8383        public String toString() {
    8484                StringBuilder result = new StringBuilder();
     
    9292                return result.toString();
    9393        }
    94        
    95 
    9694}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/type/StreamType.java

    r3204 r3211  
    11package toolchain.pabloS.lang.type;
    22
    3 //TODO - A dummy class to get PabloJ to compile.
     3import java.util.HashMap;
     4import java.util.Map;
     5
    46
    57public class StreamType implements Type {
     8        // forInteger holds all allowable StreamTypes.
     9        // StreamType is immutable, so these are the only instances ever created.
     10        static private Map<Integer, StreamType> forInteger = new HashMap<Integer, StreamType>();
     11        static {
     12                for(int powerOfTwo = 1; powerOfTwo <= 64; powerOfTwo = powerOfTwo*2) {
     13                        forInteger.put(powerOfTwo, new StreamType(powerOfTwo));
     14                }
     15        }
    616       
    7         public StreamType(int fieldWidth) {
     17        private final int fieldWidth;
     18        private StreamType(int fieldWidth) {
    819                this.fieldWidth = fieldWidth;
    920        }
     21       
    1022       
    1123        public int getFieldWidth() {
    1224                return fieldWidth;
    1325        }
    14 
    15         private final int fieldWidth;
    1626       
    1727        @Override
     
    2232        @Override
    2333        public Type unify(Type otherType) {
    24                 if(otherType instanceof StreamType) {
    25                         StreamType otherStream = (StreamType)otherType;
    26                         if(otherStream.fieldWidth == fieldWidth) {
    27                                 return this;
    28                         }
     34                if(otherType == this) {
     35                        return this;
    2936                }
    3037                return PrimitiveType.NO_MATCH;
     
    3542                return this.toString();
    3643        }
     44
     45        // naming convention overridden to make this factory look a bit like a static.
     46        public static Type STREAM(int fieldWidth) {
     47                if(forInteger.containsKey(fieldWidth)) {
     48                        return forInteger.get(fieldWidth);
     49                }
     50                // question: is this what we want for error handling?  Should maybe log an error?
     51                return PrimitiveType.ERROR;
     52        }
     53        public static boolean isValidFieldwidth(int fieldWidth) {
     54                return forInteger.containsKey(fieldWidth);
     55        }
    3756}
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/BuiltinTranslator.java

    r3210 r3211  
    55
    66import pabloS.ast.ASTNode;
    7 import pabloS.ast.CompoundIdentifierNode;
    87import pabloS.ast.FuncCallNode;
    98import pabloS.ast.IntegerConstantNode;
     
    2120        INCLUSIVESPAN(PabloSBuiltin.INCLUSIVE_SPAN),
    2221        EXCLUSIVESPAN(PabloSBuiltin.EXCLUSIVE_SPAN),
    23         SCANTOFIRST(PabloSBuiltin.SCANTO_FIRST),                        // TODO: verify that this is basicAction and not scanToAction
     22        SCANTOFIRST(PabloSBuiltin.SCAN_TO_FIRST),                       // TODO: verify that this is basicAction and not scanToAction
    2423        ADVANCE32(PabloSBuiltin.ADVANCE_32),
    2524                //advance32 came with this in its action, commented out:                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);         
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/visitors/carry/CarryInfoSetVisitor.java

    r3210 r3211  
    4141                       
    4242                        if(BuiltinCallUtil.isCarry1(node)) {
    43                                 if (BuiltinCallUtil.isBuiltInCall(node, PabloSBuiltin.SCANTO_FIRST)) {
     43                                if (BuiltinCallUtil.isBuiltInCall(node, PabloSBuiltin.SCAN_TO_FIRST)) {
    4444                                        ((CarryInfoSetSymbol)symbolTable.get(key)).addCarry1(1);
    4545                                } else {
Note: See TracChangeset for help on using the changeset viewer.