Changeset 3259 for proto/pabloj/trunk


Ignore:
Timestamp:
Jun 3, 2013, 6:27:04 PM (6 years ago)
Author:
shermer
Message:

End-of-workday commit. More work towards semantic analyzer.

Location:
proto/pabloj/trunk
Files:
7 added
12 edited

Legend:

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

    r3254 r3259  
    1010
    1111types {
     12        toolchain.pabloS.lang.signatures.FunctionSignature,
    1213        toolchain.pabloS.lang.type.Type,
    1314        toolchain.pabloS.lang.type.PrimitiveType,
     
    7677         hasBinding     {Binding binding = null;},
    7778         hasFieldWidth  {int fieldWidth = 1;},
     79         hasSignature   {FunctionSignature signature = null;},
    7880}
    7981
     
    8789  compoundIdentifier {hasBinding;} [],
    8890 
    89   binaryOperator {} [expr expr1 expr3 expr4],
    90   unaryOperator  {} [expr2],   
    91   funcCall       {} [funcCallRest],
     91  binaryOperator {hasSignature;} [expr expr1 expr3 expr4],
     92  unaryOperator  {hasSignature;} [expr2],       
     93  funcCall       {hasSignature;} [funcCallRest],
    9294  assign         {} [assignRest],
    9395 
  • proto/pabloj/trunk/src/pabloS/ast/ASTNode.java

    r3192 r3259  
    2525       
    2626        Token token;
    27         int productionTag = NO_TAG;
     27        int productionTag;
    2828        boolean simplifiable;
    29         boolean compressed = false;
    3029       
    3130        private Type type = null;
     
    8382                return productionTag;
    8483        }
    85         public void setCompressed() {
    86                 compressed = true;
    87         }
    88         public boolean isCompressed() {
    89                 return compressed;
    90         }
     84       
    9185        public void setSimplifiable(boolean value) {
    9286                simplifiable = value;
  • proto/pabloj/trunk/src/pabloS/ast/BinaryOperatorNode.java

    r3004 r3259  
    1010import java.util.List;
    1111
     12import toolchain.pabloS.lang.signatures.FunctionSignature;
    1213
    1314
    14 public class BinaryOperatorNode extends ASTNode  {
     15public class BinaryOperatorNode extends ASTNode implements HasSignatureNodeType {
     16        private FunctionSignature signature = null;
    1517
    1618
     
    2022        public BinaryOperatorNode(BinaryOperatorNode node) {
    2123                super(node);
     24                this.signature = node.signature;
    2225
    2326        }
     
    3841        // attribute accessors
    3942
     43        public FunctionSignature getSignature() {
     44                return signature;
     45        }
     46        public void setSignature(FunctionSignature _value_) {
     47                signature = _value_;
     48        }
     49       
    4050
    4151       
     
    4959                        result += ", ";
    5060                }
     61                result += "signature = " + signature + ", ";
    5162
    5263                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloS/ast/FuncCallNode.java

    r3004 r3259  
    1010import java.util.List;
    1111
     12import toolchain.pabloS.lang.signatures.FunctionSignature;
    1213
    1314
    14 public class FuncCallNode extends ASTNode  {
     15public class FuncCallNode extends ASTNode implements HasSignatureNodeType {
     16        private FunctionSignature signature = null;
    1517
    1618
     
    2022        public FuncCallNode(FuncCallNode node) {
    2123                super(node);
     24                this.signature = node.signature;
    2225
    2326        }
     
    3841        // attribute accessors
    3942
     43        public FunctionSignature getSignature() {
     44                return signature;
     45        }
     46        public void setSignature(FunctionSignature _value_) {
     47                signature = _value_;
     48        }
     49       
    4050
    4151       
     
    4959                        result += ", ";
    5060                }
     61                result += "signature = " + signature + ", ";
    5162
    5263                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloS/ast/UnaryOperatorNode.java

    r3004 r3259  
    1010import java.util.List;
    1111
     12import toolchain.pabloS.lang.signatures.FunctionSignature;
    1213
    1314
    14 public class UnaryOperatorNode extends ASTNode  {
     15public class UnaryOperatorNode extends ASTNode implements HasSignatureNodeType {
     16        private FunctionSignature signature = null;
    1517
    1618
     
    2022        public UnaryOperatorNode(UnaryOperatorNode node) {
    2123                super(node);
     24                this.signature = node.signature;
    2225
    2326        }
     
    3841        // attribute accessors
    3942
     43        public FunctionSignature getSignature() {
     44                return signature;
     45        }
     46        public void setSignature(FunctionSignature _value_) {
     47                signature = _value_;
     48        }
     49       
    4050
    4151       
     
    4959                        result += ", ";
    5060                }
     61                result += "signature = " + signature + ", ";
    5162
    5263                if(result.isEmpty()) return result;
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3254 r3259  
    2020import pabloS.lexicalAnalyzer.Lextant;
    2121
     22import toolchain.pabloS.lang.signatures.FunctionSignature;
    2223import toolchain.pabloS.lang.type.StreamType;
    2324import toolchain.pabloS.semanticAnalyzer.Binding;
     
    13451346        // return node or, if it has one child, its single child.       
    13461347        private ASTNode compressIfPossible(ASTNode node) {
    1347                 if(node.nChildren() != 1) {
    1348                         return node;
    1349                 }
    1350                 ASTNode result = node.child(0);
    1351                 result.setCompressed();
    1352                 return result;
     1348                return node.nChildren() == 1 ? node.child(0) : node;
    13531349        }
    13541350       
     
    13621358                ASTNode left   = top.child(0);
    13631359                ASTNode newTop = top.child(1);
     1360                if((newTop.nChildren() != 2) || !fromSameProduction(top, newTop)) {
     1361                        return top;
     1362                }
     1363                ASTNode middle = newTop.child(0);
     1364                ASTNode right = newTop.child(1);
    13641365               
    1365                 if( (newTop.nChildren() == 2)  &&  fromSameProduction(top, newTop) ) {
    1366                         ASTNode middle = newTop.child(0);
    1367                         ASTNode right = newTop.child(1);
    1368 
    1369                         top.initChildren();
    1370                         top.appendChild(left);
    1371                         top.appendChild(middle);
    1372                         top = rotateLeftIfPossible(top);
    1373 
    1374                         newTop.initChildren();
    1375                         newTop.appendChild(top);
    1376                         newTop.appendChild(right);
    1377 
    1378                         return newTop;
    1379                 }
    1380                 else  {
    1381                         return top;
    1382                 }
     1366                top.initChildren();
     1367                top.appendChild(left);
     1368                top.appendChild(middle);
     1369                top = rotateLeftIfPossible(top);
     1370               
     1371                newTop.initChildren();
     1372                newTop.appendChild(top);
     1373                newTop.appendChild(right);
     1374               
     1375                return newTop;
    13831376        }
    13841377        private boolean fromSameProduction(ASTNode node1, ASTNode node2) {
    1385                 return (node1.getProductionTag() == node2.getProductionTag()) &&
    1386                            !node1.isCompressed() &&
    1387                            !node2.isCompressed();
     1378                return node1.getProductionTag() == node2.getProductionTag();
    13881379        }
    13891380        private ASTNode promoteLastChild(ASTNode tree) {
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3253 r3259  
    1111
    1212import pabloS.ast.*;
     13import toolchain.pabloS.lang.type.Type;
    1314
    1415import java.util.ArrayList;
     
    236237        ////////////////////////////////////////////////////////////////////////////
    237238       
    238         public static String assignOperatorLexeme(FuncCallNode node) {
    239                 return node.getToken().getLexeme();
    240         }
    241239        public static ASTNode nameNode(FuncCallNode node) {
    242240                return node.child(0);
     
    281279    }   
    282280
     281        public static List<Type> argumentTypes(FuncCallNode node) {
     282                return childTypes(argsListNode(node));
     283        }
    283284
    284285        ////////////////////////////////////////////////////////////////////////////
     
    339340        // CompoundIdentifierNode
    340341        ////////////////////////////////////////////////////////////////////////////
     342
     343        public static String nameBefore(CompoundIdentifierNode compound, ASTNode lastChild) {
     344                StringBuilder result = new StringBuilder();
     345                List<ASTNode> children = compound.getChildren();
     346                for(int i=0;i<children.size(); i++) {
     347                        ASTNode child = children.get(i);
     348                        if(child==lastChild) {
     349                                break;
     350                        }
     351                        if(i > 0) {
     352                                result.append(".");
     353                        }
     354                        result.append(lexeme(child));
     355                }
     356                return result.toString();
     357        }
     358        public static String nameUpTo(CompoundIdentifierNode compound, ASTNode lastChild) {
     359                StringBuilder result = new StringBuilder();
     360                List<ASTNode> children = compound.getChildren();
     361                for(int i=0;i<children.size(); i++) {
     362                        ASTNode child = children.get(i);
     363                        if(i > 0) {
     364                                result.append(".");
     365                        }
     366                        result.append(lexeme(child));
     367                       
     368                        if(child==lastChild) {
     369                                break;
     370                        }
     371                }
     372                return result.toString();
     373        }
    341374        public static String pckageName(CompoundIdentifierNode compound) {
    342375                ASTNode pckageNode = pckageNode(compound);
     
    353386                return compound.child(1);
    354387        }
     388        public static String name(CompoundIdentifierNode compound) {
     389                return nameUpTo(compound, null);
     390        }
    355391       
    356392        ////////////////////////////////////////////////////////////////////////////
     
    368404                return node.getToken().getLexeme();
    369405        }                       
     406        public static ASTNode headChild(ASTNode node) {
     407                return node.child(0);
     408        }
     409        public static List<ASTNode> tailChildren(ASTNode compound) {
     410                List<ASTNode> children = compound.getChildren();
     411                return children.subList(1, children.size());
     412        }
     413        public static List<Type> childTypes(ASTNode node) {
     414                List<Type> result = new ArrayList<Type>(node.nChildren());
     415                for(ASTNode child: node.getChildren()) {
     416                        result.add(child.getType());
     417                }
     418                return result;
     419        }
    370420
    371421}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3245 r3259  
    55
    66import toolchain.pabloS.lang.signatures.FunctionSignature;
    7 import toolchain.pabloS.lang.type.PrimitiveType;
    8 import static toolchain.pabloS.lang.type.StreamType.STREAM;
    97import static toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator.*;
     8import static toolchain.pabloS.lang.signatures.SignatureShorthand.*;
    109import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
    1110
     
    3736    private final InitialValue initialValue;
    3837        private final String name;
    39         @SuppressWarnings("unused")
    4038        private final FunctionSignature signature;
    4139        private final BuiltinTranslator translator;
     
    5553       
    5654       
    57         /////////////////////////////////////////////////////////////////
    58         // signature encoding:
    59         //      sig_S_S         (STREAM(1)) -> STREAM(1)
    60         //  sig_SS_S    (STREAM(1), STREAM(1)) -> STREAM(1)
    61         //  sig_SI_S    (STREAM(1), INTEGER) -> STREAM(1)
    62         //  sig_II_S    (INTEGER, INTEGER) -> STREAM(1)
    63         //  sig_ST_V    (STREAM(1), STRING) -> VOID
    64         //  sig_V_S             (VOID) -> STREAM(1)
    65         //  sig_V_V             (VOID) -> VOID
    66         /////////////////////////////////////////////////////////////////
    67         static private FunctionSignature sig_S_S() {
    68                 return new FunctionSignature(STREAM(1), STREAM(1));
    69         }
    70         static private FunctionSignature sig_SS_S() {
    71                 return new FunctionSignature(STREAM(1), STREAM(1), STREAM(1));
    72         }
    73         static private FunctionSignature sig_SI_S() {
    74                 return new FunctionSignature(STREAM(1), PrimitiveType.INTEGER, STREAM(1));
    75         }
    76         static private FunctionSignature sig_II_S() {
    77                 return new FunctionSignature(PrimitiveType.INTEGER, PrimitiveType.INTEGER, STREAM(1));
    78         }
    79         static private FunctionSignature sig_ST_V() {
    80                 return new FunctionSignature(STREAM(1), PrimitiveType.STRING, PrimitiveType.VOID);
    81         }
    82         static private FunctionSignature sig_V_S() {
    83                 return new FunctionSignature(PrimitiveType.VOID, STREAM(1));
    84         }
    85         static private FunctionSignature sig_V_V() {
    86                 return new FunctionSignature(PrimitiveType.VOID, PrimitiveType.VOID);
    87         }
     55
    8856       
    8957        /////////////////////////////////////////////////////////////////
     
    11381        public final InitialValue getInitialValue() { return initialValue; }
    11482        public final int intInitialValue() { return (initialValue == InitialValue.One) ? 1 : 0; }
    115        
     83
     84        public FunctionSignature getSignature() { return signature; }
     85
    11686}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/type/StreamStructure.java

    r3162 r3259  
    11package toolchain.pabloS.lang.type;
    22
    3 // TODO - A dummy class to get PabloJ to compile.
     3import toolchain.pabloS.semanticAnalyzer.SymbolTable;
    44
    5 public class StreamStructure { // implements Type {
     5public class StreamStructure implements CompoundType {
     6        private SymbolTable symbolTable;
     7       
     8       
     9        public StreamStructure(SymbolTable symbolTable) {
     10                super();
     11                this.symbolTable = symbolTable;
     12        }
     13
     14        @Override
     15        public String infoString() {
     16                return null;
     17        }
     18
     19        @Override
     20        public Type unify(Type otherType) {
     21                return this == otherType ? this : PrimitiveType.NO_MATCH;
     22        }
     23
     24        @Override
     25        public Type getConcreteType() {
     26                return this;
     27        }
     28
     29
     30        public SymbolTable getSymbolTable() {
     31                return symbolTable;
     32        }
     33//
     34//      public void setSymbolTable(SymbolTable symbolTable) {
     35//              this.symbolTable = symbolTable;
     36//      }
    637
    738}
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/Binding.java

    r3254 r3259  
    11package toolchain.pabloS.semanticAnalyzer;
    22
     3import toolchain.pabloS.lang.type.CompoundType;
    34import toolchain.pabloS.lang.type.PrimitiveType;
    45import toolchain.pabloS.lang.type.Type;
    56
     7// immutable
    68public class Binding {
    79        public static Binding make(String name, Type type) {
    8                 return new Binding(name, type);
     10                return new Binding(name, type, false);
    911        }
    10 
     12        public static Binding makeTypeBinding(String name, Type type) {
     13                return new Binding(name, type, true);
     14        }
     15       
    1116        private String name;
    1217        private Type type;
     18        private boolean isTypeDefinition;
    1319       
    14         private Binding(String name, Type type) {
     20        private Binding(String name, Type type, boolean isTypeDefinition) {
    1521                super();
    1622                this.name = name;
    1723                this.type = type;
     24                this.isTypeDefinition = isTypeDefinition;
    1825        }
    1926
     
    2532                return type;
    2633        }
    27 
    28         private static Binding nullBinding = new Binding("nullBinding", PrimitiveType.ERROR);
     34        public final boolean isTypeDefinition() {
     35                return isTypeDefinition;
     36        }
     37        public boolean isCompoundInstance() {
     38                return (type instanceof CompoundType) && !isTypeDefinition();
     39        }
     40        public boolean isNull() {
     41                return false;
     42        }
     43       
     44        private static Binding nullBinding =
     45                        new Binding("nullBinding", PrimitiveType.ERROR, false) {
     46                                public boolean isNull() {
     47                                        return true;
     48                                }
     49                        };
    2950        public static Binding getNullInstance() {
    3051                return nullBinding;
    3152        }
     53
    3254       
    3355}
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/SemanticAnalyzer.java

    r3254 r3259  
    11package toolchain.pabloS.semanticAnalyzer;
     2import java.util.List;
     3
    24import pabloS.ast.*;
     5import pabloS.inputHandler.Locator;
     6import pabloS.lexicalAnalyzer.Lextant;
     7import pabloS.logging.ScatterLogger;
     8import pabloS.tokens.LextantToken;
    39import toolchain.pabloS.ast.Accessors;
     10import toolchain.pabloS.lang.PabloSBuiltinTypeBuilder;
     11import toolchain.pabloS.lang.signatures.FunctionSignature;
     12import toolchain.pabloS.lang.signatures.FunctionSignatures;
     13import toolchain.pabloS.lang.signatures.OperatorSignatures;
     14import toolchain.pabloS.lang.type.CompoundType;
     15import toolchain.pabloS.lang.type.FunctionType;
    416import toolchain.pabloS.lang.type.PrimitiveType;
    517import toolchain.pabloS.lang.type.StreamType;
     
    2133                public void visitEnter(ProgramNode node) {
    2234                        node.setSymbolTable(new SymbolTable());
     35                        PabloSBuiltinTypeBuilder.installOn(node);
    2336                }
    2437                @Override
     
    107120                @Override
    108121                public void visitLeave(BinaryOperatorNode node) {
    109                         // TODO typecheck against operator signatures
     122                        operatorNodeVisit(node);
    110123                }
    111124                @Override
    112125                public void visitLeave(UnaryOperatorNode node) {
    113                         // TODO Auto-generated method stub                     
     126                        operatorNodeVisit(node);
     127                }
     128
     129                private void operatorNodeVisit(ASTNode node) {
     130                        LextantToken token = (LextantToken)node.getToken();
     131                        Lextant operator = token.getLextant();
     132                        FunctionSignatures signatures = OperatorSignatures.getSignatures(operator);
     133                        List<Type> types = Accessors.childTypes(node);
     134                       
     135                        if(signatures.accepts(types)) {
     136                                FunctionSignature signature = signatures.acceptingSignature(types);
     137                                Type returnType = signature.resultType();
     138                                ((HasSignatureNodeType)node).setSignature(signature);
     139                                node.setType(returnType);
     140                        }
     141                        else {
     142                                operatorTypeCheckError(node, operator.name(), types);
     143                                ((HasSignatureNodeType)node).setSignature(FunctionSignature.nullInstance());
     144                                node.setType(PrimitiveType.ERROR);
     145                        }
    114146                }
    115147               
     
    119151                @Override
    120152                public void visitLeave(FuncCallNode node) {
    121                         // TODO look up name, check signature
    122                 }
    123                 @Override
    124                 public void visitLeave(FuncCallArgListNode node) {
    125                         // TODO Auto-generated method stub
    126                 }
     153                        Binding binding = nameBinding(node);
     154                        Type bindingType = binding.getType();
     155                        if(bindingType instanceof FunctionType) {
     156                                FunctionType functionType = (FunctionType)bindingType;
     157                                FunctionSignatures signatures = functionType.getSignatures();
     158                                List<Type> types = Accessors.argumentTypes(node);
     159                               
     160                                if(signatures.accepts(types)) {
     161                                        FunctionSignature signature = signatures.acceptingSignature(types);
     162                                        Type returnType = signature.resultType();
     163                                        node.setSignature(signature);
     164                                        node.setType(returnType);
     165                                }
     166                                else {
     167                                        functionTypeCheckError(node, types);
     168                                        node.setSignature(FunctionSignature.nullInstance());
     169                                        node.setType(PrimitiveType.ERROR);
     170                                }
     171                        }
     172                        else {
     173                                notAFunctionError(node);
     174                                node.setType(PrimitiveType.ERROR);
     175                        }       
     176                }       
     177
     178
     179                private Binding nameBinding(FuncCallNode node) {
     180                        HasBindingNodeType nameNode = (HasBindingNodeType)(Accessors.nameNode(node));
     181                        return nameNode.getBinding();
     182                }
     183                @Override
     184                public void visitLeave(FuncCallArgListNode node) {}
    127185               
    128186            //   
     
    130188                //
    131189                @Override
     190                public void visitEnter(CompoundIdentifierNode node) {
     191                        node.skipChildren();
     192                }
     193                @Override
    132194                public void visitLeave(CompoundIdentifierNode node) {
    133                         // TODO Auto-generated method stub
    134                 }
     195                        Binding binding = findCompoundBinding(node);
     196                        node.setBinding(binding);
     197                }
     198
     199                private Binding findCompoundBinding(CompoundIdentifierNode node) {
     200                        Binding binding = headBinding(node);
     201                       
     202                        for(ASTNode child: Accessors.tailChildren(node)) {
     203                                if(binding.isCompoundInstance()) {
     204                                        binding = nextChildBinding(node, binding, child);
     205                                }
     206                                else {
     207                                        noncompoundError(node, binding, child);
     208                                        binding = Binding.getNullInstance();
     209                                        break;
     210                                }
     211                        }
     212                        return binding;
     213                }
     214                private void noncompoundError(CompoundIdentifierNode parent, Binding binding, ASTNode child) {
     215                        if(!binding.isNull()) {
     216                                semanticError(parent, "subcomponent " + Accessors.nameUpTo(parent, child) + " is not a package or an instance of a compound type." );
     217                        }
     218                }
     219                private Binding nextChildBinding(CompoundIdentifierNode parent, Binding binding, ASTNode child) {
     220                        CompoundType leftType = (CompoundType)(binding.getType());
     221                        SymbolTable symbolTable = leftType.getSymbolTable();
     222                        binding = bindingOrError(parent, symbolTable, child);
     223                        return binding;
     224                }
     225                private Binding bindingOrError(CompoundIdentifierNode parent, SymbolTable symbolTable, ASTNode child) {
     226                        String name = Accessors.lexeme(child);
     227                        if(symbolTable.hasBinding(name)) {
     228                                return  symbolTable.bindingFor(name);
     229                        }
     230                        else {
     231                                semanticError(parent, "subcomponent " + name + " undefined in " + Accessors.nameBefore(parent, child) + ". ");
     232                                return  Binding.getNullInstance();
     233                        }
     234                }
     235                private Binding headBinding(CompoundIdentifierNode node) {
     236                        ASTNode headChild = Accessors.headChild(node); 
     237                        return bindingOrError(node, headChild);
     238                }
     239                private Binding bindingOrError(ASTNode startNode, ASTNode nameNode) {
     240                        String name = Accessors.lexeme(nameNode);       
     241                        for(ASTNode ancestor: startNode.pathToRoot()) {
     242                                if(ancestor instanceof HasSymbolTableNodeType) {
     243                                        SymbolTable symbolTable = ((HasSymbolTableNodeType) ancestor).getSymbolTable();
     244                                        if(symbolTable.hasBinding(name)) {
     245                                                return symbolTable.bindingFor(name);
     246                                        }
     247                                }
     248                        }
     249                        semanticError(startNode, "undefined identifier: " + name);
     250                        return Binding.getNullInstance();
     251                }
     252               
    135253                @Override
    136254                public void visitLeave(IdentifierNode node) {
     
    143261                        }
    144262                        else {
    145                                 String name = Accessors.name(node);
    146                                 for(ASTNode ancestor: node.pathToRoot()) {
    147                                         if(ancestor instanceof HasSymbolTableNodeType) {
    148                                                 SymbolTable symbolTable = ((HasSymbolTableNodeType) ancestor).getSymbolTable();
    149                                                 if(symbolTable.hasBinding(name)) {
    150                                                         node.setBinding(symbolTable.bindingFor(name));
    151                                                 }                                                                                                               // I WAS HERE: TS
    152                                         }
    153                                 }
    154                         }
    155                 }
    156 
     263                                Binding binding = bindingOrError(node, node);
     264                                node.setBinding(binding);
     265                        }
     266                }
    157267                private boolean isBeingDefined(IdentifierNode node) {
    158268                        ASTNode parent = node.getParent();
     
    211321                        node.setType(PrimitiveType.ERROR);
    212322                }
    213 
     323               
     324            //   
     325                // e r r o r s
     326                //
     327                private void operatorTypeCheckError(ASTNode node, String operatorName, List<Type> operandTypes) {
     328                        semanticError(node, "operator " + operatorName + " not defined for types " + operandTypes.toString() + ".");   
     329                }       
     330                private void functionTypeCheckError(FuncCallNode node, List<Type> operandTypes) {
     331                        ASTNode nameNode = Accessors.nameNode(node);
     332                        String name = Accessors.name((CompoundIdentifierNode)nameNode);
     333                       
     334                        semanticError(node, "function " + name + " not defined for types " + operandTypes.toString() + ".");   
     335                }       
     336                private void notAFunctionError(FuncCallNode node) {
     337                        ASTNode nameNode = Accessors.nameNode(node);
     338                        String name = Accessors.name((CompoundIdentifierNode)nameNode);
     339                        semanticError(node, "symbol " + name + " used as a function name but not declared as a function.");
     340                }
     341                private void semanticError(Locator locator, String errorDescription) {
     342                        ScatterLogger log = ScatterLogger.getLogger("pabloS.SemanticAnalyzer");
     343                        String message = "" + locator.getLocation() + ": " + "semantic error--" + errorDescription;
     344                        log.severe(message);
     345                }       
     346               
     347                @SuppressWarnings("unused")
     348                private void logError(String message) {
     349                        ScatterLogger log = ScatterLogger.getLogger("pabloS.semanticAnalyzer");
     350                        log.severe(message);
     351                }
     352                @SuppressWarnings("unused")
     353                private String at(Locator locator) {
     354                        return " at " + locator.getLocation();
     355                }
    214356        }
    215357}
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/SymbolTable.java

    r3254 r3259  
    2525                }
    2626        }
     27        public boolean isNull() {
     28                return false;
     29        }
     30       
     31        private static SymbolTable nullInstance = new SymbolTable() {
     32                @Override public void add(Binding binding) {}
     33                @Override public boolean isNull() { return true; }
     34        };
     35        public static SymbolTable getNullInstance() {
     36                return nullInstance;
     37        }
    2738}
Note: See TracChangeset for help on using the changeset viewer.