Changeset 2285


Ignore:
Timestamp:
Jan 25, 2007, 5:02:03 PM (14 years ago)
Author:
roman
Message:

Format Checker

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

Legend:

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

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

    r2228 r2285  
    1 #Sat Jan 06 02:57:32 MSK 2007
     1#Wed Jan 24 02:58:05 MSK 2007
    22eclipse.preferences.version=1
    3 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
    4 org.eclipse.jdt.core.compiler.compliance=1.5
     3org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
     4org.eclipse.jdt.core.compiler.compliance=1.6
    55org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
    66org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
    7 org.eclipse.jdt.core.compiler.source=1.5
     7org.eclipse.jdt.core.compiler.source=1.6
  • devel-tools/trunk/eclipse/org.refal.plus.comp/META-INF/MANIFEST.MF

    r2225 r2285  
    66Bundle-Localization: plugin
    77Bundle-Vendor: Program Systems Institute, Pereslavl-Zalessky
    8 Bundle-RequiredExecutionEnvironment: J2SE-1.5
     8Bundle-RequiredExecutionEnvironment: JavaSE-1.6
    99Export-Package: org.refal.plus.comp,
    1010 org.refal.plus.comp.ast
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FormatChecker.java

    r2279 r2285  
    11package org.refal.plus.comp;
    22
    3 import java.util.LinkedList;
    4 
    5 import org.refal.plus.comp.TkAttributes.VarType;
    63import org.refal.plus.comp.ast.AstAlt;
    74import org.refal.plus.comp.ast.AstAltMatch;
     
    3431import org.refal.plus.comp.ast.AstResultExp;
    3532import org.refal.plus.comp.ast.AstSentence;
    36 import org.refal.plus.comp.ast.AstSymbol;
    3733import org.refal.plus.comp.ast.AstTerm;
    3834import org.refal.plus.comp.ast.AstTopNode;
     
    5046        }
    5147
    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;
    98         }
    99 
    100         private static LinkedList<AstTerm> expandTopLevel(AstExp astExp) {
    101                 LinkedList<AstTerm> list = new LinkedList<AstTerm>();
    102                 for (AstTerm astTerm : astExp.termList) {
    103                         if (astTerm instanceof AstCall) {
    104                                 AstCall astCall = (AstCall) astTerm;
    105                                 if (astCall.funcDecl != null)
    106                                         list.addAll(astCall.funcDecl.outFormat.termList);
    107                         } else {
    108                                 list.add(astTerm);
    109                         }
    110                 }
    111                 return list;
    112         }
    113 
    114         private static boolean hardCoversHard(AstTerm f, AstTerm e) {
    115                 if (f instanceof AstSymbol) {
    116                         if (!(e instanceof AstSymbol))
    117                                 return false;
    118                         else
    119                                 return symbolCoversSymbol((AstSymbol) f, (AstSymbol) e);
    120                 } else if (f instanceof AstParen) {
    121                         if (!(e instanceof AstParen))
    122                                 return false;
    123                         else
    124                                 return covers(((AstParen) f).exp, ((AstParen) e).exp);
    125                 } else if (isVar(VarType.S, f)) {
    126                         return (e instanceof AstSymbol) || (isVar(VarType.S, e));
    127                 } else if (isVar(VarType.T, f)) {
    128                         return true;
    129                 } else {
    130                         assert false;
    131                         return false;
    132                 }
    133         }
    134 
    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 
    154         private static boolean mayBeEmpty(LinkedList<AstTerm> e) {
    155                 for (AstTerm t : e) {
    156                         if (!isVar(VarType.E, t))
    157                                 return false;
    158                 }
    159                 return true;
    160         }
    161 
    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 
    18648        private final MsgHandler msgHandler;
    18749
     
    19153
    19254        private void checkFormat(AstExp format, AstExp exp) {
    193                 if (!covers(format, exp)) {
     55                if (!FormatMatcher.covers(format, exp)) {
    19456                        msgHandler.send(exp.pos, MsgCode.FormatMismatch);
    19557                }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/NameChecker.java

    r2279 r2285  
    6969        }
    7070
    71         private void expandNames(AstExp astExp) {
    72                 ArrayList<AstTerm> termList = astExp.termList;
    73 
    74                 int i = termList.size();
    75                 while (i > 0) {
    76                         i--;
    77                         AstExp exp = getNameExpansion(termList.get(i));
    78                         if (exp != null) {
    79                                 termList.remove(i);
    80                                 termList.addAll(i, exp.termList);
    81                         }
    82                 }
    83         }
    84 
    8571        private AstFuncDecl getFuncDecl(AstName astName) {
    8672                String identifier = astName.identifier;
     
    9884        }
    9985
    100         private AstExp getNameExpansion(AstTerm astTerm) {
    101                 if (!(astTerm instanceof AstRef))
    102                         return null;
    103                 AstRef astRef = (AstRef) astTerm;
    104                 if (astRef.decl instanceof AstConstBinding)
    105                         return ((AstConstBinding) astRef.decl).exp;
    106                 else {
    107                         return new AstExp(new AstRefSymbol(astRef));
    108                 }
    109         }
    110 
    11186        public void visit(AstAlt astAlt) {
    11287                for (AstPath astPath : astAlt.pathList)
     
    148123                for (AstTerm astTerm : astExp.termList)
    149124                        astTerm.accept(this);
    150                 expandNames(astExp);
    151125        }
    152126
Note: See TracChangeset for help on using the changeset viewer.