Changeset 3119 for proto


Ignore:
Timestamp:
May 7, 2013, 10:43:37 AM (6 years ago)
Author:
ksherdy
Message:

Migrated to latest pabloS Scatter grammar. Passes all tests.

Location:
proto/pabloj/trunk
Files:
3 added
9 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r3004 r3119  
    119119        //
    120120        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    121                        
    122         funcCallOrAssignStmt    #-> expr ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ; // | (idisaCallRest _promote_)
     121       
     122        funcCallOrAssignStmt    # -> expr (assignRest _promote_)? TERMINATOR ;
    123123       
    124124        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
     
    151151        // e x p r e s s i o n s
    152152        //     
    153         expr            #->     expr1 ((OR^|XOR^) expr)? ;
    154                                        
    155         expr1           #-> expr2 ((AND^) expr1)? ;
    156                                        
    157         expr2           #-> NOT^^? expr3  _leftAssoc_;
     153        expr            #->     expr1 ((OR^|XOR^) expr)? _leftAssoc_ ;
     154                                       
     155        expr1           #-> expr2 ((AND^) expr1)? _leftAssoc_ ;
     156                                       
     157        expr2           #-> NOT^^? expr3 ;
    158158       
    159159        expr3           #-> LROUND expr RROUND
     
    211211        structTypeBody                  ->      LCURLY structMember TERMINATOR (structMember TERMINATOR)* RCURLY;
    212212                                       
    213         structMember                    ->      type structMemberName ; // (structMemberAssignOperator^! expr) ?; // TODO
     213        structMember                    ->      type structMemberName ; // (structMemberAssignOperator^! expr) ?;
    214214       
    215215        structMemberName                #-> identifier ;
  • proto/pabloj/trunk/src/pabloS/ast/ASTNode.java

    r3004 r3119  
    1111
    1212import pabloS.tokens.Token;
    13 
    14 
    15 
    16 public class ASTNode  {
     13import pabloS.inputHandler.Locator;
     14import pabloS.inputHandler.TextLocation;
     15
     16
     17
     18public class ASTNode implements Locator  {
    1719        public static final ASTNode NO_PARENT = null;
    1820        public static final int NO_TAG = -1;
     
    8486                return simplifiable;
    8587        }
     88        public TextLocation getLocation() {
     89                return getToken().getLocation();
     90        }       
    8691
    8792
     
    133138                replaceChild(index, replacement);
    134139        }
    135         private void replaceChild(int index, ASTNode replacement) {
     140        public void replaceChild(int index, ASTNode replacement) {
    136141                ASTNode oldChild = children.remove(index);
    137142                oldChild.setParent(null);
  • proto/pabloj/trunk/src/pabloS/inputHandler/BookmarkCharStream.java

    r2834 r3119  
    88package pabloS.inputHandler;
    99
    10 import java.util.Stack;
     10import java.util.ArrayDeque;
     11import java.util.Deque;
    1112
    1213public class BookmarkCharStream extends PushbackCharStream {
     
    1819
    1920       
    20         private Stack<Object> bookmarkedText;
     21        private Deque<Object> bookmarkedText;
    2122        private boolean isBookmarking;
    2223       
    2324        public BookmarkCharStream(InputHandler handler) {
    2425                super(handler);
    25                 this.bookmarkedText = new Stack<Object>();
     26                this.bookmarkedText = new ArrayDeque<Object>();
    2627                isBookmarking = false;
    2728        }
     
    7172        }
    7273
    73         // it would probably be faster to check the bottom of stack against
    74         // bookmark first...
     74
    7575        public void release(Bookmark bookmark) {
    76                 Object object;
    77                 do {
    78                         object = bookmarkedText.pop();
    79                 } while (object != bookmark);
    80                
    81                 if(bookmarkedText.isEmpty()) {
     76                if(bookmark == bookmarkedText.peekLast()) {
     77                        bookmarkedText.clear();
    8278                        isBookmarking = false;
     79                }
     80                else {
     81                        bookmarkedText.removeFirstOccurrence(bookmark);
    8382                }
    8483        }
  • proto/pabloj/trunk/src/pabloS/inputHandler/TextLocation.java

    r2834 r3119  
    99
    1010// value object for specifying the location of a lexeme or other piece of text
    11 public class TextLocation {
     11public class TextLocation implements Locator {
    1212        private String filename;
    1313        private int lineNumber;
     
    4343        }
    4444       
     45        @Override
     46        public TextLocation getLocation() {
     47                return this;
     48        }
    4549       
    4650       
  • proto/pabloj/trunk/src/pabloS/lexicalAnalyzer/tokenRecognizers/CharacterTokenRecognizer.java

    r3080 r3119  
    1010import pabloS.tokens.CharacterToken;
    1111import pabloS.tokens.Token;
    12 import pabloS.tokens.NullToken;
    1312import pabloS.inputHandler.BookmarkCharStream;
    1413import pabloS.inputHandler.LocatedChar;
    1514import pabloS.inputHandler.TextLocation;
    16 import pabloS.inputHandler.LocatedCharStream;
    1715
    1816public class CharacterTokenRecognizer extends TokenRecognizerImp {
  • proto/pabloj/trunk/src/pabloS/lexicalAnalyzer/tokenRecognizers/TokenRecognizerImp.java

    r3080 r3119  
    99import pabloS.lexicalAnalyzer.LexicalType;
    1010import pabloS.lexicalAnalyzer.TokenRecognizer;
     11import pabloS.logging.ScatterLogger;
    1112import pabloS.tokens.Token;
    1213import pabloS.inputHandler.LocatedChar;
     
    115116                return result;
    116117        }
    117                
     118
    118119        private boolean sloppyInputStartsWith(String lexeme) {
    119120                for(int i=0; i<lexeme.length(); i++) {
     
    124125                return true;
    125126        }
     127       
     128       
     129        protected void lexicalError(String msg) {
     130                logError("lexical error: " + msg);
     131        }
     132
     133        static void logError(String message) {
     134                ScatterLogger log = ScatterLogger.getLogger("compiler.semanticAnalyzer");
     135                log.severe(message);
     136        }
    126137}
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3080 r3119  
    6363                                }
    6464                        }
     65                        else {
     66                                return syntaxErrorNode("[FUNCTION¹, IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
     67                        }
    6568                }
    6669                if(allowCompression) {
     
    291294                        }
    292295                }
     296                else {
     297                        return syntaxErrorNode("[IDENTIFIER¹, IF¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STRING¹, VAR¹, WHILE¹]");
     298                }
    293299                if( nowReading.isLextant(Lextant.TERMINATOR) ) {
    294300                        expect(Lextant.TERMINATOR);
     
    314320                        allChildren.add(child);
    315321                }
    316                 if( nowReading.isLextant(Lextant.LROUND) ) {
    317                         {
    318                                 ASTNode child = parseFuncCallRest();
    319                                 result.appendChild(child);
    320                                 allChildren.add(child);
    321                         }
    322                         result = promoteLastChild(result);
    323                         allowCompression = false;
    324                 }
    325                 else if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
     322                if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    326323                        {
    327324                                ASTNode child = parseAssignRest();
     
    409406                        expect(Lextant.XOR_ASSIGN);
    410407                }
     408                else {
     409                        return syntaxErrorNode("[AND_ASSIGN¹, ASSIGN¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
     410                }
    411411                if(allowCompression) {
    412412                        return result;
     
    651651                                expect(Lextant.XOR);
    652652                        }
     653                        else {
     654                                return syntaxErrorNode("[OR¹, XOR¹]");
     655                        }
    653656                        {
    654657                                ASTNode child = parseExpr();
     
    657660                        }
    658661                }
     662                result = rotateLeftIfPossible(result);
    659663                if(allowCompression) {
    660664                        return compressIfPossible(result);
     
    686690                        }
    687691                }
     692                result = rotateLeftIfPossible(result);
    688693                if(allowCompression) {
    689694                        return compressIfPossible(result);
     
    711716                        allChildren.add(child);
    712717                }
    713                 result = rotateLeftIfPossible(result);
    714718                if(allowCompression) {
    715719                        return compressIfPossible(result);
     
    766770                        }
    767771                }
     772                else {
     773                        return syntaxErrorNode("[IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
     774                }
    768775                if(allowCompression) {
    769776                        return compressIfPossible(result);
     
    794801                                allChildren.add(child);
    795802                        }
     803                }
     804                else {
     805                        return syntaxErrorNode("[INTEGER_CONST¹, SQ_STRING¹, STRING¹]");
    796806                }
    797807                if(allowCompression) {
     
    848858                        readToken();
    849859                }
     860                else {
     861                        return syntaxErrorNode("[SQ_STRING¹, STRING¹]");
     862                }
    850863                if(allowCompression) {
    851864                        return result;
     
    938951                                allChildren.add(child);
    939952                        }
     953                }
     954                else {
     955                        return syntaxErrorNode("[IDENTIFIER¹, STREAM¹, STRUCT¹, VOID¹]");
    940956                }
    941957                if(allowCompression) {
  • proto/pabloj/trunk/src/pabloS/tokens/CharacterToken.java

    r3080 r3119  
    1111import pabloS.inputHandler.TextLocation;
    1212
    13 public class CharacterToken extends TokenImp  implements IntValuedToken {
    14         protected CharacterToken(LexicalType type, TextLocation location, String lexeme) {
     13public class CharacterToken extends TokenImp implements IntValuedToken {
     14        private char value;
     15
     16        protected CharacterToken(LexicalType type, TextLocation location, String lexeme, char value) {
    1517                super(type, location, lexeme.intern());
     18                this.value = value;
    1619        }
    1720       
    1821        public static CharacterToken make(LexicalType type, TextLocation location, String lexeme) {
    19                 CharacterToken result = new CharacterToken(type, location, lexeme);
     22                CharacterToken result = new CharacterToken(type, location, lexeme, lexeme.charAt(0));
    2023                return result;
    2124        }
    22 
    23         public int getValue() {
    24                 return (int)(getLexeme().charAt(0));
     25        public static CharacterToken make(LexicalType type, TextLocation location, String lexeme, char value) {
     26                CharacterToken result = new CharacterToken(type, location, lexeme, value);
     27                return result;
    2528        }
    2629       
     30        public char getChar() {
     31                return value;
     32        }
     33        public int getValue() {
     34                return (int)(value);
     35        }
     36
    2737        @Override
    2838        protected String rawString() {
    29                 return "character, " + getLexeme();
     39                return "character, " + getChar();
    3040        }
    3141}
  • proto/pabloj/trunk/src/pabloS/tokens/Token.java

    r2834 r3119  
    1111import pabloS.lexicalAnalyzer.Lextant;
    1212import pabloS.inputHandler.TextLocation;
     13import pabloS.inputHandler.Locator;
    1314
    14 public interface Token {
     15public interface Token extends Locator {
    1516        public String getLexeme();
    1617        public String getPrintableLexeme();
Note: See TracChangeset for help on using the changeset viewer.