Changeset 3619 for devel-tools/trunk


Ignore:
Timestamp:
Mar 30, 2008, 4:26:32 PM (13 years ago)
Author:
yura
Message:
  • Exp -> Expr.
Location:
devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt
Files:
9 edited
1 moved

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/Checker.java

    r3566 r3619  
    1212        ImportChecker.check(astImplem, astEnv);
    1313        NameChecker.check(astImplem, msgHandler);
    14         ExpChecker.check(astImplem, msgHandler);
     14        ExprChecker.check(astImplem, msgHandler);
    1515        FormatChecker.check(astImplem, msgHandler);
    1616        FenceAndCutChecker.check(astImplem, msgHandler);
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/ExprChecker.java

    r3602 r3619  
    3838import org.refal.rfpdt.ast.SentenceVisitor;
    3939
    40 public class ExpChecker implements ProgramVisitor, SentenceVisitor {
     40public class ExprChecker implements ProgramVisitor, SentenceVisitor {
    4141    private static final class Container {
    4242        public boolean noError = true;
     
    4949
    5050    public static void check (AstImplem astImplem, MsgHandler msgHandler) {
    51         ExpChecker v = new ExpChecker(msgHandler);
     51        ExprChecker v = new ExprChecker(msgHandler);
    5252        v.visit(astImplem);
    5353    }
     
    6161        public void visit (AstCharSymbol astCharSymbol, ContainerWithVar e) {}
    6262
    63         public void visit (AstExpr astExp, ContainerWithVar e) {
     63        public void visit (AstExpr astExpr, ContainerWithVar e) {
    6464            ContainerWithVar e1 = new ContainerWithVar();
    65             for (AstTerm astTerm : astExp.termList)
     65            for (AstTerm astTerm : astExpr.termList)
    6666                astTerm.accept(this, e1);
    6767            e.noError &= e1.noError;
     
    102102        public void visit (AstCharSymbol astCharSymbol, Container e) {}
    103103
    104         public void visit (AstExpr astExp, Container e) {
    105             for (AstTerm astTerm : astExp.termList)
     104        public void visit (AstExpr astExpr, Container e) {
     105            for (AstTerm astTerm : astExpr.termList)
    106106                astTerm.accept(this, e);
    107107        }
     
    132132        public void visit (AstCharSymbol astCharSymbol, Container e) {}
    133133
    134         public void visit (AstExpr astExp, Container e) {
    135             for (AstTerm astTerm : astExp.termList)
     134        public void visit (AstExpr astExpr, Container e) {
     135            for (AstTerm astTerm : astExpr.termList)
    136136                astTerm.accept(this, e);
    137137        }
     
    156156    private final MsgHandler msgHandler;
    157157
    158     private ExpChecker (final MsgHandler msgHandler) {
     158    private ExprChecker (final MsgHandler msgHandler) {
    159159        this.msgHandler = msgHandler;
    160160    }
    161161
    162     private void checkFormat (AstExpr astExp) {
     162    private void checkFormat (AstExpr astExpr) {
    163163        ContainerWithVar e = new ContainerWithVar();
    164         astExp.accept(new FormatChecker(), e);
    165         astExp.noError = e.noError;
    166     }
    167 
    168     private void checkPattern (AstExpr astExp) {
     164        astExpr.accept(new FormatChecker(), e);
     165        astExpr.noError = e.noError;
     166    }
     167
     168    private void checkPattern (AstExpr astExpr) {
    169169        Container e = new Container();
    170         astExp.accept(new PatternChecker(), e);
    171         astExp.noError = e.noError;
    172     }
    173 
    174     private void checkResult (AstExpr astExp) {
     170        astExpr.accept(new PatternChecker(), e);
     171        astExpr.noError = e.noError;
     172    }
     173
     174    private void checkResult (AstExpr astExpr) {
    175175        Container e = new Container();
    176         astExp.accept(new ResultChecker(), e);
    177         astExp.noError = e.noError;
     176        astExpr.accept(new ResultChecker(), e);
     177        astExpr.noError = e.noError;
    178178    }
    179179
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/FormatChecker.java

    r3570 r3619  
    3939import org.refal.rfpdt.ast.SentenceVisitorWithEnv;
    4040
    41 public class FormatChecker implements ProgramVisitor, SentenceVisitor, SentenceVisitorWithEnv<FormatChecker.RefAstExp>,
     41public class FormatChecker implements ProgramVisitor, SentenceVisitor, SentenceVisitorWithEnv<FormatChecker.RefAstExpr>,
    4242        ExprVisitor {
    43     private static final class RefAstExp {
    44         public AstExpr exp;
     43    private static final class RefAstExpr {
     44        public AstExpr expr;
    4545        public MsgCode msgCode;
    4646
    47         public RefAstExp () {
    48             exp = null;
     47        public RefAstExpr () {
     48            expr = null;
    4949            msgCode = null;
    5050        }
    5151
    52         public RefAstExp (AstExpr format, MsgCode msg) {
     52        public RefAstExpr (AstExpr format, MsgCode msg) {
    5353            if (format.noError) {
    54                 exp = format;
     54                expr = format;
    5555                msgCode = msg;
    5656            }
    5757        }
    5858
    59         public RefAstExp (RefAstExp ref) {
    60             exp = ref.exp;
     59        public RefAstExpr (RefAstExpr ref) {
     60            expr = ref.expr;
    6161            msgCode = ref.msgCode;
    6262        }
    6363
    6464        public void reset () {
    65             exp = null;
     65            expr = null;
    6666            msgCode = null;
    6767        }
     
    6969        public void set (AstExpr format, MsgCode msg) {
    7070            if (format.noError) {
    71                 exp = format;
     71                expr = format;
    7272                msgCode = msg;
    7373            } else
     
    8989    }
    9090
    91     private void covers (AstExpr format, AstExpr exp, MsgCode msg) {
    92         if ((format != null) && format.noError && exp.noError && !FormatMatcher.covers(format, exp))
    93             msgHandler.send(exp.pos, msg);
     91    private void covers (AstExpr format, AstExpr expr, MsgCode msg) {
     92        if ((format != null) && format.noError && expr.noError && !FormatMatcher.covers(format, expr))
     93            msgHandler.send(expr.pos, msg);
    9494    }
    9595
     
    109109            inFormat = null;
    110110        }
    111         astFuncDef.body.accept(this, new RefAstExp(decl.outFormat, MsgCode.WrongFormatOfFunctionResult));
     111        astFuncDef.body.accept(this, new RefAstExpr(decl.outFormat, MsgCode.WrongFormatOfFunctionResult));
    112112    }
    113113
     
    187187    }
    188188
    189     // SentenceVisitorWithEnv<FormatChecker.RefAstExp>
    190 
    191     public void visit (AstAlt astAlt, RefAstExp e) {
     189    // SentenceVisitorWithEnv<FormatChecker.RefAstExpr>
     190
     191    public void visit (AstAlt astAlt, RefAstExpr e) {
    192192        for (AstSentence astSentence : astAlt.sentenceList)
    193             astSentence.accept(this, new RefAstExp(e));
    194         e.reset();
    195     }
    196 
    197     public void visit (AstCut astCut, RefAstExp e) {}
    198 
    199     public void visit (AstCutAll astCutAll, RefAstExp e) {}
    200 
    201     public void visit (AstError astError, RefAstExp e) {
    202         astError.sentence.accept(this, new RefAstExp());
    203         e.reset();
    204     }
    205 
    206     public void visit (AstFail astFail, RefAstExp e) {
    207         e.reset();
    208     }
    209 
    210     public void visit (AstFence astFence, RefAstExp e) {}
    211 
    212     public void visit (AstFormat astFormat, RefAstExp e) {
     193            astSentence.accept(this, new RefAstExpr(e));
     194        e.reset();
     195    }
     196
     197    public void visit (AstCut astCut, RefAstExpr e) {}
     198
     199    public void visit (AstCutAll astCutAll, RefAstExpr e) {}
     200
     201    public void visit (AstError astError, RefAstExpr e) {
     202        astError.sentence.accept(this, new RefAstExpr());
     203        e.reset();
     204    }
     205
     206    public void visit (AstFail astFail, RefAstExpr e) {
     207        e.reset();
     208    }
     209
     210    public void visit (AstFence astFence, RefAstExpr e) {}
     211
     212    public void visit (AstFormat astFormat, RefAstExpr e) {
    213213        e.set(astFormat.expr, MsgCode.FormatMismatch);
    214214    }
    215215
    216     public void visit (AstIter astIter, RefAstExp e) {
    217         astIter.sentence.accept(this, new RefAstExp(astIter.target, MsgCode.FormatMismatch));
     216    public void visit (AstIter astIter, RefAstExpr e) {
     217        astIter.sentence.accept(this, new RefAstExpr(astIter.target, MsgCode.FormatMismatch));
    218218        e.set(astIter.target, MsgCode.FormatMismatch);
    219219    }
    220220
    221     public void visit (AstName astName, RefAstExp e) {}
    222 
    223     public void visit (AstNot astNot, RefAstExp e) {
    224         astNot.sentence.accept(this, new RefAstExp());
    225         e.reset();
    226     }
    227 
    228     public void visit (AstPattern astPattern, RefAstExp e) {
    229         e.reset();
    230     }
    231 
    232     public void visit (AstResult astResult, RefAstExp e) {
    233         covers(e.exp, astResult.expr, e.msgCode);
     221    public void visit (AstName astName, RefAstExpr e) {}
     222
     223    public void visit (AstNot astNot, RefAstExpr e) {
     224        astNot.sentence.accept(this, new RefAstExpr());
     225        e.reset();
     226    }
     227
     228    public void visit (AstPattern astPattern, RefAstExpr e) {
     229        e.reset();
     230    }
     231
     232    public void visit (AstResult astResult, RefAstExpr e) {
     233        covers(e.expr, astResult.expr, e.msgCode);
    234234        astResult.expr.accept(this);
    235235        e.reset();
    236236    }
    237237
    238     public void visit (AstSentence astSentence, RefAstExp e) {
     238    public void visit (AstSentence astSentence, RefAstExpr e) {
    239239        for (int i = astSentence.statementList.length - 1; i >= 0; i--)
    240240            astSentence.statementList[i].accept(this, e);
    241241    }
    242242
    243     public void visit (AstTrap astTrap, RefAstExp e) {
    244         astTrap.catchSentence.accept(this, new RefAstExp(e));
    245         astTrap.trySentence.accept(this, new RefAstExp(e));
     243    public void visit (AstTrap astTrap, RefAstExpr e) {
     244        astTrap.catchSentence.accept(this, new RefAstExpr(e));
     245        astTrap.trySentence.accept(this, new RefAstExpr(e));
    246246        e.reset();
    247247    }
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/FormatMatcher.java

    r3570 r3619  
    3939    }
    4040
    41     public static boolean covers (AstExpr format, AstExpr exp) {
    42         FormatMatcher matcher = new FormatMatcher(format, exp);
     41    public static boolean covers (AstExpr format, AstExpr expr) {
     42        FormatMatcher matcher = new FormatMatcher(format, expr);
    4343        return matcher.match();
    4444    }
     
    152152    }
    153153
    154     private final LinkedList<AstTerm> exp;
     154    private final LinkedList<AstTerm> expr;
    155155
    156156    private final LinkedList<AstTerm> format;
    157157
    158     private FormatMatcher (AstExpr format, AstExpr exp) {
     158    private FormatMatcher (AstExpr format, AstExpr expr) {
    159159        this.format = new LinkedList<AstTerm>();
    160160        addToList(0, this.format, format.termList);
    161         this.exp = new LinkedList<AstTerm>();
    162         addToList(0, this.exp, exp.termList);
     161        this.expr = new LinkedList<AstTerm>();
     162        addToList(0, this.expr, expr.termList);
    163163    }
    164164
    165165    private boolean expIsEmpty () {
    166166        for (;;) {
    167             if (exp.isEmpty())
     167            if (expr.isEmpty())
    168168                return true;
    169             for (AstTerm t : exp) {
     169            for (AstTerm t : expr) {
    170170                if (!(t instanceof AstCall) && !(t instanceof AstRef))
    171171                    return false;
    172172            }
    173             expandFirstTerm(exp);
     173            expandFirstTerm(expr);
    174174        }
    175175    }
     
    177177    private boolean expMayBeEmpty () {
    178178        for (;;) {
    179             if (exp.isEmpty())
     179            if (expr.isEmpty())
    180180                return true;
    181181
    182             if (isVar(VarType.E, exp.getFirst())) {
    183                 exp.remove();
    184                 continue;
    185             }
    186 
    187             for (AstTerm t : exp) {
     182            if (isVar(VarType.E, expr.getFirst())) {
     183                expr.remove();
     184                continue;
     185            }
     186
     187            for (AstTerm t : expr) {
    188188                if (!isExpandable(t) && !isVar(VarType.E, t))
    189189                    return false;
    190190            }
    191191
    192             if (isExpandable(exp.getFirst())) {
    193                 expandFirstTerm(exp);
     192            if (isExpandable(expr.getFirst())) {
     193                expandFirstTerm(expr);
    194194                continue;
    195195            }
     
    206206            if (format.isEmpty())
    207207                break;
    208             if (!exp.isEmpty() && isTheSameRef(format.getFirst(), exp.getFirst())) {
     208            if (!expr.isEmpty() && isTheSameRef(format.getFirst(), expr.getFirst())) {
    209209                format.removeFirst();
    210                 exp.removeFirst();
     210                expr.removeFirst();
    211211                continue;
    212212            }
     
    215215                continue;
    216216            }
    217             if (!exp.isEmpty() && isExpandable(exp.getFirst())) {
    218                 expandFirstTerm(exp);
     217            if (!expr.isEmpty() && isExpandable(expr.getFirst())) {
     218                expandFirstTerm(expr);
    219219                continue;
    220220            }
     
    222222            if (!isHard(firstF))
    223223                break;
    224             if (exp.isEmpty())
    225                 return false;
    226             AstTerm firstE = exp.getFirst();
     224            if (expr.isEmpty())
     225                return false;
     226            AstTerm firstE = expr.getFirst();
    227227            if (!hardCoversHard(firstF, firstE))
    228228                return false;
    229229            format.removeFirst();
    230             exp.removeFirst();
     230            expr.removeFirst();
    231231        }
    232232
     
    234234            if (format.isEmpty())
    235235                break;
    236             if (!exp.isEmpty() && isTheSameRef(format.getLast(), exp.getLast())) {
     236            if (!expr.isEmpty() && isTheSameRef(format.getLast(), expr.getLast())) {
    237237                format.removeLast();
    238                 exp.removeLast();
     238                expr.removeLast();
    239239                continue;
    240240            }
     
    243243                continue;
    244244            }
    245             if (!exp.isEmpty() && isExpandable(exp.getLast())) {
    246                 expandLastTerm(exp);
     245            if (!expr.isEmpty() && isExpandable(expr.getLast())) {
     246                expandLastTerm(expr);
    247247                continue;
    248248            }
     
    250250            if (!isHard(lastF))
    251251                break;
    252             if (exp.isEmpty())
    253                 return false;
    254             AstTerm lastE = exp.getLast();
     252            if (expr.isEmpty())
     253                return false;
     254            AstTerm lastE = expr.getLast();
    255255            if (!hardCoversHard(lastF, lastE))
    256256                return false;
    257257            format.removeLast();
    258             exp.removeLast();
     258            expr.removeLast();
    259259        }
    260260
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/NameChecker.java

    r3570 r3619  
    325325    public void visit (AstCharSymbol astCharSymbol) {}
    326326
    327     public void visit (AstExpr astExp) {
    328         for (AstTerm astTerm : astExp.termList)
     327    public void visit (AstExpr astExpr) {
     328        for (AstTerm astTerm : astExpr.termList)
    329329            astTerm.accept(this);
    330330    }
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/RefalASGenerator.java

    r3570 r3619  
    328328    }
    329329
    330     public void visit (AstExpr astExp, Expr.Concatenator e) {
    331         for (AstTerm astTerm : astExp.termList)
     330    public void visit (AstExpr astExpr, Expr.Concatenator e) {
     331        for (AstTerm astTerm : astExpr.termList)
    332332            astTerm.accept(this, e);
    333333    }
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/VariableScopeChecker.java

    r3570 r3619  
    251251    public void visit (AstCharSymbol astCharSymbol, VarVisitor e) {}
    252252
    253     public void visit (AstExpr astExp, VarVisitor e) {
    254         for (AstTerm astTerm : astExp.termList)
     253    public void visit (AstExpr astExpr, VarVisitor e) {
     254        for (AstTerm astTerm : astExpr.termList)
    255255            astTerm.accept(this, e);
    256256    }
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/parser/RfpParser.java

    r3566 r3619  
    1010import static org.refal.rfpdt.parser.TkStarters.s_directive;
    1111import static org.refal.rfpdt.parser.TkStarters.s_directives;
    12 import static org.refal.rfpdt.parser.TkStarters.s_exp;
    13 import static org.refal.rfpdt.parser.TkStarters.s_exp_head;
     12import static org.refal.rfpdt.parser.TkStarters.s_expr;
     13import static org.refal.rfpdt.parser.TkStarters.s_expr_head;
    1414import static org.refal.rfpdt.parser.TkStarters.s_func_decl;
    1515import static org.refal.rfpdt.parser.TkStarters.s_func_def;
     
    392392    // const_binding
    393393    // : (WORD)
    394     // name EQL #exp
     394    // name EQL #expr
    395395
    396396    private void const_binding (long ftk, ArrayList<AstTopNode> list, boolean isPublic) {
    397397        assert tkIs(s_name);
    398         AstName astName = name(EQL | s_exp | ftk, null);
    399         accept(EQL, s_exp | ftk);
    400         AstExpr astExp = exp(ftk);
    401         list.add(new AstConstBinding(SrcPosition.fromToInclusive(astName.pos, astExp.pos), astName, isPublic, astExp));
     398        AstName astName = name(EQL | s_expr | ftk, null);
     399        accept(EQL, s_expr | ftk);
     400        AstExpr astExpr = expr(ftk);
     401        list.add(new AstConstBinding(SrcPosition.fromToInclusive(astName.pos, astExpr.pos), astName, isPublic, astExpr));
    402402    }
    403403
    404404    // func_decl
    405405    // : (FUNC_DECL)
    406     // FUNC_DECL name #exp EQL #exp
     406    // FUNC_DECL name #expr EQL #expr
    407407
    408408    private void func_decl (long ftk, ArrayList<AstTopNode> list, boolean isPublic) {
     
    411411        RetMode retMode = (RetMode) scanner.tkKind;
    412412        nextTk();
    413         AstName astName = name(s_exp | EQL | ftk, MsgCode.MissingFunctionName);
    414         AstExpr inFormat = exp(EQL | s_exp | ftk);
    415         accept(EQL, s_exp | ftk);
    416         AstExpr outFormat = exp(ftk);
     413        AstName astName = name(s_expr | EQL | ftk, MsgCode.MissingFunctionName);
     414        AstExpr inFormat = expr(EQL | s_expr | ftk);
     415        accept(EQL, s_expr | ftk);
     416        AstExpr outFormat = expr(ftk);
    417417        list.add(new AstFuncDecl(SrcPosition.fromToInclusive(start, outFormat.pos), astName, isPublic, retMode,
    418418                inFormat, outFormat));
     
    555555    // #let
    556556    // : (LET)
    557     // LET #exp
     557    // LET #expr
    558558    // | (COMMA | CUT | EQL | ERROR | FAIL |
    559559    // FENCE | NOT | SC | TRAP | WITH)
     
    574574            if (acceptWOError(LET, s_rest | ftk)) {
    575575                isEmptyLet = false;
    576                 astTarget = exp(s_rest | ftk);
     576                astTarget = expr(s_rest | ftk);
    577577            }
    578578            ArrayList<AstStatement> statements2 = new ArrayList<AstStatement>();
     
    661661    // REF | SC | TRAP | VAR | WITH |
    662662    // WORD)
    663     // #exp #pattern_alts
     663    // #expr #pattern_alts
    664664
    665665    private AstSentence source (long ftk) {
     
    683683            statements.add(alt(s_pattern_alts | ftk));
    684684        else {
    685             AstExpr astExp = exp(s_pattern_alts | ftk);
    686             statements.add(new AstResult(astExp.pos, astExp));
     685            AstExpr astExpr = expr(s_pattern_alts | ftk);
     686            statements.add(new AstResult(astExpr.pos, astExpr));
    687687        }
    688688        pattern_alts(ftk, statements);
     
    705705    // #pattern
    706706    // : (MATCH_DIR)
    707     // MATCH_DIR #exp
     707    // MATCH_DIR #expr
    708708    // | (CHAR | COMMA | CUT | EQL | ERROR |
    709709    // FAIL | FENCE | LANGU | LPAR | NOT |
    710710    // NUMB | REF | SC | TRAP | VAR |
    711711    // WITH | WORD)
    712     // #exp
     712    // #expr
    713713    // ;
    714714
     
    722722            nextTk();
    723723        }
    724         AstExpr astExp = exp(ftk);
    725         SrcPosition pos = start == null ? astExp.pos : SrcPosition.fromToInclusive(start, astExp.pos);
    726         statements.add(new AstPattern(pos, matchDir, astExp));
     724        AstExpr astExpr = expr(ftk);
     725        SrcPosition pos = start == null ? astExpr.pos : SrcPosition.fromToInclusive(start, astExpr.pos);
     726        statements.add(new AstPattern(pos, matchDir, astExpr));
    727727    }
    728728
     
    802802    // ========================================================================
    803803
    804     // #exp
     804    // #expr
    805805    // : (CHAR | LANGU | LPAR | NUMB | REF |
    806806    // VAR | WORD)
    807     // exp_head #exp
     807    // expr_head #expr
    808808    // | (COL | COL_CURL | COMMA | CUT | EQL |
    809809    // ERROR | FAIL | FENCE | ITER | LET |
     
    812812    // /* empty */
    813813
    814     private AstExpr exp (long ftk) {
     814    private AstExpr expr (long ftk) {
    815815        ArrayList<AstTerm> termList = new ArrayList<AstTerm>();
    816816        SrcPosition prev = prevTkPos;
    817         while (sync(s_exp_head, ftk))
    818             termList.add(exp_head(s_exp_head | ftk));
     817        while (sync(s_expr_head, ftk))
     818            termList.add(expr_head(s_expr_head | ftk));
    819819        return new AstExpr(prev, tkPos, termList.toArray(new AstTerm[termList.size()]));
    820820    }
    821821
    822     // exp_head
     822    // expr_head
    823823    // : (REF)
    824824    // REF name
     
    826826    // static_symbol
    827827    // | (LPAR)
    828     // LPAR #exp RPAR
     828    // LPAR #expr RPAR
    829829    // | (VAR)
    830830    // VAR
    831831    // | (LANGU)
    832     // LANGU name #exp RANGU
    833 
    834     private AstTerm exp_head (long ftk) {
    835         assert tkIn(s_exp_head);
     832    // LANGU name #expr RANGU
     833
     834    private AstTerm expr_head (long ftk) {
     835        assert tkIn(s_expr_head);
    836836        AstTerm astTerm;
    837837        SrcPosition start = tkPos;
     
    844844        else if (tkIs(LPAR)) {
    845845            nextTk();
    846             AstExpr astExp = exp(RPAR | ftk);
     846            AstExpr astExpr = expr(RPAR | ftk);
    847847            SrcPosition pos;
    848848            if (accept(RPAR, ftk))
     
    850850            else
    851851                pos = SrcPosition.fromToExclusive(start, tkPos);
    852             astTerm = new AstParen(pos, astExp);
     852            astTerm = new AstParen(pos, astExpr);
    853853        } else if (tkIs(VAR)) {
    854854            VarType t = AstVar.typeOfChar(scanner.tkChar);
     
    860860        } else if (tkIs(LANGU)) {
    861861            nextTk();
    862             AstName astName = name(s_exp | RANGU | ftk, MsgCode.MissingFunctionName);
    863             AstExpr astExp = exp(RANGU | ftk);
     862            AstName astName = name(s_expr | RANGU | ftk, MsgCode.MissingFunctionName);
     863            AstExpr astExpr = expr(RANGU | ftk);
    864864            SrcPosition pos;
    865865            if (accept(RANGU, ftk))
     
    867867            else
    868868                pos = SrcPosition.fromToExclusive(start, tkPos);
    869             astTerm = new AstCall(pos, astName, astExp);
     869            astTerm = new AstCall(pos, astName, astExpr);
    870870        } else {
    871871            assert false;
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/parser/TkFollowers.java

    r3566 r3619  
    5656    public static final long f_sentences = RCURL;
    5757    public static final long f_paths = RCURL;
    58     public static final long f_exp = COL | COL_CURL | COMMA | CUT | EQL | ERROR | FAIL | FENCE | ITER | LET | NOT
     58    public static final long f_expr = COL | COL_CURL | COMMA | CUT | EQL | ERROR | FAIL | FENCE | ITER | LET | NOT
    5959            | RANGU | RPAR | SC | TRAP | WITH;
    6060    public static final long f_names = SC;
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/parser/TkStarters.java

    r3566 r3619  
    7676    public static final long s_paths = CHAR | COL | COL_CURL | COMMA | CUT | EQL | ERROR | FAIL | FENCE | ITER | LANGU
    7777            | LCURL | LET | LPAR | NOT | NUMB | REF | SC | TRAP | VAR | WORD;
    78     public static final long s_exp = CHAR | LANGU | LPAR | NUMB | REF | VAR | WORD;
    79     public static final long s_exp_head = CHAR | LANGU | LPAR | NUMB | REF | VAR | WORD;
     78    public static final long s_expr = CHAR | LANGU | LPAR | NUMB | REF | VAR | WORD;
     79    public static final long s_expr_head = CHAR | LANGU | LPAR | NUMB | REF | VAR | WORD;
    8080    public static final long s_static_symbol = CHAR | NUMB | WORD;
    8181    public static final long s_names = WORD;
Note: See TracChangeset for help on using the changeset viewer.