Changeset 2244


Ignore:
Timestamp:
Jan 12, 2007, 10:08:40 PM (14 years ago)
Author:
roman
Message:

Context checks

Location:
devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FenceAndCutChecker.java

    r2238 r2244  
    2525        public FenceAndCutChecker(final MsgHandler msgHandler) {
    2626                this.msgHandler = msgHandler;
    27         }
    28 
    29         private void visit(AstPatternAlt astPatternAlt, Integer t) {
    30                 for (AstSentence astSentence : astPatternAlt.sentenceList) {
    31                         astSentence.rest.accept(this, t);
    32                 }
    3327        }
    3428
     
    9286        }
    9387
     88        public void visit(AstPatternAlt astPatternAlt, Integer t) {
     89                for (AstSentence astSentence : astPatternAlt.sentenceList) {
     90                        astSentence.rest.accept(this, t);
     91                }
     92        }
     93
    9494        public void visit(AstResultExp astResultExp, Integer t) {
    9595                return;
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/LexicalEnvironment.java

    r2234 r2244  
    3030        }
    3131
     32        public boolean bindIfCompatible(String key, V v) {
     33                if (!isCompatibleWith(key, v))
     34                        return false;
     35                else {
     36                        bind(key, v);
     37                        return true;
     38                }
     39        }
     40
     41        public boolean bindIfCompatibleInScope(String key, V v) {
     42                if (!isCompatibleWithInScope(key, v))
     43                        return false;
     44                else {
     45                        bind(key, v);
     46                        return true;
     47                }
     48        }
     49
    3250        public boolean contains(String key) {
    3351                return lookup(key) != null;
    3452        }
    3553
    36         public LexicalEnvironment<V> getParent() {
    37                 return parent;
     54        public boolean isCompatibleWith(String key, V v) {
     55                V v1 = lookup(key);
     56                return v1 == null || v1.equals(v);
    3857        }
    3958
    40         public boolean isCompatibleWith(String key, V v) {
     59        public boolean isCompatibleWithInScope(String key, V v) {
    4160                V v1 = lookupInScope(key);
    4261                return v1 == null || v1.equals(v);
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/MsgCode.java

    r2242 r2244  
    1515        NumberImmediatelyFollowedByIdentifierOrVariable(Severity.Error,
    1616                        "Number immediately followed by identifier or variable"), //
    17         UnexpectedEOFInCharacterString(Severity.Error, "Unexpected EOF in character string"), //
     17        TwoOccurrencesOfTheVariable_X_HaveDifferentTypes(Severity.Error,
     18                        "Two occurrences of the variable %s have different types"), //
     19        UnexpectedEOFInCharacterString(Severity.Error,
     20                        "Unexpected EOF in character string"), //
    1821        UnexpectedEOFInComment(Severity.Error, "Unexpected EOF in comment"), //
    1922        UnexpectedEOFInWord(Severity.Error, "Unexpected EOF in word"), //
    20         UnexpectedNewLineInCharacterString(Severity.Error, "Unexpected new line in character string"), //
     23        UnexpectedNewLineInCharacterString(Severity.Error,
     24                        "Unexpected new line in character string"), //
    2125        UnexpectedNewLineInWord(Severity.Error, "Unexpected new line in word"), //
     26        Variable_X_IsNotDefined(Severity.Error, "Variable %s is not defined"), //
    2227        WrongSyntax(Severity.Error, "Wrong syntax");
    2328
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableCollector.java

    r2238 r2244  
    145145
    146146        public void visit(AstPattern astPattern) {
    147                 astPattern.exp.accept(this);
     147                throw new UnsupportedOperationException();
    148148        }
    149149
     
    156156
    157157        public void visit(AstResultExp astResultExp) {
    158                 astResultExp.exp.accept(this);
     158                throw new UnsupportedOperationException();
    159159        }
    160160
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableScopeChecker.java

    r2238 r2244  
    77import org.refal.plus.comp.ast.AstCutAll;
    88import org.refal.plus.comp.ast.AstError;
     9import org.refal.plus.comp.ast.AstExp;
    910import org.refal.plus.comp.ast.AstFail;
    1011import org.refal.plus.comp.ast.AstFence;
     
    1415import org.refal.plus.comp.ast.AstNot;
    1516import org.refal.plus.comp.ast.AstPath;
    16 import org.refal.plus.comp.ast.AstPattern;
    1717import org.refal.plus.comp.ast.AstPatternAlt;
    1818import org.refal.plus.comp.ast.AstResultExp;
    1919import org.refal.plus.comp.ast.AstSentence;
    2020import org.refal.plus.comp.ast.AstTrap;
     21import org.refal.plus.comp.ast.AstVar;
    2122import org.refal.plus.comp.ast.PathVisitor;
    2223
     
    3031        }
    3132
    32         private void visit(AstPatternAlt astPatternAlt, LexicalEnvironment<VarType> t) {
     33        public void visit(AstPatternAlt astPatternAlt,
     34                        LexicalEnvironment<VarType> t) {
    3335                for (AstSentence astSentence : astPatternAlt.sentenceList) {
    3436                        LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
    35                         ExtendWithVariablesFrom(t1, astSentence.pattern);
     37                        addVariablesFrom(t1, astSentence.pattern.exp);
    3638                        astSentence.rest.accept(this, t1);
    3739                }
    3840        }
    3941
    40         private void ExtendWithVariablesFrom(LexicalEnvironment<VarType> t, AstPattern pattern) {
    41                
     42        private void defineVariablesFrom(LexicalEnvironment<VarType> t, AstExp exp) {
     43                VariableCollector vc = new VariableCollector();
     44                vc.visit(exp);
     45                for (AstVar astVar : vc.variables) {
     46                        if (!t.bindIfCompatibleInScope(astVar.index, astVar.type)) {
     47                                twoOccurrencesWithDifferentTypes(astVar);
     48                        }
     49                }
     50        }
     51
     52        private void addVariablesFrom(LexicalEnvironment<VarType> t, AstExp exp) {
     53                VariableCollector vc = new VariableCollector();
     54                vc.visit(exp);
     55                for (AstVar astVar : vc.variables) {
     56                        if (!t.bindIfCompatible(astVar.index, astVar.type)) {
     57                                twoOccurrencesWithDifferentTypes(astVar);
     58                        }
     59                }
     60        }
     61
     62        private void twoOccurrencesWithDifferentTypes(AstVar astVar) {
     63                msgHandler.send(astVar.pos,
     64                                MsgCode.TwoOccurrencesOfTheVariable_X_HaveDifferentTypes,
     65                                astVar.index);
    4266        }
    4367
     
    4973
    5074        public void visit(AstAltMatch astAltMatch, LexicalEnvironment<VarType> t) {
    51                 // TODO Auto-generated method stub
    52 
     75                astAltMatch.source.accept(this, t);
     76                visit(astAltMatch.patternAlt, t);
    5377        }
    5478
     
    7094
    7195        public void visit(AstFence astFence, LexicalEnvironment<VarType> t) {
    72                 // TODO Auto-generated method stub
    73 
     96                astFence.path.accept(this, t);
    7497        }
    7598
    7699        public void visit(AstIter astIter, LexicalEnvironment<VarType> t) {
    77                 // TODO Auto-generated method stub
    78 
     100                astIter.source1.accept(this, t);
     101                LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     102                defineVariablesFrom(t1, astIter.target);
     103                astIter.source2.accept(this, t1);
     104                astIter.rest.accept(this, t1);
    79105        }
    80106
    81107        public void visit(AstLet astLet, LexicalEnvironment<VarType> t) {
    82                 // TODO Auto-generated method stub
    83 
     108                astLet.source.accept(this, t);
     109                LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     110                defineVariablesFrom(t1, astLet.target);
     111                astLet.rest.accept(this, t1);
    84112        }
    85113
    86114        public void visit(AstMatch astMatch, LexicalEnvironment<VarType> t) {
    87                 // TODO Auto-generated method stub
    88 
     115                astMatch.source.accept(this, t);
     116                AstSentence astSentence = astMatch.sentence;
     117                LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     118                addVariablesFrom(t1, astSentence.pattern.exp);
     119                astSentence.rest.accept(this, t1);
    89120        }
    90121
    91122        public void visit(AstNot astNot, LexicalEnvironment<VarType> t) {
    92                 // TODO Auto-generated method stub
    93 
     123                astNot.source.accept(this, t);
     124                astNot.rest.accept(this, t);
    94125        }
    95126
    96127        public void visit(AstResultExp astResultExp, LexicalEnvironment<VarType> t) {
    97                 // TODO Auto-generated method stub
    98 
     128                AstExp astExp = astResultExp.exp;
     129                VariableCollector vc = new VariableCollector();
     130                vc.visit(astExp);
     131                for (AstVar astVar : vc.variables) {
     132                        if (!t.contains(astVar.index))
     133                                msgHandler.send(astVar.pos, MsgCode.Variable_X_IsNotDefined,
     134                                                astVar.index);
     135                        if( !t.isCompatibleWith(astVar.index, astVar.type))
     136                                msgHandler.send(astVar.pos, MsgCode.TwoOccurrencesOfTheVariable_X_HaveDifferentTypes,
     137                                                astVar.index);
     138                }
    99139        }
    100140
    101141        public void visit(AstTrap astTrap, LexicalEnvironment<VarType> t) {
    102                 // TODO Auto-generated method stub
    103 
     142                astTrap.path.accept(this, t);
     143                visit(astTrap.patternAlt, t);
    104144        }
    105145
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/PathVisitor.java

    r2232 r2244  
    1313        void visit(AstMatch astMatch, T t);
    1414        void visit(AstNot astNot, T t);
     15        void visit(AstPatternAlt astPatternAlt, T t);
    1516        void visit(AstResultExp astResultExp, T t);
    1617        void visit(AstTrap astTrap, T t);
Note: See TracChangeset for help on using the changeset viewer.