Changeset 2378


Ignore:
Timestamp:
Feb 11, 2007, 1:50:02 AM (14 years ago)
Author:
roman
Message:

CompilerEnvironment?

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

Legend:

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

    r2290 r2378  
    22
    33public class ConsoleMsgHandler extends MsgHandler {
     4
     5        static private RfpResource errorResource = RfpResource.implem("UNKNOWN");
     6
     7        private static String buildFileName(SrcPosition pos) {
     8                RfpResource resource = pos.rfpResource;
     9                String fileExt = resource.isInterface ? ".rfi" : ".rf";
     10                String fileName = resource.moduleName + fileExt;
     11                return fileName;
     12        }
    413
    514        @Override
     
    716                updateCounters(msgCode);
    817                if (pos == null)
    9                         pos = new SrcPosition("ERROR", 1, 0, 0, 0);
     18                        pos = new SrcPosition(errorResource, 1, 0, 0, 0);
    1019                String severity;
    1120                switch (msgCode.getSeverity()) {
     
    2231                        throw new IllegalArgumentException();
    2332                }
    24                 System.out.printf("%s(%d, %d): %s: ", pos.fileName, pos.line,
     33                System.out.printf("%s(%d, %d): %s: ", buildFileName(pos), pos.line,
    2534                                pos.charStart - pos.lineStart + 1, severity);
    2635                System.out.printf(msgCode.getFormat(), args);
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FenceAndCutChecker.java

    r2279 r2378  
    3434import org.refal.plus.comp.ast.AstTraceAll;
    3535import org.refal.plus.comp.ast.AstTrap;
     36import org.refal.plus.comp.ast.AstUse;
    3637import org.refal.plus.comp.ast.AstVar;
    3738import org.refal.plus.comp.ast.AstWordSymbol;
     
    197198                throw new UnsupportedOperationException();
    198199        }
     200
     201        public void visit(AstUse astUse, Integer e) {
     202                throw new UnsupportedOperationException();
     203        }
    199204}
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/FormatChecker.java

    r2285 r2378  
    3535import org.refal.plus.comp.ast.AstTraceAll;
    3636import org.refal.plus.comp.ast.AstTrap;
     37import org.refal.plus.comp.ast.AstUse;
    3738import org.refal.plus.comp.ast.AstVar;
    3839import org.refal.plus.comp.ast.AstWordSymbol;
     
    194195        }
    195196
     197        public void visit(AstUse astUse, AstExp e) {
     198                throw new UnsupportedOperationException();
     199        }
     200
    196201        public void visit(AstVar astVar, AstExp e) {
    197202        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ImportChecker.java

    r2373 r2378  
    66import org.refal.plus.comp.ast.AstImplem;
    77import org.refal.plus.comp.ast.AstName;
     8import org.refal.plus.comp.ast.AstUse;
    89
    910public class ImportChecker {
     
    1516
    1617                ArrayList<String> moduleNameList = new ArrayList<String>();
    17                 AstName[] astNameList = astImplem.moduleNames;
    18                 for (AstName astName : astNameList) {
     18                AstUse[] astUseList = astImplem.useList;
     19                for (AstUse astUse : astUseList) {
     20                        AstName astName = astUse.name;
    1921                        String moduleName = astName.identifier;
    2022                        if (moduleName.equals(currentModuleName)) {
     
    3739        public static void populateImports(AstImplem astImplem,
    3840                        CompilerEnvironment environment) {
    39                 AstName[] astNameList = astImplem.moduleNames;
    40                 for (AstName astName : astNameList) {
    41                         String moduleName = astName.identifier;
     41                AstUse[] astUseList = astImplem.useList;
     42                for (AstUse astUse : astUseList) {
     43                        String moduleName = astUse.name.identifier;
    4244                }
    4345
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/NameChecker.java

    r2285 r2378  
    3939import org.refal.plus.comp.ast.AstTraceAll;
    4040import org.refal.plus.comp.ast.AstTrap;
     41import org.refal.plus.comp.ast.AstUse;
    4142import org.refal.plus.comp.ast.AstVar;
    4243import org.refal.plus.comp.ast.AstWordSymbol;
     
    264265        }
    265266
     267        public void visit(AstUse astUse) {
     268                throw new UnsupportedOperationException();
     269        }
     270
    266271        public void visit(AstVar astVar) {
    267272                return;
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/RfpParser.java

    r2370 r2378  
    111111import org.refal.plus.comp.ast.AstTraceAll;
    112112import org.refal.plus.comp.ast.AstTrap;
     113import org.refal.plus.comp.ast.AstUse;
    113114import org.refal.plus.comp.ast.AstVar;
    114115import org.refal.plus.comp.ast.AstWordSymbol;
     
    120121        private final MsgHandler msgHandler;
    121122
    122         private RfpParser(CompilerEnvironment environment) {
     123        private RfpParser(CompilerEnvironment environment, RfpResource rfpResource) {
    123124                Reader reader = environment.getImplemReader();
    124                 String moduleName = environment.getModuleName();
    125125                MsgHandler msgHandler = environment.getMsgHandler();
    126                 RfpScanner scanner = new RfpScanner(reader, moduleName, msgHandler);
     126                RfpScanner scanner = new RfpScanner(reader, rfpResource, msgHandler);
    127127
    128128                this.scanner = scanner;
     
    224224
    225225        private void syntaxError(long expected_tokens) {
    226                 if (syntaxErrorPos.fileName == tkPos.fileName
     226                if (syntaxErrorPos.rfpResource.equals(tkPos.rfpResource)
    227227                                && syntaxErrorPos.charStart == tkPos.charStart
    228228                                && tkSubset(expected_tokens, syntaxErrorTks))
     
    288288                int count = 0;
    289289                for (AstTerm astTerm : astTermList) {
    290                         if( isSoftVariable(astTerm) ) {
     290                        if (isSoftVariable(astTerm)) {
    291291                                count++;
    292                                 if( count > 1 )
    293                                         msgHandler.send(astTerm.pos, MsgCode.SeveralSoftVariablesAtTheSameLevel);
     292                                if (count > 1)
     293                                        msgHandler.send(astTerm.pos,
     294                                                        MsgCode.SeveralSoftVariablesAtTheSameLevel);
    294295                        }
    295296
     
    297298        }
    298299
     300        public static AstInterf parseInterf(CompilerEnvironment environment,
     301                        String moduleName) {
     302                RfpResource rfpResource = RfpResource.interf(moduleName);
     303                RfpParser parser = new RfpParser(environment, rfpResource);
     304                return parser.interf();
     305        }
     306
    299307        public static AstInterf parseInterf(CompilerEnvironment environment) {
    300                 RfpParser parser = new RfpParser(environment);
     308                RfpResource rfpResource = RfpResource.interf(environment
     309                                .getModuleName());
     310                RfpParser parser = new RfpParser(environment, rfpResource);
    301311                return parser.interf();
    302312        }
    303313
    304314        public static AstImplem parseImplem(CompilerEnvironment environment) {
    305                 RfpParser parser = new RfpParser(environment);
     315                RfpResource rfpResource = RfpResource.implem(environment
     316                                .getModuleName());
     317                RfpParser parser = new RfpParser(environment, rfpResource);
    306318                return parser.implem();
    307319        }
     
    321333
    322334        private AstImplem implem() {
    323                 ArrayList<AstName> moduleNames = new ArrayList<AstName>();
     335                ArrayList<AstUse> useList = new ArrayList<AstUse>();
    324336                ArrayList<AstTopNode> topNodes = new ArrayList<AstTopNode>();
    325337
    326338                nextTk();
    327                 imports(s_directives | f_implem, tk0, moduleNames);
     339                imports(s_directives | f_implem, tk0, useList);
    328340                directives(f_implem, tk0, topNodes);
    329341
    330342                return new AstImplem( //
    331                                 moduleNames.toArray(new AstName[moduleNames.size()]), //
     343                                useList.toArray(new AstUse[useList.size()]), //
    332344                                topNodes.toArray(new AstTopNode[topNodes.size()]));
    333345        }
     
    337349        // | (USE) import #imports ;
    338350
    339         private void imports(long ftk, long stk, ArrayList<AstName> list) {
     351        private void imports(long ftk, long stk, ArrayList<AstUse> list) {
    340352                for (;;) {
    341353                        sync(USE | ftk, stk);
     
    350362        // : (USE) USE #module_names SC ;
    351363
    352         private void import_modules(long ftk, long stk, ArrayList<AstName> list) {
     364        private void import_modules(long ftk, long stk, ArrayList<AstUse> list) {
    353365                assert tkIs(USE);
    354366                nextTk();
     
    362374        // | (IDENT) name #module_names ;
    363375
    364         private void module_names(long ftk, long stk, ArrayList<AstName> list) {
     376        private void module_names(long ftk, long stk, ArrayList<AstUse> list) {
    365377                for (;;) {
    366378                        sync(IDENT | ftk, stk);
    367379                        if (!tkIs(IDENT))
    368380                                break;
    369                         list.add(new AstName(tkPos, scanner.tkString));
     381                        list.add(new AstUse(new AstName(tkPos, scanner.tkString)));
    370382                        nextTk();
    371383                }
     
    846858                SrcPosition start = tkPos;
    847859                while (tkIn(s_pattern_exp_head)) {
    848                         AstTerm astTerm = pattern_exp_head(s_pattern_exp | ftk, stk, mustBeHard);
     860                        AstTerm astTerm = pattern_exp_head(s_pattern_exp | ftk, stk,
     861                                        mustBeHard);
    849862                        termList.add(astTerm);
    850863                }
    851                 if( mustBeHard)
     864                if (mustBeHard)
    852865                        checkForHardness(termList);
    853866                return new AstExp(start, termList);
     
    868881                        nextTk();
    869882                        AstName astName = name(ftk, stk);
    870                         astTerm = new AstRef(SrcPosition.fromToInclusive(start, astName.pos), astName);
     883                        astTerm = new AstRef(SrcPosition
     884                                        .fromToInclusive(start, astName.pos), astName);
    871885                        sync(ftk, stk);
    872886                } else if (tkIn(s_static_symbol))
     
    877891                        SrcPosition end = tkPos;
    878892                        accept(RPAR);
    879                         astTerm = new AstParen(SrcPosition.fromToInclusive(start, end), astExp);
     893                        astTerm = new AstParen(SrcPosition.fromToInclusive(start, end),
     894                                        astExp);
    880895                        sync(ftk, stk);
    881896                } else if (tkIs(VAR)) {
     
    936951                        nextTk();
    937952                        AstName astName = name(ftk, stk);
    938                         astTerm = new AstRef(SrcPosition.fromToInclusive(start, astName.pos), astName);
     953                        astTerm = new AstRef(SrcPosition
     954                                        .fromToInclusive(start, astName.pos), astName);
    939955                        sync(ftk, stk);
    940956                } else if (tkIn(s_static_symbol)) {
     
    945961                        SrcPosition end = tkPos;
    946962                        accept(RPAR);
    947                         astTerm = new AstParen(SrcPosition.fromToInclusive(start, end), astExp);
     963                        astTerm = new AstParen(SrcPosition.fromToInclusive(start, end),
     964                                        astExp);
    948965                        sync(ftk, stk);
    949966                } else if (tkIs(VAR)) {
     
    957974                        SrcPosition end = tkPos;
    958975                        accept(RANGU);
    959                         astTerm = new AstCall(SrcPosition.fromToInclusive(start, end), astName, astExp);
     976                        astTerm = new AstCall(SrcPosition.fromToInclusive(start, end),
     977                                        astName, astExp);
    960978                        sync(ftk, stk);
    961979                } else {
     
    10071025                        nextTk();
    10081026                        AstName astName = name(ftk, stk);
    1009                         astTerm = new AstRef(SrcPosition.fromToInclusive(start, astName.pos), astName);
     1027                        astTerm = new AstRef(SrcPosition
     1028                                        .fromToInclusive(start, astName.pos), astName);
    10101029                        sync(ftk, stk);
    10111030                } else if (tkIn(s_static_symbol)) {
     
    10161035                        SrcPosition end = tkPos;
    10171036                        accept(RPAR);
    1018                         astTerm = new AstParen(SrcPosition.fromToInclusive(start, end), astExp);
     1037                        astTerm = new AstParen(SrcPosition.fromToInclusive(start, end),
     1038                                        astExp);
    10191039                        sync(ftk, stk);
    10201040                } else {
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/RfpScanner.java

    r2370 r2378  
    1515        private final PushbackReader reader;
    1616
    17         private final String fileName;
     17        private final RfpResource rfpResource;
    1818
    1919        private final MsgHandler msgHandler;
    2020
    21         public RfpScanner(Reader reader, String fileName,
     21        public RfpScanner(Reader reader, RfpResource rfpResource,
    2222                        MsgHandler msgHandler) {
    2323                this.reader = new PushbackReader(reader);
    24                 this.fileName = fileName;
     24                this.rfpResource = rfpResource;
    2525                this.msgHandler = msgHandler;
    2626
     
    7575        private void scanError(int line, int lineStart, int charStart, int charEnd,
    7676                        MsgCode msgCode, Object... args) {
    77                 SrcPosition pos = new SrcPosition(fileName, line, lineStart, charStart,
     77                SrcPosition pos = new SrcPosition(rfpResource, line, lineStart, charStart,
    7878                                charEnd);
    7979                msgHandler.send(pos, msgCode, args);
     
    417417                        tk = EOP;
    418418                }
    419                 tkPos = new SrcPosition(fileName, tkLine, tkLineStart, tkCharStart,
     419                tkPos = new SrcPosition(rfpResource, tkLine, tkLineStart, tkCharStart,
    420420                                tkCharEnd);
    421421        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/SrcPosition.java

    r2279 r2378  
    66                if (pos == null)
    77                        return null;
    8                 return new SrcPosition(pos.fileName, pos.line, pos.lineStart,
     8                return new SrcPosition(pos.rfpResource, pos.line, pos.lineStart,
    99                                pos.charStart, pos.charStart);
    1010        }
     
    1313                if (start == null || end == null)
    1414                        return null;
    15                 return new SrcPosition(start.fileName, start.line, start.lineStart,
     15                return new SrcPosition(start.rfpResource, start.line, start.lineStart,
    1616                                start.charStart, end.charStart - 1);
    1717        }
     
    2020                if (start == null || end == null)
    2121                        return null;
    22                 return new SrcPosition(start.fileName, start.line, start.lineStart,
     22                return new SrcPosition(start.rfpResource, start.line, start.lineStart,
    2323                                start.charStart, end.charEnd);
    2424        }
     
    2828        public final int charStart; // Zero-based
    2929
    30         public final String fileName;
     30        public final RfpResource rfpResource;
    3131
    3232        public final int line; // One-based
     
    3434        public final int lineStart; // Zero-based
    3535
     36        static private RfpResource emptyRfpresource = RfpResource.implem("");
     37       
    3638        public SrcPosition() {
    37                 this.fileName = "";
     39                this.rfpResource = emptyRfpresource;
    3840                this.line = 1;
    3941                this.lineStart = 0;
     
    4244        }
    4345
    44         public SrcPosition(String fileName, int line, int lineStart, int charStart,
     46        public SrcPosition(RfpResource rfpResource, int line, int lineStart, int charStart,
    4547                        int charEnd) {
    46                 this.fileName = fileName;
     48                this.rfpResource = rfpResource;
    4749                this.line = line;
    4850                this.lineStart = lineStart;
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableCollector.java

    r2264 r2378  
    3535import org.refal.plus.comp.ast.AstTraceAll;
    3636import org.refal.plus.comp.ast.AstTrap;
     37import org.refal.plus.comp.ast.AstUse;
    3738import org.refal.plus.comp.ast.AstVar;
    3839import org.refal.plus.comp.ast.AstWordSymbol;
     
    170171        }
    171172
     173        public void visit(AstUse astUse) {
     174                throw new UnsupportedOperationException();
     175        }
     176
    172177        public void visit(AstVar astVar) {
    173178                variables.add(astVar);
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/VariableScopeChecker.java

    r2279 r2378  
    3535import org.refal.plus.comp.ast.AstTraceAll;
    3636import org.refal.plus.comp.ast.AstTrap;
     37import org.refal.plus.comp.ast.AstUse;
    3738import org.refal.plus.comp.ast.AstVar;
    3839import org.refal.plus.comp.ast.AstWordSymbol;
     
    238239        }
    239240
     241        public void visit(AstUse astUse, LexicalEnvironment<VarType> e) {
     242                throw new UnsupportedOperationException();
     243        }
     244
    240245        public void visit(AstVar astVar, LexicalEnvironment<VarType> e) {
    241246                throw new UnsupportedOperationException();
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/AstImplem.java

    r2262 r2378  
    55
    66public final class AstImplem extends AstNode {
    7         public final AstName[] moduleNames;
     7        public final AstUse[] useList;
     8        //public final AstName[] moduleNames;
    89
    910        public final AstTopNode[] topNodes;
    1011
    11         public AstImplem(AstName[] moduleNames, AstTopNode[] topNodes) {
    12                 this.moduleNames = moduleNames;
     12        public AstImplem(AstUse[] useList, AstTopNode[] topNodes) {
     13                this.useList = useList;
    1314                this.topNodes = topNodes;
    1415        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/ImageBuilder.java

    r2264 r2378  
    127127
    128128        public void visit(AstImplem astImplem) {
    129                 if (astImplem.moduleNames.length != 0) {
     129                if (astImplem.useList.length != 0) {
    130130                        append("$use");
    131                         for (AstName astName : astImplem.moduleNames) {
     131                        for (AstUse astUse : astImplem.useList) {
    132132                                append(" ");
    133                                 astName.accept(this);
     133                                astUse.accept(this);
    134134                        }
    135135                        append(";");
     
    245245                append(" $with ");
    246246                astTrap.patternAlt.accept(this);
     247        }
     248
     249        public void visit(AstUse astUse) {
     250                astUse.name.accept(this);
    247251        }
    248252
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/NodeVisitor.java

    r2264 r2378  
    3333        void visit(AstTraceAll astTraceAll);
    3434        void visit(AstTrap astTrap);
     35        void visit(AstUse astUse);
    3536        void visit(AstVar astVar);
    3637        void visit(AstWordSymbol astWordSymbol);
  • devel-tools/trunk/eclipse/org.refal.plus.comp/src/org/refal/plus/comp/ast/VisitorWithEnv.java

    r2264 r2378  
    3333        void visit(AstTraceAll astTraceAll, E e);
    3434        void visit(AstTrap astTrap, E e);
     35        void visit(AstUse astUse, E e);
    3536        void visit(AstVar astVar, E e);
    3637        void visit(AstWordSymbol astWordSymbol, E e);
Note: See TracChangeset for help on using the changeset viewer.