Changeset 2255


Ignore:
Timestamp:
Jan 20, 2007, 4:13:44 PM (14 years ago)
Author:
roman
Message:

The check for hardness of format and hard expressions

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

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.plus.comp/.classpath

    r2234 r2255  
    22<classpath>
    33        <classpathentry kind="src" path="src"/>
    4         <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
     4        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
    55        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
    66        <classpathentry kind="output" path="bin"/>
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/MsgCode.java

    r2250 r2255  
    22
    33public enum MsgCode { //
     4        AVariableWithoutIndexInResultExpression(Severity.Error,
     5                        "A variable without index in result expression"), //
    46        CutWithoutAMatchingFence(Severity.Error, "\\! without a matching fence"), //
    57        DuplicateDeclarationOfTheName_X(Severity.Error,
    68                        "Duplicate declaration of the name %s"), //
    79        DuplicateDefinitionOfTheFunction_X(Severity.Error,
    8                         "Duplicate definition of the function %s"), //
    9         ExceptionThrown(Severity.Error, "Exception thrown: %s"), // 
     10                        "Duplicate definition of the function %s"), // 
     11        ExceptionThrown(Severity.Error, "Exception thrown: %s"), //
    1012        ExpectedConstructs(Severity.Error, "Expected constructs: %s"), //
    1113        Function_X_IsNotDeclared(Severity.Error, "Function %s is not declared"), //
     
    2123        NumberImmediatelyFollowedByIdentifierOrVariable(Severity.Error,
    2224                        "Number immediately followed by identifier or variable"), //
     25        SeveralSoftVariablesAtTheSameLevel(Severity.Error,
     26                        "Several soft variables at the same level"), //
    2327        TwoOccurrencesOfTheVariable_X_HaveDifferentTypes(Severity.Error,
    2428                        "Two occurrences of the variable %s have different types"), //
     
    2933        UnexpectedNewLineInCharacterString(Severity.Error,
    3034                        "Unexpected new line in character string"), //
    31         UnexpectedNewLineInWord(Severity.Error, "Unexpected new line in word"), Variable_X_IsNotDefined(Severity.Error, "Variable %s is not defined"), //
    32         WrongSyntax(
    33                         Severity.Error, "Wrong syntax"), //
     35        UnexpectedNewLineInWord(Severity.Error, "Unexpected new line in word"), //
     36        Variable_X_IsNotDefined(Severity.Error, "Variable %s is not defined"), //
     37        WrongSyntax(Severity.Error, "Wrong syntax"), //
    3438        X_IsNotAFunction(Severity.Error, "%s is not a function");
    3539
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/Parser.java

    r2248 r2255  
    170170                return new AstResultExp(astExp);
    171171        }
    172        
     172
     173        private static boolean isSoftVariable(AstTerm astTerm) {
     174                if (!(astTerm instanceof AstVar))
     175                        return false;
     176                AstVar astVar = (AstVar) astTerm;
     177                return astVar.type == VarType.E || astVar.type == VarType.V;
     178        }
     179
     180        private void checkForHardness(ArrayList<AstTerm> astTermList) {
     181                int count = 0;
     182                for (AstTerm astTerm : astTermList) {
     183                        if( isSoftVariable(astTerm) ) {
     184                                count++;
     185                                if( count > 1 )
     186                                        msgHandler.send(astTerm.pos, MsgCode.SeveralSoftVariablesAtTheSameLevel);
     187                        }
     188
     189                }
     190        }
     191
    173192        public static AstInterf parseInterf(Scanner scanner, String fileName,
    174193                        MsgHandler msgHandler) {
     
    511530                                astPath = astRest;
    512531                        } else {
    513                                 astPath = new AstLet(astSource, new AstExp(),
    514                                                 astRest);
     532                                astPath = new AstLet(astSource, new AstExp(), astRest);
    515533                        }
    516534                } else if (tkIs(LET)) {
     
    707725                        matchDir = MatchDir.L;
    708726                }
    709                 AstExp exp = pattern_exp(ftk, stk);
     727                AstExp exp = pattern_exp(ftk, stk, false);
    710728                return new AstPattern(matchDir == MatchDir.R, exp);
    711729        }
     
    715733        // | (s_pattern_exp_head) pattern_exp_head #pattern_exp ;
    716734
    717         private AstExp pattern_exp(long ftk, long stk) {
     735        private AstExp pattern_exp(long ftk, long stk, boolean mustBeHard) {
    718736                sync(s_pattern_exp | ftk, stk);
    719737
    720738                ArrayList<AstTerm> termList = new ArrayList<AstTerm>();
    721739                while (tkIn(s_pattern_exp_head)) {
    722                         AstTerm astTerm = pattern_exp_head(s_pattern_exp | ftk, stk);
     740                        AstTerm astTerm = pattern_exp_head(s_pattern_exp | ftk, stk, mustBeHard);
    723741                        termList.add(astTerm);
    724742                }
     743                if( mustBeHard)
     744                        checkForHardness(termList);
    725745                return new AstExp(termList);
    726746        }
     
    732752        // | (VAR) VAR ;
    733753
    734         private AstTerm pattern_exp_head(long ftk, long stk) {
     754        private AstTerm pattern_exp_head(long ftk, long stk, boolean mustBeHard) {
    735755                assert tkIn(s_pattern_exp_head);
    736756                AstTerm astTerm;
     
    745765                else if (tkIs(LPAR)) {
    746766                        nextTk();
    747                         AstExp astExp = pattern_exp(RPAR, ftk | stk);
     767                        AstExp astExp = pattern_exp(RPAR, ftk | stk, mustBeHard);
    748768                        accept(RPAR);
    749769                        astTerm = new AstParen(astExp);
     
    765785
    766786        private AstExp hard_exp(long ftk, long stk) {
    767                 return pattern_exp(ftk, stk);
     787                return pattern_exp(ftk, stk, true);
    768788        }
    769789
    770790        // #format_exp
    771         // : (CHAR | EQL | LPAR | NUMB | REF | SC | VAR | WORD) #pattern_exp ;
     791        // : #pattern_exp ;
    772792
    773793        private AstExp format_exp(long ftk, long stk) {
    774                 return pattern_exp(ftk, stk);
     794                return pattern_exp(ftk, stk, true);
    775795        }
    776796
     
    867887                assert tkIn(s_const_exp_head);
    868888                AstTerm astTerm;
    869                
     889
    870890                if (tkIs(REF)) {
    871891                        nextTk();
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableScopeChecker.java

    r2250 r2255  
    3131        }
    3232
    33         public void visit(AstPatternAlt astPatternAlt,
    34                         LexicalEnvironment<VarType> t) {
    35                 for (AstSentence astSentence : astPatternAlt.sentenceList) {
    36                         LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
    37                         addVariablesFrom(t1, astSentence.pattern.exp);
    38                         astSentence.rest.accept(this, t1);
     33        private void addVariablesFrom(LexicalEnvironment<VarType> t, AstExp exp) {
     34                VariableCollector vc = new VariableCollector();
     35                vc.visit(exp);
     36                for (AstVar astVar : vc.variables) {
     37                        if (astVar.index.length() != 0)
     38                                if (!t.bindIfCompatible(astVar.index, astVar.type)) {
     39                                        twoOccurrencesWithDifferentTypes(astVar);
     40                                }
    3941                }
    4042        }
     
    4446                vc.visit(exp);
    4547                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                         }
     48                        if (astVar.index.length() != 0)
     49                                if (!t.bindIfCompatibleInScope(astVar.index, astVar.type)) {
     50                                        twoOccurrencesWithDifferentTypes(astVar);
     51                                }
    5952                }
    6053        }
     
    125118        }
    126119
     120        public void visit(AstPatternAlt astPatternAlt, LexicalEnvironment<VarType> t) {
     121                for (AstSentence astSentence : astPatternAlt.sentenceList) {
     122                        LexicalEnvironment<VarType> t1 = new LexicalEnvironment<VarType>(t);
     123                        addVariablesFrom(t1, astSentence.pattern.exp);
     124                        astSentence.rest.accept(this, t1);
     125                }
     126        }
     127
    127128        public void visit(AstResultExp astResultExp, LexicalEnvironment<VarType> t) {
    128129                AstExp astExp = astResultExp.exp;
     
    130131                vc.visit(astExp);
    131132                for (AstVar astVar : vc.variables) {
    132                         if (!t.contains(astVar.index))
     133                        if (astVar.index.length() == 0)
     134                                msgHandler.send(astVar.pos,
     135                                                MsgCode.AVariableWithoutIndexInResultExpression);
     136                        else if (!t.contains(astVar.index))
    133137                                msgHandler.send(astVar.pos, MsgCode.Variable_X_IsNotDefined,
    134138                                                astVar.index);
    135                         if( !t.isCompatibleWith(astVar.index, astVar.type))
    136                                 msgHandler.send(astVar.pos, MsgCode.TwoOccurrencesOfTheVariable_X_HaveDifferentTypes,
    137                                                 astVar.index);
     139                        else if (!t.isCompatibleWith(astVar.index, astVar.type))
     140                                msgHandler
     141                                                .send(
     142                                                                astVar.pos,
     143                                                                MsgCode.TwoOccurrencesOfTheVariable_X_HaveDifferentTypes,
     144                                                                astVar.index);
    138145                }
    139146        }
Note: See TracChangeset for help on using the changeset viewer.