Changeset 2279


Ignore:
Timestamp:
Jan 22, 2007, 11:59:36 PM (14 years ago)
Author:
roman
Message:

All context checks seem to have been implemented, after all.

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

Legend:

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

    r2238 r2279  
    33public class ConsoleMsgHandler extends MsgHandler {
    44
    5         public int errorCount = 0;
    6 
    7         public int warningCount = 0;
    8        
    9         public int infoCount = 0;
    10 
    11         public boolean reportWarnings = false;
    12 
    13         public ConsoleMsgHandler() {
    14         }
    15 
    16         void errorPrefix(String fileName, int line, int startColumn) {
    17                 errorCount++;
    18                 System.out.printf("%s(%d, %d): ERROR: ", fileName, line, startColumn);
    19                 return;
    20         }
    21 
    225        @Override
    236        public void send(SrcPosition pos, MsgCode msgCode, Object... args) {
     7                updateCounters(msgCode);
    248                if (pos == null)
    259                        pos = new SrcPosition("ERROR", 1, 0, 0, 0);
     
    2711                switch (msgCode.getSeverity()) {
    2812                case Info:
    29                         infoCount++;
    3013                        severity = "INFO";
    3114                case Error:
    32                         errorCount++;
    3315                        severity = "ERROR";
    3416                case Warning:
    35                         warningCount++;
    3617                        severity = "WARNING";
    3718                default:
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FenceAndCutChecker.java

    r2264 r2279  
    4040public final class FenceAndCutChecker implements VisitorWithEnv<Integer> {
    4141
     42        public static void check(AstImplem astImplem, MsgHandler msgHandler) {
     43                FenceAndCutChecker v = new FenceAndCutChecker(msgHandler);
     44                v.visit(astImplem, 0);
     45        }
     46
    4247        private final MsgHandler msgHandler;
    4348
    44         public FenceAndCutChecker(final MsgHandler msgHandler) {
     49        private FenceAndCutChecker(final MsgHandler msgHandler) {
    4550                this.msgHandler = msgHandler;
    4651        }
     
    5560                astAltMatch.source.accept(this, 0);
    5661                visit(astAltMatch.patternAlt, e);
     62        }
     63
     64        public void visit(AstCall astCall, Integer e) {
     65                throw new UnsupportedOperationException();
     66        }
     67
     68        public void visit(AstCharSymbol astCharSymbol, Integer e) {
     69                throw new UnsupportedOperationException();
     70        }
     71
     72        public void visit(AstConstBinding astConstBinding, Integer e) {
    5773        }
    5874
     
    7692        }
    7793
     94        public void visit(AstExp astExp, Integer e) {
     95                throw new UnsupportedOperationException();
     96        }
     97
    7898        public void visit(AstFail astFail, Integer e) {
    7999                return;
     
    82102        public void visit(AstFence astFence, Integer e) {
    83103                astFence.path.accept(this, e + 1);
     104        }
     105
     106        public void visit(AstFuncDecl astFuncDecl, Integer e) {
     107        }
     108
     109        public void visit(AstFuncDef astFuncDef, Integer e) {
     110                astFuncDef.body.accept(this, 0);
     111        }
     112
     113        public void visit(AstImplem astImplem, Integer e) {
     114                for(AstTopNode astTopNode : astImplem.topNodes)
     115                        astTopNode.accept(this, 0);
     116        }
     117
     118        public void visit(AstInterf astInterf, Integer e) {
     119                throw new UnsupportedOperationException();
    84120        }
    85121
     
    100136        }
    101137
     138        public void visit(AstName astName, Integer e) {
     139                throw new UnsupportedOperationException();
     140        }
     141
    102142        public void visit(AstNot astNot, Integer e) {
    103143                astNot.source.accept(this, 0);
    104144                astNot.rest.accept(this, e);
    105         }
    106 
    107         public void visit(AstPatternAlt astPatternAlt, Integer e) {
    108                 for (AstSentence astSentence : astPatternAlt.sentenceList) {
    109                         astSentence.rest.accept(this, e);
    110                 }
    111         }
    112 
    113         public void visit(AstResultExp astResultExp, Integer e) {
    114                 return;
    115         }
    116 
    117         public void visit(AstTrap astTrap, Integer e) {
    118                 astTrap.path.accept(this, 0);
    119                 visit( astTrap.patternAlt, e);
    120         }
    121 
    122         public void visit(AstCall astCall, Integer e) {
    123                 throw new UnsupportedOperationException();
    124         }
    125 
    126         public void visit(AstCharSymbol astCharSymbol, Integer e) {
    127                 throw new UnsupportedOperationException();
    128         }
    129 
    130         public void visit(AstConstBinding astConstBinding, Integer e) {
    131         }
    132 
    133         public void visit(AstExp astExp, Integer e) {
    134                 throw new UnsupportedOperationException();
    135         }
    136 
    137         public void visit(AstFuncDecl astFuncDecl, Integer e) {
    138         }
    139 
    140         public void visit(AstFuncDef astFuncDef, Integer e) {
    141                 astFuncDef.body.accept(this, 0);
    142         }
    143 
    144         public void visit(AstImplem astImplem, Integer e) {
    145                 for(AstTopNode astTopNode : astImplem.topNodes)
    146                         astTopNode.accept(this, 0);
    147         }
    148 
    149         public void visit(AstInterf astInterf, Integer e) {
    150                 throw new UnsupportedOperationException();
    151         }
    152 
    153         public void visit(AstName astName, Integer e) {
    154                 throw new UnsupportedOperationException();
    155145        }
    156146
     
    170160        }
    171161
     162        public void visit(AstPatternAlt astPatternAlt, Integer e) {
     163                for (AstSentence astSentence : astPatternAlt.sentenceList) {
     164                        astSentence.rest.accept(this, e);
     165                }
     166        }
     167
    172168        public void visit(AstRef astRef, Integer e) {
    173169                throw new UnsupportedOperationException();
     
    178174        }
    179175
     176        public void visit(AstResultExp astResultExp, Integer e) {
     177                return;
     178        }
     179
    180180        public void visit(AstSentence astSentence, Integer e) {
    181181                throw new UnsupportedOperationException();
     
    183183
    184184        public void visit(AstTraceAll astTraceAll, Integer e) {
     185        }
     186
     187        public void visit(AstTrap astTrap, Integer e) {
     188                astTrap.path.accept(this, 0);
     189                visit( astTrap.patternAlt, e);
    185190        }
    186191
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FormatChecker.java

    r2264 r2279  
    4545public class FormatChecker implements VisitorWithEnv<AstExp> {
    4646
    47         private final MsgHandler msgHandler;
    48 
    49         public FormatChecker(final MsgHandler msgHandler) {
    50                 this.msgHandler = msgHandler;
     47        public static void check(AstImplem astImplem, MsgHandler msgHandler) {
     48                FormatChecker v = new FormatChecker(msgHandler);
     49                v.visit(astImplem, null);
     50        }
     51
     52        private static boolean covers(AstExp format, AstExp exp) {
     53                return covers(expandTopLevel(format), expandTopLevel(exp));
     54        }
     55
     56        private static boolean covers(LinkedList<AstTerm> f, LinkedList<AstTerm> e) {
     57                for (;;) {
     58                        if (f.isEmpty())
     59                                break;
     60                        AstTerm firstF = f.getFirst();
     61                        if (!isHard(firstF))
     62                                break;
     63                        if (e.isEmpty())
     64                                return false;
     65                        AstTerm firstE = e.getFirst();
     66                        if (!hardCoversHard(firstF, firstE))
     67                                return false;
     68                        f.removeFirst();
     69                        e.removeFirst();
     70                }
     71
     72                for (;;) {
     73                        if (f.isEmpty())
     74                                break;
     75                        AstTerm lastF = f.getLast();
     76                        if (!isHard(lastF))
     77                                break;
     78                        if (e.isEmpty())
     79                                return false;
     80                        AstTerm lastE = e.getLast();
     81                        if (!hardCoversHard(lastF, lastE))
     82                                return false;
     83                        f.removeLast();
     84                        e.removeLast();
     85                }
     86
     87                if (f.isEmpty())
     88                        return e.isEmpty();
     89
     90                assert f.size() == 1;
     91                AstTerm fTerm = f.getFirst();
     92                assert fTerm instanceof AstVar;
     93                AstVar fVar = (AstVar) fTerm;
     94                if (fVar.type == VarType.V)
     95                        return !mayBeEmpty(e);
     96                assert fVar.type == VarType.E;
     97                return true;
    5198        }
    5299
     
    65112        }
    66113
    67         private static boolean isVar(VarType type, AstTerm astTerm) {
    68                 if (!(astTerm instanceof AstVar))
    69                         return false;
    70                 AstVar astVar = (AstVar) astTerm;
    71                 return astVar.type == type;
    72         }
    73 
    74         private static boolean isHard(AstTerm t) {
    75                 if (t instanceof AstSymbol)
    76                         return true;
    77                 if (t instanceof AstParen)
    78                         return true;
    79                 if (t instanceof AstVar) {
    80                         AstVar v = (AstVar) t;
    81                         return v.type == VarType.S || v.type == VarType.T;
    82                 }
    83                 return false;
    84         }
    85 
    86         private static boolean symbolCoversSymbol(AstSymbol f, AstSymbol e) {
    87                 if (f instanceof AstCharSymbol) {
    88                         if (!(e instanceof AstCharSymbol))
    89                                 return false;
    90                         return ((AstCharSymbol) f).character == ((AstCharSymbol) e).character;
    91                 } else if (f instanceof AstNumberSymbol) {
    92                         if (!(e instanceof AstNumberSymbol))
    93                                 return false;
    94                         return ((AstNumberSymbol) f).bigInteger
    95                                         .equals(((AstNumberSymbol) e).bigInteger);
    96                 } else if (f instanceof AstRefSymbol) {
    97                         if (!(e instanceof AstRefSymbol))
    98                                 return false;
    99                         return ((AstRefSymbol) f).decl == ((AstRefSymbol) e).decl;
    100                 } else if (f instanceof AstWordSymbol) {
    101                         if (!(e instanceof AstWordSymbol))
    102                                 return false;
    103                         return ((AstWordSymbol) f).word.equals(((AstWordSymbol) e).word);
    104                 } else {
    105                         assert false;
    106                         return false;
    107                 }
    108         }
    109 
    110114        private static boolean hardCoversHard(AstTerm f, AstTerm e) {
    111115                if (f instanceof AstSymbol) {
     
    129133        }
    130134
     135        private static boolean isHard(AstTerm t) {
     136                if (t instanceof AstSymbol)
     137                        return true;
     138                if (t instanceof AstParen)
     139                        return true;
     140                if (t instanceof AstVar) {
     141                        AstVar v = (AstVar) t;
     142                        return v.type == VarType.S || v.type == VarType.T;
     143                }
     144                return false;
     145        }
     146
     147        private static boolean isVar(VarType type, AstTerm astTerm) {
     148                if (!(astTerm instanceof AstVar))
     149                        return false;
     150                AstVar astVar = (AstVar) astTerm;
     151                return astVar.type == type;
     152        }
     153
    131154        private static boolean mayBeEmpty(LinkedList<AstTerm> e) {
    132155                for (AstTerm t : e) {
     
    137160        }
    138161
    139         private static boolean covers(LinkedList<AstTerm> f, LinkedList<AstTerm> e) {
    140                 for (;;) {
    141                         if (f.isEmpty())
    142                                 break;
    143                         AstTerm firstF = f.getFirst();
    144                         if (!isHard(firstF))
    145                                 break;
    146                         if (e.isEmpty())
    147                                 return false;
    148                         AstTerm firstE = e.getFirst();
    149                         if (!hardCoversHard(firstF, firstE))
    150                                 return false;
    151                         f.removeFirst();
    152                         e.removeFirst();
    153                 }
    154 
    155                 for (;;) {
    156                         if (f.isEmpty())
    157                                 break;
    158                         AstTerm lastF = f.getLast();
    159                         if (!isHard(lastF))
    160                                 break;
    161                         if (e.isEmpty())
    162                                 return false;
    163                         AstTerm lastE = e.getLast();
    164                         if (!hardCoversHard(lastF, lastE))
    165                                 return false;
    166                         f.removeLast();
    167                         e.removeLast();
    168                 }
    169 
    170                 if (f.isEmpty())
    171                         return e.isEmpty();
    172 
    173                 assert f.size() == 1;
    174                 AstTerm fTerm = f.getFirst();
    175                 assert fTerm instanceof AstVar;
    176                 AstVar fVar = (AstVar) fTerm;
    177                 if (fVar.type == VarType.V)
    178                         return !mayBeEmpty(e);
    179                 assert fVar.type == VarType.E;
    180                 return true;
    181         }
    182 
    183         private static boolean covers(AstExp format, AstExp exp) {
    184                 return covers(expandTopLevel(format), expandTopLevel(exp));
     162        private static boolean symbolCoversSymbol(AstSymbol f, AstSymbol e) {
     163                if (f instanceof AstCharSymbol) {
     164                        if (!(e instanceof AstCharSymbol))
     165                                return false;
     166                        return ((AstCharSymbol) f).character == ((AstCharSymbol) e).character;
     167                } else if (f instanceof AstNumberSymbol) {
     168                        if (!(e instanceof AstNumberSymbol))
     169                                return false;
     170                        return ((AstNumberSymbol) f).bigInteger
     171                                        .equals(((AstNumberSymbol) e).bigInteger);
     172                } else if (f instanceof AstRefSymbol) {
     173                        if (!(e instanceof AstRefSymbol))
     174                                return false;
     175                        return ((AstRefSymbol) f).decl == ((AstRefSymbol) e).decl;
     176                } else if (f instanceof AstWordSymbol) {
     177                        if (!(e instanceof AstWordSymbol))
     178                                return false;
     179                        return ((AstWordSymbol) f).word.equals(((AstWordSymbol) e).word);
     180                } else {
     181                        assert false;
     182                        return false;
     183                }
     184        }
     185
     186        private final MsgHandler msgHandler;
     187
     188        private FormatChecker(final MsgHandler msgHandler) {
     189                this.msgHandler = msgHandler;
    185190        }
    186191
     
    281286
    282287        public void visit(AstNot astNot, AstExp e) {
    283                 astNot.source.accept(this, new AstExp());
     288                astNot.source.accept(this, new AstExp(astNot.source.pos));
    284289                astNot.rest.accept(this, e);
    285290        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/MsgCode.java

    r2264 r2279  
    1212        ExpectedConstructs(Severity.Error, "Expected constructs: %s"), //
    1313        FormatMismatch(Severity.Error, "Format mismatch"), //
     14        Function_X_IsDeclaredButNotDefined(Severity.Error, "Function %s is declared but not defined"), //
    1415        Function_X_IsNotDeclared(Severity.Error, "Function %s is not declared"), //
    1516        InvalidCharacter(Severity.Error, "Invalid character"), //
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/MsgHandler.java

    r2238 r2279  
    33public abstract class MsgHandler {
    44
     5        protected int errorCount = 0;
     6
     7        protected int infoCount = 0;
     8
     9        protected int warningCount = 0;
     10
     11        protected void updateCounters(MsgCode msgCode) {
     12                if (msgCode.getSeverity() == MsgCode.Severity.Error)
     13                        errorCount++;
     14                switch (msgCode.getSeverity()) {
     15                case Info:
     16                        infoCount++;
     17                        break;
     18                case Warning:
     19                        warningCount++;
     20                        break;
     21                case Error:
     22                        errorCount++;
     23                        break;
     24                }
     25        }
     26
     27        public int getErrorCount() {
     28                return errorCount;
     29        }
     30
     31        public int getInfoCount() {
     32                return infoCount;
     33        }
     34
     35        public int getWarningCount() {
     36                return warningCount;
     37        }
     38
    539        public abstract void send(SrcPosition pos, MsgCode msgCode, Object... args);
    640
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/NameChecker.java

    r2264 r2279  
    4545public final class NameChecker implements NodeVisitor {
    4646
    47         public final HashMap<String, AstDecl> bindings = new HashMap<String, AstDecl>();
     47        public static void check(AstImplem astImplem, MsgHandler msgHandler) {
     48                NameChecker v = new NameChecker(msgHandler);
     49                v.visit(astImplem);
     50        }
     51
     52        private final HashMap<String, AstDecl> bindings = new HashMap<String, AstDecl>();
     53
     54        private final ArrayList<AstFuncDecl> funcDeclList = new ArrayList<AstFuncDecl>();
    4855
    4956        private final MsgHandler msgHandler;
    5057
    51         public NameChecker(final MsgHandler msgHandler) {
     58        private NameChecker(final MsgHandler msgHandler) {
    5259                this.msgHandler = msgHandler;
    5360        }
     
    156163                astFuncDecl.outFormat.accept(this);
    157164                bindName(astFuncDecl, MsgCode.DuplicateDeclarationOfTheName_X);
     165                funcDeclList.add(astFuncDecl);
    158166        }
    159167
     
    165173                AstFuncDecl astFuncDecl = getFuncDecl(astName);
    166174                if (astFuncDecl == null) {
    167                         msgHandler.send(astName.pos, MsgCode.Function_X_IsNotDeclared,
    168                                         identifier);
    169175                } else if (astFuncDecl.funcDef != null)
    170176                        msgHandler.send(astName.pos,
     
    179185                for (AstTopNode astTopNode : astImplem.topNodes)
    180186                        astTopNode.accept(this);
     187                for (AstFuncDecl astFuncDecl : funcDeclList) {
     188                        if (astFuncDecl.funcDef == null)
     189                                msgHandler.send(astFuncDecl.name.pos,
     190                                                MsgCode.Function_X_IsDeclaredButNotDefined,
     191                                                astFuncDecl.name.identifier);
     192                }
    181193        }
    182194
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/Parser.java

    r2264 r2279  
    11package org.refal.plus.comp;
    22
    3 import static org.refal.plus.comp.TkAttributes.*;
    4 import static org.refal.plus.comp.TkFollowers.*;
    5 import static org.refal.plus.comp.TkStarters.*;
    6 import static org.refal.plus.comp.TkTags.*;
     3import static org.refal.plus.comp.TkFollowers.f_const_bindings;
     4import static org.refal.plus.comp.TkFollowers.f_func_body;
     5import static org.refal.plus.comp.TkFollowers.f_implem;
     6import static org.refal.plus.comp.TkFollowers.f_interf;
     7import static org.refal.plus.comp.TkFollowers.f_iter_tail;
     8import static org.refal.plus.comp.TkFollowers.f_o_rest;
     9import static org.refal.plus.comp.TkFollowers.f_path;
     10import static org.refal.plus.comp.TkFollowers.f_source;
     11import static org.refal.plus.comp.TkStarters.s_const_binding;
     12import static org.refal.plus.comp.TkStarters.s_const_bindings;
     13import static org.refal.plus.comp.TkStarters.s_const_exp;
     14import static org.refal.plus.comp.TkStarters.s_const_exp_head;
     15import static org.refal.plus.comp.TkStarters.s_decl;
     16import static org.refal.plus.comp.TkStarters.s_directive;
     17import static org.refal.plus.comp.TkStarters.s_directives;
     18import static org.refal.plus.comp.TkStarters.s_format_exp;
     19import static org.refal.plus.comp.TkStarters.s_func_body;
     20import static org.refal.plus.comp.TkStarters.s_iter_tail;
     21import static org.refal.plus.comp.TkStarters.s_o_rest;
     22import static org.refal.plus.comp.TkStarters.s_obj_names;
     23import static org.refal.plus.comp.TkStarters.s_path;
     24import static org.refal.plus.comp.TkStarters.s_path_tail;
     25import static org.refal.plus.comp.TkStarters.s_paths;
     26import static org.refal.plus.comp.TkStarters.s_pattern;
     27import static org.refal.plus.comp.TkStarters.s_pattern_alt;
     28import static org.refal.plus.comp.TkStarters.s_pattern_exp;
     29import static org.refal.plus.comp.TkStarters.s_pattern_exp_head;
     30import static org.refal.plus.comp.TkStarters.s_rest;
     31import static org.refal.plus.comp.TkStarters.s_result_exp;
     32import static org.refal.plus.comp.TkStarters.s_result_exp_head;
     33import static org.refal.plus.comp.TkStarters.s_sentence;
     34import static org.refal.plus.comp.TkStarters.s_sentences;
     35import static org.refal.plus.comp.TkStarters.s_source;
     36import static org.refal.plus.comp.TkStarters.s_source_tail;
     37import static org.refal.plus.comp.TkStarters.s_static_symbol;
     38import static org.refal.plus.comp.TkTags.CHAR;
     39import static org.refal.plus.comp.TkTags.COL;
     40import static org.refal.plus.comp.TkTags.COL_CURL;
     41import static org.refal.plus.comp.TkTags.COMMA;
     42import static org.refal.plus.comp.TkTags.CONST;
     43import static org.refal.plus.comp.TkTags.CUT;
     44import static org.refal.plus.comp.TkTags.EQL;
     45import static org.refal.plus.comp.TkTags.ERROR;
     46import static org.refal.plus.comp.TkTags.FAIL;
     47import static org.refal.plus.comp.TkTags.FENCE;
     48import static org.refal.plus.comp.TkTags.FUNC_DECL;
     49import static org.refal.plus.comp.TkTags.IDENT;
     50import static org.refal.plus.comp.TkTags.ITER;
     51import static org.refal.plus.comp.TkTags.LANGU;
     52import static org.refal.plus.comp.TkTags.LCURL;
     53import static org.refal.plus.comp.TkTags.LET;
     54import static org.refal.plus.comp.TkTags.LPAR;
     55import static org.refal.plus.comp.TkTags.MATCH_DIR;
     56import static org.refal.plus.comp.TkTags.NOT;
     57import static org.refal.plus.comp.TkTags.NUMB;
     58import static org.refal.plus.comp.TkTags.OBJ_DECL;
     59import static org.refal.plus.comp.TkTags.RANGU;
     60import static org.refal.plus.comp.TkTags.RCURL;
     61import static org.refal.plus.comp.TkTags.REF;
     62import static org.refal.plus.comp.TkTags.RPAR;
     63import static org.refal.plus.comp.TkTags.SC;
     64import static org.refal.plus.comp.TkTags.TRACE_ALL;
     65import static org.refal.plus.comp.TkTags.TRAP;
     66import static org.refal.plus.comp.TkTags.USE;
     67import static org.refal.plus.comp.TkTags.VAR;
     68import static org.refal.plus.comp.TkTags.WITH;
     69import static org.refal.plus.comp.TkTags.WORD;
    770
    871import java.util.ArrayList;
    972import java.util.HashMap;
    1073
     74import org.refal.plus.comp.TkAttributes.MatchDir;
    1175import org.refal.plus.comp.TkAttributes.ObjKind;
    12 import org.refal.plus.comp.ast.*;
     76import org.refal.plus.comp.TkAttributes.RetMode;
     77import org.refal.plus.comp.TkAttributes.VarType;
     78import org.refal.plus.comp.ast.AstAlt;
     79import org.refal.plus.comp.ast.AstAltMatch;
     80import org.refal.plus.comp.ast.AstCall;
     81import org.refal.plus.comp.ast.AstCharSymbol;
     82import org.refal.plus.comp.ast.AstConstBinding;
     83import org.refal.plus.comp.ast.AstCut;
     84import org.refal.plus.comp.ast.AstCutAll;
     85import org.refal.plus.comp.ast.AstError;
     86import org.refal.plus.comp.ast.AstExp;
     87import org.refal.plus.comp.ast.AstFail;
     88import org.refal.plus.comp.ast.AstFence;
     89import org.refal.plus.comp.ast.AstFuncDecl;
     90import org.refal.plus.comp.ast.AstFuncDef;
     91import org.refal.plus.comp.ast.AstImplem;
     92import org.refal.plus.comp.ast.AstInterf;
     93import org.refal.plus.comp.ast.AstIter;
     94import org.refal.plus.comp.ast.AstLet;
     95import org.refal.plus.comp.ast.AstMatch;
     96import org.refal.plus.comp.ast.AstName;
     97import org.refal.plus.comp.ast.AstNot;
     98import org.refal.plus.comp.ast.AstNumberSymbol;
     99import org.refal.plus.comp.ast.AstObjDecl;
     100import org.refal.plus.comp.ast.AstParen;
     101import org.refal.plus.comp.ast.AstPath;
     102import org.refal.plus.comp.ast.AstPattern;
     103import org.refal.plus.comp.ast.AstPatternAlt;
     104import org.refal.plus.comp.ast.AstRef;
     105import org.refal.plus.comp.ast.AstResultExp;
     106import org.refal.plus.comp.ast.AstSentence;
     107import org.refal.plus.comp.ast.AstSymbol;
     108import org.refal.plus.comp.ast.AstTerm;
     109import org.refal.plus.comp.ast.AstTopNode;
     110import org.refal.plus.comp.ast.AstTraceAll;
     111import org.refal.plus.comp.ast.AstTrap;
     112import org.refal.plus.comp.ast.AstVar;
     113import org.refal.plus.comp.ast.AstWordSymbol;
    13114
    14115public final class Parser {
     
    526627                        sync(ftk, stk);
    527628                } else if (tkIn(s_rest)) {
     629                        SrcPosition pos = tkPos;
    528630                        AstPath astRest = rest(ftk, stk);
    529631                        if (isEmptyResultExp(astSource)) {
    530632                                astPath = astRest;
    531633                        } else {
    532                                 astPath = new AstLet(astSource, new AstExp(), astRest);
     634                                astPath = new AstLet(astSource, new AstExp(pos), astRest);
    533635                        }
    534636                } else if (tkIs(LET)) {
     
    566668                        astPath = new AstIter(astSource1, astSource2, astTarget, astRest);
    567669                } else if (tkIn(s_o_rest | f_iter_tail)) {
    568                         AstExp astTarget = new AstExp();
     670                        AstExp astTarget = new AstExp(tkPos);
    569671                        AstPath astRest = o_rest(ftk, stk);
    570672                        astPath = new AstIter(astSource1, astSource2, astTarget, astRest);
     
    585687                if (tkIn(f_o_rest)) {
    586688                        // empty
    587                         AstExp astExp = new AstExp();
     689                        AstExp astExp = new AstExp(tkPos);
    588690                        astPath = new AstResultExp(astExp);
    589691                        sync(ftk, stk);
     
    609711                assert tkIn(s_rest);
    610712
     713                SrcPosition pos = tkPos;
    611714                AstPath astRest;
    612715                if (tkIs(COMMA)) {
     
    620723                        nextTk();
    621724                        AstPath astPath = path(ftk, stk);
    622                         astRest = new AstCut(astPath);
     725                        astRest = new AstCut(pos, astPath);
    623726                } else if (tkIs(ERROR)) {
    624727                        nextTk();
     
    737840
    738841                ArrayList<AstTerm> termList = new ArrayList<AstTerm>();
     842                SrcPosition start = tkPos;
    739843                while (tkIn(s_pattern_exp_head)) {
    740844                        AstTerm astTerm = pattern_exp_head(s_pattern_exp | ftk, stk, mustBeHard);
     
    743847                if( mustBeHard)
    744848                        checkForHardness(termList);
    745                 return new AstExp(termList);
     849                return new AstExp(start, termList);
    746850        }
    747851
     
    756860                AstTerm astTerm;
    757861
     862                SrcPosition start = tkPos;
    758863                if (tkIs(REF)) {
    759864                        nextTk();
    760865                        AstName astName = name(ftk, stk);
    761                         astTerm = new AstRef(astName);
     866                        astTerm = new AstRef(SrcPosition.fromToInclusive(start, astName.pos), astName);
    762867                        sync(ftk, stk);
    763868                } else if (tkIn(s_static_symbol))
     
    766871                        nextTk();
    767872                        AstExp astExp = pattern_exp(RPAR, ftk | stk, mustBeHard);
     873                        SrcPosition end = tkPos;
    768874                        accept(RPAR);
    769                         astTerm = new AstParen(astExp);
     875                        astTerm = new AstParen(SrcPosition.fromToInclusive(start, end), astExp);
    770876                        sync(ftk, stk);
    771877                } else if (tkIs(VAR)) {
     
    803909
    804910                ArrayList<AstTerm> termList = new ArrayList<AstTerm>();
     911                SrcPosition start = tkPos;
    805912                while (tkIn(s_result_exp_head)) {
    806913                        AstTerm astTerm = result_exp_head(s_result_exp | ftk, stk);
    807914                        termList.add(astTerm);
    808915                }
    809                 return new AstExp(termList);
     916                return new AstExp(start, termList);
    810917        }
    811918
     
    821928                AstTerm astTerm;
    822929
     930                SrcPosition start = tkPos;
    823931                if (tkIs(REF)) {
    824932                        nextTk();
    825933                        AstName astName = name(ftk, stk);
    826                         astTerm = new AstRef(astName);
     934                        astTerm = new AstRef(SrcPosition.fromToInclusive(start, astName.pos), astName);
    827935                        sync(ftk, stk);
    828936                } else if (tkIn(s_static_symbol)) {
     
    831939                        nextTk();
    832940                        AstExp astExp = result_exp(RPAR, ftk | stk);
     941                        SrcPosition end = tkPos;
    833942                        accept(RPAR);
    834                         astTerm = new AstParen(astExp);
     943                        astTerm = new AstParen(SrcPosition.fromToInclusive(start, end), astExp);
    835944                        sync(ftk, stk);
    836945                } else if (tkIs(VAR)) {
     
    842951                        AstName astName = name(s_result_exp | RANGU, ftk | stk);
    843952                        AstExp astExp = result_exp(RANGU, ftk | stk);
    844                         astTerm = new AstCall(astName, astExp);
     953                        SrcPosition end = tkPos;
    845954                        accept(RANGU);
     955                        astTerm = new AstCall(SrcPosition.fromToInclusive(start, end), astName, astExp);
    846956                        sync(ftk, stk);
    847957                } else {
     
    872982
    873983                ArrayList<AstTerm> termList = new ArrayList<AstTerm>();
     984                SrcPosition start = tkPos;
    874985                while (tkIn(s_const_exp_head)) {
    875986                        AstTerm astTerm = const_exp_head(s_const_exp | ftk, stk);
    876987                        termList.add(astTerm);
    877988                }
    878                 return new AstExp(termList);
     989                return new AstExp(start, termList);
    879990        }
    880991
     
    888999                AstTerm astTerm;
    8891000
     1001                SrcPosition start = tkPos;
    8901002                if (tkIs(REF)) {
    8911003                        nextTk();
    8921004                        AstName astName = name(ftk, stk);
    893                         astTerm = new AstRef(astName);
     1005                        astTerm = new AstRef(SrcPosition.fromToInclusive(start, astName.pos), astName);
    8941006                        sync(ftk, stk);
    8951007                } else if (tkIn(s_static_symbol)) {
     
    8981010                        nextTk();
    8991011                        AstExp astExp = const_exp(RPAR, ftk | stk);
     1012                        SrcPosition end = tkPos;
    9001013                        accept(RPAR);
    901                         astTerm = new AstParen(astExp);
     1014                        astTerm = new AstParen(SrcPosition.fromToInclusive(start, end), astExp);
    9021015                        sync(ftk, stk);
    9031016                } else {
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/SrcPosition.java

    r2206 r2279  
    22
    33public final class SrcPosition {
     4
     5        public static SrcPosition emptyRange(SrcPosition pos) {
     6                if (pos == null)
     7                        return null;
     8                return new SrcPosition(pos.fileName, pos.line, pos.lineStart,
     9                                pos.charStart, pos.charStart);
     10        }
     11
     12        public static SrcPosition fromToExclusive(SrcPosition start, SrcPosition end) {
     13                if (start == null || end == null)
     14                        return null;
     15                return new SrcPosition(start.fileName, start.line, start.lineStart,
     16                                start.charStart, end.charStart - 1);
     17        }
     18
     19        public static SrcPosition fromToInclusive(SrcPosition start, SrcPosition end) {
     20                if (start == null || end == null)
     21                        return null;
     22                return new SrcPosition(start.fileName, start.line, start.lineStart,
     23                                start.charStart, end.charEnd);
     24        }
     25
     26        public final int charEnd; // Zero-based
     27
     28        public final int charStart; // Zero-based
    429
    530        public final String fileName;
     
    833
    934        public final int lineStart; // Zero-based
    10 
    11         public final int charStart; // Zero-based
    12        
    13         public final int charEnd; // Zero-based
    1435
    1536        public SrcPosition() {
     
    2142        }
    2243
    23         public SrcPosition(String fileName, int line, int lineStart, int charStart, int charEnd) {
     44        public SrcPosition(String fileName, int line, int lineStart, int charStart,
     45                        int charEnd) {
    2446                this.fileName = fileName;
    2547                this.line = line;
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableScopeChecker.java

    r2264 r2279  
    4242                VisitorWithEnv<LexicalEnvironment<TkAttributes.VarType>> {
    4343
     44        public static void check(MsgHandler msgHandler, AstImplem astImplem) {
     45                VariableScopeChecker v = new VariableScopeChecker(msgHandler);
     46                v.visit(astImplem, null);
     47        }
     48
    4449        private final MsgHandler msgHandler;
    4550
    46         public VariableScopeChecker(final MsgHandler msgHandler) {
     51        private VariableScopeChecker(final MsgHandler msgHandler) {
    4752                this.msgHandler = msgHandler;
    4853        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstCall.java

    r2262 r2279  
    33 */
    44package org.refal.plus.comp.ast;
     5
     6import org.refal.plus.comp.SrcPosition;
    57
    68
     
    1214        public AstFuncDecl funcDecl = null;
    1315
    14         public AstCall(AstName name, AstExp arg) {
     16        public AstCall(SrcPosition pos, AstName name, AstExp arg) {
     17                this.pos = pos;
    1518                this.name = name;
    1619                this.arg = arg;
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstCut.java

    r2262 r2279  
    44package org.refal.plus.comp.ast;
    55
     6import org.refal.plus.comp.SrcPosition;
     7
    68public final class AstCut extends AstPath {
    79        public final AstPath path;
    810
    9         public AstCut(AstPath path) {
     11        public AstCut(SrcPosition pos, AstPath path) {
     12                this.pos = pos;
    1013                this.path = path;
    1114        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstExp.java

    r2264 r2279  
    66import java.util.ArrayList;
    77
     8import org.refal.plus.comp.SrcPosition;
     9
    810public final class AstExp extends AstNode {
    911        public final ArrayList<AstTerm> termList;
    1012
    11         public AstExp() {
    12                 this(new ArrayList<AstTerm>(0));
     13        public AstExp(SrcPosition start) {
     14                this.pos = SrcPosition.emptyRange(start);
     15                this.termList = new ArrayList<AstTerm>(0);
    1316        }
    1417
    15         public AstExp(ArrayList<AstTerm> astTermList) {
     18        public AstExp(SrcPosition start, ArrayList<AstTerm> astTermList) {
     19                if (astTermList.isEmpty())
     20                        this.pos = SrcPosition.emptyRange(start);
     21                else {
     22                        AstTerm first = astTermList.get(0);
     23                        AstTerm last = astTermList.get(astTermList.size() - 1);
     24                        this.pos = SrcPosition.fromToInclusive(first.pos, last.pos);
     25                }
    1626                this.termList = astTermList;
    1727        }
     
    2030                ArrayList<AstTerm> termList = new ArrayList<AstTerm>(1);
    2131                termList.add(astTerm);
     32                this.pos = astTerm.pos;
    2233                this.termList = termList;
    2334        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstParen.java

    r2262 r2279  
    44package org.refal.plus.comp.ast;
    55
     6import org.refal.plus.comp.SrcPosition;
     7
    68public final class AstParen extends AstTerm {
    79        public final AstExp exp;
    810
    9         public AstParen(AstExp exp) {
     11        public AstParen(SrcPosition pos, AstExp exp) {
     12                this.pos = pos;
    1013                this.exp = exp;
    1114        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstRef.java

    r2262 r2279  
    33 */
    44package org.refal.plus.comp.ast;
     5
     6import org.refal.plus.comp.SrcPosition;
    57
    68public final class AstRef extends AstTerm {
     
    911        public AstDecl decl = null;
    1012
    11         public AstRef(AstName name) {
     13        public AstRef(SrcPosition pos, AstName name) {
     14                this.pos = pos;
    1215                this.name = name;
    1316        }
Note: See TracChangeset for help on using the changeset viewer.