Changeset 1287


Ignore:
Timestamp:
Aug 8, 2011, 11:32:17 AM (8 years ago)
Author:
shermer
Message:

v0.7.0

Major addition: the parse statement.
parseStatement package added.
util.error.ErrLog? added for centralized error reporting, and

suppression of output if errors present.

VariableNamer? expanded to provide parse-statement temporary variables.
Parser updated to handle parse statements and >+> and >+>= operators.
BasicBlock? if-statement pythonating corrected.
ASTVariable interface and base implementation introduced. It allows VariableASTB and StructFrieldASTB to be treated uniformly. isAccumulatorVariable property added to ASTVariables for use in parse statement.
ScanThroughASTB updated for representing >+> (shiftScanThrough).
TupleASTB, ParseBlockASTN, and ParseStatementASTN added.
Extracted ParentalRepair? from MacroExpander?.
Changed ASTtoIncode to handle shifted ScanThrough?.

Location:
proto/pebble/trunk
Files:
17 added
16 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/.settings/org.eclipse.core.resources.prefs

    r1242 r1287  
    1 #Wed Jul 27 02:52:56 PDT 2011
     1#Fri Aug 05 15:46:40 PDT 2011
    22eclipse.preferences.version=1
    33encoding//inputs/parabix2.py=utf-8
     4encoding//inputs/parabix2_pablo.py=utf-8
     5encoding//inputs/xmlwf2.pbl=utf-8
  • proto/pebble/trunk/inputs/xmlwf.pbl

    r1265 r1287  
    77//
    88
    9 struct Control {        // why no FF in control?
    10   x00_x1F,
    11   CR,
    12   LF,
    13   HT,
    14   SP,
    15   CRLF,
    16 }
     9
    1710
    1811macro classify_bytes {
     
    4437}
    4538
     39// TS: why no FF in control?
     40// I removed all but CRLF, which is the only field used here.
     41// Are the others needed as output?
     42struct Control {       
     43#  x00_x1F,
     44#  CR,
     45#  LF,
     46#  HT,
     47#  SP,
     48   CRLF,
     49}
     50
    4651macro normalize_line_breaks {
    4752        new<Control> control
     
    6065        CtCD_start = "<!"
    6166        EndTag_start = "</"
    62         CD_End = "]]>"
     67        CD_end = "]]>"
    6368        DoubleHyphen = "--"
    6469        PI_end = "?>"
     
    8691        CtCDPI_starts = 0
    8792        PI_name_ends = 0
    88         PI_namestarts = 0
     93        PI_name_starts = 0
    8994       
    9095        // Scanning streams
     
    95100       
    96101        // Initiate the scan
    97         CtCDPI_Cursor = 1
    98         CtCDPI_Cursor = (CtCDPI_Cursor +> CtCDPI_scan) & EOF_mask
    99        
    100         while CtCDPI_Cursor not allzero {
    101                 CtCDPI_starts |= CtCDPI_Cursor
    102                 PI_Cursor = CtCDPI_Cursor & "<?"
    103                 CD_Ct_Cursor = >(CtCDPI_Cursor & ~PI_Cursor)
    104                 CD_Cursor = CD_Ct_Cursor & [<]
    105                 Ct_Cursor = CD_Ct_Cursor & [-]
    106                
    107                 PI_starts |= PI_Cursor
    108                 CD_starts |= CD_Cursor
    109                 Ct_starts |= Ct_Cursor
    110                
    111                 Ct_Cursor >=
    112                 Ct_errors |= Ct_Cursor & ~ [^-]
    113                 Ct_Cursor >=
    114                 Ct_end_scan |= Ct_Cursor
    115                
    116                 //PI_Cursor +>= PI_end_scan
    117                 PI_Cursor >=
    118                 PI_namestarts |= PI_Cursor
    119                 PI_name_end = PI_Cursor +> nameScan
     102        CtCDPI_cursor = 1
     103        CtCDPI_cursor = (CtCDPI_cursor +> CtCDPI_scan) & EOF_mask
     104       
     105
     106        while CtCDPI_cursor not allzero {
     107                CtCDPI_starts |= CtCDPI_cursor
     108               
     109                PI_cursor = CtCDPI_cursor & "<?"
     110                CD_Ct_cursor = >(CtCDPI_cursor & ~PI_cursor)
     111                CD_cursor = CD_Ct_cursor & [<]
     112                Ct_cursor = CD_Ct_cursor & [-]
     113               
     114                PI_starts |= PI_cursor
     115                CD_starts |= CD_cursor
     116                Ct_starts |= Ct_cursor
     117               
     118                Ct_cursor >=
     119                Ct_errors |= Ct_cursor & ~ [^-]
     120                Ct_cursor >=
     121                Ct_end_scan |= Ct_cursor
     122               
     123                //PI_cursor +>= PI_end_scan
     124                PI_cursor >=
     125                PI_name_starts |= PI_cursor
     126                PI_name_end = PI_cursor +> nameScan
    120127                PI_name_ends |= PI_name_end
    121                 callouts.PI_name |= PI_Cursor <> PI_name_end 
    122                
    123                 PI_Cursor = PI_name_end +> PI_end_scan
    124                 CD_Cursor +>= CD_end_scan
    125                 Ct_Cursor = >(Ct_Cursor +> Ct_end_scan)
    126                
    127                 PI_ends |= PI_Cursor
    128                 CD_ends |= CD_Cursor
    129                 Ct_ends |= Ct_Cursor
    130                
    131                 CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
    132                 CtCDPI_Cursor +>= CtCDPI_scan
    133                 CtCDPI_Cursor &= EOF_mask
     128                callouts.PI_name |= PI_cursor <> PI_name_end 
     129               
     130                PI_cursor = PI_name_end +> PI_end_scan
     131                CD_cursor +>= CD_end_scan
     132                Ct_cursor = >(Ct_cursor +> Ct_end_scan)
     133               
     134                PI_ends |= PI_cursor
     135                CD_ends |= CD_cursor
     136                Ct_ends |= Ct_cursor
     137               
     138                CtCDPI_cursor = PI_cursor | CD_cursor | Ct_cursor
     139                CtCDPI_cursor +>= CtCDPI_scan
     140                CtCDPI_cursor &= EOF_mask
    134141        }
    135         // End of loop: no remaining CtCDPI_Cursor
     142        // End of loop: no remaining CtCDPI_cursor
    136143         
    137144        callouts.CD_span = CD_starts <> CD_ends 
     
    142149    callouts.x_error = Ct_errors | Ct_ends & [^>]
    143150    callouts.x_error |= >(PI_name_ends &~ whitespace) &~ PI_end
    144     callouts.x_error |= PI_namestarts & PI_name_ends
     151    callouts.x_error |= PI_name_starts & PI_name_ends
    145152
    146153        // If any of the Comment, CDATA or PI markups are unterminated, it is an error.
  • proto/pebble/trunk/src/ast/AST.java

    r1259 r1287  
    4848        public boolean isABlock();
    4949       
     50        // Some nodes and their subtrees denote variable names
     51        // (or lvalues...)
     52        public boolean isVariableName();
     53       
    5054        // this is a conservative equivalence-checker
    5155        // mainly for boolean expressions.
  • proto/pebble/trunk/src/ast/ASTVisitor.java

    r1258 r1287  
    9090        public void visitEnter(OrASTB node);
    9191        public void visitLeave(OrASTB node);
     92        public void visitEnter(ParseBlockASTN node);
     93        public void visitLeave(ParseBlockASTN node);
     94        public void visitEnter(ParseStatementASTN node);
     95        public void visitLeave(ParseStatementASTN node);
    9296        public void visitEnter(ProgramBlockASTN node);
    9397        public void visitLeave(ProgramBlockASTN node);
     
    108112        public void visitEnter(StructFieldASTB node);
    109113        public void visitLeave(StructFieldASTB node);
     114        public void visitEnter(TupleASTB node);
     115        public void visitLeave(TupleASTB node);
    110116        public void visitEnter(TrueLiteralASTB node);
    111117        public void visitLeave(TrueLiteralASTB node);
     
    171177                public void visitEnter(OrASTB node) { defaultVisitEnter(node); }
    172178                public void visitLeave(OrASTB node) { defaultVisitLeave(node); }
     179                public void visitEnter(ParseBlockASTN node) { defaultVisitEnter(node); }
     180                public void visitLeave(ParseBlockASTN node) { defaultVisitLeave(node); }
     181                public void visitEnter(ParseStatementASTN node) { defaultVisitEnter(node); }
     182                public void visitLeave(ParseStatementASTN node) { defaultVisitLeave(node); }
    173183                public void visitEnter(ProgramBlockASTN node) { defaultVisitEnter(node); }
    174184                public void visitLeave(ProgramBlockASTN node) { defaultVisitLeave(node); }
     
    189199                public void visitEnter(StructFieldASTB node) { defaultVisitEnter(node); }
    190200                public void visitLeave(StructFieldASTB node) { defaultVisitLeave(node); }
     201                public void visitEnter(TupleASTB node) { defaultVisitEnter(node); }
     202                public void visitLeave(TupleASTB node) { defaultVisitLeave(node); }
    191203                public void visitEnter(TrueLiteralASTB node) { defaultVisitEnter(node); }
    192204                public void visitLeave(TrueLiteralASTB node) { defaultVisitLeave(node); }
  • proto/pebble/trunk/src/ast/baseNodes/NodeImp.java

    r1259 r1287  
    3030                return false;
    3131        }
    32        
     32        // variable-nameness defaults to false.
     33        public boolean isVariableName() {
     34                return false;
     35        }
    3336        // block-ness defaults to false.
    3437        public boolean isABlock() {
     
    180183        }
    181184        public void replaceWith(AST node) {
     185//              System.err.println("replacing: " + this);
    182186                assert parent != null;
    183187                parent.replaceChild(this, node);
  • proto/pebble/trunk/src/ast/exprNodes/ScanThroughASTB.java

    r1242 r1287  
    1010        public static final int FIELD = 1;
    1111       
     12        // when shifted is false, we have normal a +> b
     13        // when shifted is true, we have a >+> b = a +> (a|b),
     14        //              which is almost >a +> b (shift and scan through)
     15        boolean shifted;
     16
     17       
    1218        ///////////////////////////////////////////////////////////
    1319        // constructors
     
    1521        private ScanThroughASTB() {
    1622                super();
     23                shifted = false;
    1724        }
    1825        private ScanThroughASTB(AST cursors, AST field) {
     
    2027                addChild(cursors);
    2128                addChild(field);
     29                shifted = false;
     30        }
     31
     32        ///////////////////////////////////////////////////////////
     33        // Node features
     34        ///////////////////////////////////////////////////////////
     35        public boolean isShifted() {
     36                return shifted;
     37        }
     38        public void setShifted(boolean shifted) {
     39                this.shifted = shifted;
    2240        }
    2341       
     
    3553                return false;
    3654        }
    37         public static AST make(AST cursors, AST field ) {
     55        public static ScanThroughASTB make(AST cursors, AST field ) {
    3856                return new ScanThroughASTB(cursors, field);
    3957        }
     
    4664        @Override
    4765        public AST copyThisNode() {
    48                 return new ScanThroughASTB();
     66                ScanThroughASTB copy = new ScanThroughASTB();
     67                copy.setShifted(shifted);
     68                return copy;
    4969        }
    5070        @Override
     
    6181        @Override
    6282        public void toBuilder(PStringBuilder builder) {
    63                 builder.append("ScanThrough(%s, %s)", getChild(CURSORS).toString(), getChild(FIELD).toString());
     83                if(shifted)
     84                        builder.append("ShiftedScanThrough(%s, %s)", getChild(CURSORS).toString(), getChild(FIELD).toString());
     85                else
     86                        builder.append("ScanThrough(%s, %s)", getChild(CURSORS).toString(), getChild(FIELD).toString());
    6487        }
    6588
  • proto/pebble/trunk/src/ast/exprNodes/StructFieldASTB.java

    r1259 r1287  
    33import util.PStringBuilder;
    44import ast.AST;
     5import ast.ASTVariable;
    56import ast.ASTVisitor;
    6 import ast.baseNodes.ExprNodeImp;
     7import ast.baseNodes.VariableNameExprImp;
    78
    8 public class StructFieldASTB extends ExprNodeImp {
     9public class StructFieldASTB extends VariableNameExprImp {
    910        // child indices
    1011        public static final int STRUCT = 0;
     
    3637                return vField.getName();
    3738        }
     39        @Override
     40        public String getName() {
     41                return structName() + "." + fieldName();
     42        }
    3843       
    3944        ///////////////////////////////////////////////////////////
     
    5055        }
    5156
    52         public static AST make(AST struct, AST field) {
     57        public static ASTVariable make(AST struct, AST field) {
    5358                return new StructFieldASTB(struct, field);
    5459        }
    5560       
    5661        // this make does its own parsing...perhaps inappropriately so.
    57         public static AST make(String name) {
     62        public static ASTVariable make(String name) {
    5863                int splitIndex = name.lastIndexOf('.');
    5964                if(splitIndex == -1) {
     
    8489        @Override
    8590        public void toBuilder(PStringBuilder builder) {
    86                 builder.append("Field(%s, %s)", getChild(0).toString(),
     91                builder.append("Field%s(%s, %s)", isAccumString(),
     92                                                                                getChild(0).toString(),
    8793                                                                            getChild(1).toString());
    8894        }
  • proto/pebble/trunk/src/ast/exprNodes/VariableASTB.java

    r1242 r1287  
    44import ast.AST;
    55import ast.ASTVisitor;
    6 import ast.baseNodes.ExprNodeImp;
     6import ast.baseNodes.VariableNameExprImp;
    77
    8 public class VariableASTB extends ExprNodeImp {
     8public class VariableASTB extends VariableNameExprImp {
    99        private String name;
    1010
     
    2020        // node features
    2121        ///////////////////////////////////////////////////////////
     22        @Override
    2223        public String getName() {
    2324                return name;
     
    3536                return false;
    3637        }
    37 
    38         public static AST make(String name) {
     38        public static VariableASTB make(String name) {
    3939                return new VariableASTB(name);
    4040        }
     
    6060        @Override
    6161        public void toBuilder(PStringBuilder builder) {
    62                 builder.append("Variable(%s)", name);
     62                builder.append("Variable%s(%s)", isAccumString(), name );
    6363        }
    64 
    6564}
  • proto/pebble/trunk/src/ast/transforms/ASTtoIncode.java

    r1281 r1287  
    149149
    150150                        String sym = newTemporary();
    151                         Instruction instr = makeScan(sym, arg0, arg1);
     151                        Instruction instr;
     152                        if(node.isShifted()) {
     153                                instr = makeShiftScan(sym, arg0, arg1);
     154                        }
     155                        else {
     156                                instr = makeScan(sym, arg0, arg1);
     157                        }
    152158                        addToBlock(instr);
    153159
  • proto/pebble/trunk/src/ast/transforms/MacroExpander.java

    r1242 r1287  
    22
    33import java.util.HashSet;
    4 import java.util.List;
    54import java.util.Set;
    65
    76import ast.AST;
    87import ast.ASTVisitor;
    9 import ast.nodes.BlockStatementASTN;
    10 import ast.nodes.ExecutionBlockASTN;
    118import ast.nodes.ExpandASTN;
    129
     
    1815                ExpandMacrosVisitor expander = new ExpandMacrosVisitor();
    1916                tree.accept(expander);
    20                 expander.assembleNewChildLists();
     17                ParentalRepair.apply(expander.parents);
    2118        }
    2219
     
    2623        }
    2724       
     25       
     26        /////////////////////////////////////////////////////////////
     27        // visitor
     28        /////////////////////////////////////////////////////////////
    2829        private static class ExpandMacrosVisitor extends ASTVisitor.Default {
    2930                Set<AST> parents = new HashSet<AST>();
    30                
    31                 public void assembleNewChildLists() {
    32                         for(AST parent: parents) {
    33                                 checkParentType(parent);
    34                                 assembleNewChildren(parent);
    35                         }
    36                 }
    37                 private void assembleNewChildren(AST parent) {
    38                         List<AST> oldChildren = parent.children();
    39                         parent.removeAllChildren();
    40                         for(AST child: oldChildren) {
    41                                 if(child instanceof ExecutionBlockASTN) {
    42                                         for(AST grandchild: child.children()) {
    43                                                 parent.addChild(grandchild);
    44                                         }
    45                                 }
    46                                 else {
    47                                         parent.addChild(child);
    48                                 }
    49                         }
    50                        
    51                 }
    52                 private void checkParentType(AST parent) {
    53                         if( !(parent instanceof BlockStatementASTN ||
    54                                   parent instanceof ExecutionBlockASTN) ) {
    55                                 throw new MalformedASTException("unexpected parent of macro: " + parent);
    56                         }
    57                 }
    5831               
    5932                public void visitLeave(ExpandASTN node) {
  • proto/pebble/trunk/src/incode/BasicBlock.java

    r1284 r1287  
    1515
    1616public class BasicBlock {
     17        private static final String BASE_BASIC_BLOCK_NAME = "bblock_";
    1718        private static int count = 0;
    1819        private static Map<String, BasicBlock> blocks ;
    19         private static final String BASE_BASIC_BLOCK_NAME = "bblock_";
    2020       
    2121        private String name;
     
    2727//constructor, naming, and maintenance of static instance map
    2828///////////////////////////////////////////////////////////////////////////
    29        
    3029        public BasicBlock() {
    3130                store = new ArrayList<Instruction>(16);
     
    6564// removeLast           : removes the last instruction
    6665///////////////////////////////////////////////////////////////////////////
    67 
    6866        /**
    6967         * Adds an instruction to the end of this block.
     
    147145
    148146
    149 
    150147///////////////////////////////////////////////////////////////////////////
    151148// pythonation - converting to python code
     
    155152// pythonateOne                 : convert a single block
    156153///////////////////////////////////////////////////////////////////////////
    157        
    158154        public String pythonate(int baseIndentLevel) {
    159155                PStringBuilder result = new PStringBuilder(baseIndentLevel);
     
    203199                                pythonateWorkList(subWork, result);
    204200                                result.dedent();
    205                                
    206                                 result.appendLine("else:");
    207 
    208                                 subWork = new WorkList(falseBlock, 0);
    209                                 subWork.prohibit(joinBlock);
    210 //                                              System.err.println("    create " + subWork + " " + falseBlock.getName() + " prohibit " + joinBlock.getName());
    211 
    212                                 result.indent();
    213                                 pythonateWorkList(subWork, result);     
    214                                 result.dedent();       
     201                                if(falseBlock != joinBlock) {
     202                                        result.appendLine("else:");
     203
     204                                        subWork = new WorkList(falseBlock, 0);
     205                                        subWork.prohibit(joinBlock);
     206
     207                                        result.indent();
     208                                        pythonateWorkList(subWork, result);     
     209                                        result.dedent();       
     210                                }
    215211
    216212                                work.add(joinBlock, 0);
     
    256252        }
    257253
     254       
    258255///////////////////////////////////////////////////////////////////////////
    259256// successors
    260257///////////////////////////////////////////////////////////////////////////
    261 
    262258        /**
    263259         * Get the list of BasicBlocks that can directly follow this BasicBlock.
     
    298294        }
    299295
     296       
    300297///////////////////////////////////////////////////////////////////////////
    301298// property list delegates
     
    317314        }
    318315       
     316       
    319317///////////////////////////////////////////////////////////////////////////
    320318// toString
    321319///////////////////////////////////////////////////////////////////////////
    322 
    323320        public String toString() {
    324321                return toString("    ", 0);
  • proto/pebble/trunk/src/incode/InstructionFactories.java

    r1281 r1287  
    4141        public static Instruction makeScan(String var, String operand1, String operand2) {
    4242                return new Instruction(Op.SCAN, var, operand1, operand2);
     43        }
     44        public static Instruction makeShiftScan(String var, String operand1, String operand2) {
     45                return new Instruction(Op.SHIFTSCAN, var, operand1, operand2);
    4346        }
    4447        public static Instruction makeSpan(String var, String operand1, String operand2) {
  • proto/pebble/trunk/src/incode/Op.java

    r1284 r1287  
    2222        SHIFT(">>", 2),                 // 0 = 1 shiftby 2                      (d e i)
    2323        SCAN("+>", 2),                  // 0 = scanThrough(1, 2)        (d e e)
     24        SHIFTSCAN(">+>", 2),    // 0 = scanThrough(1, 1|2)      (d e e)
    2425        SPAN("<>", 2),                  // 0 = span(1, 2)                       (d e e)
    2526       
     
    9798                return this==AND || this==OR || this==XOR || this==NOT ||
    9899                           this==COPY || this==SEL || this==ANDNOT || this==SHIFT ||
    99                            this==SCAN || this==SPAN;    // leave INSTANTIATE out for now.
     100                           this==SCAN || this==SHIFTSCAN || this==SPAN; // leave INSTANTIATE out for now.
    100101        }
    101102        // for Jump types, the name in operand0 is the block to jump to.
     
    201202                case SHIFT:    return "%1$s = shift(%2$s, %3$s)";
    202203                case SCAN:     return "%1$s = scanThrough(%2$s, %3$s)";
     204                case SHIFTSCAN:
     205                                           return "%1$s = shiftScanThrough(%2$s, %3$s)";
    203206                case SPAN:     return "%1$s = %3$s - %2$s";
    204207                case NOP:          return "pass";
     
    228231                case SHIFT:    return "%1$s = bitutil.multiAdvance(%2$s, %3$s)";
    229232                case SCAN:     return "%1$s = bitutil.scanThru(%2$s, %3$s)";
     233                case SHIFTSCAN:
     234                                           return "%1$s = bitutil.scanThru(%2$s, (%3$s)|(%2s))";
    230235                case SPAN:     return "%1$s = %3$s - %2$s";
    231236                case NOP:          return "pass";
  • proto/pebble/trunk/src/main/Main.java

    r1280 r1287  
    1313import lexicalStream.LexicalCollector;
    1414import lexicalStream.MoveLexdefsToBranchStarts;
     15import parseStatement.ParseStatementExpander;
    1516import parser.PebbleLexer;
    1617import parser.PebbleParser;
     
    2728import ast.transforms.MacroExpander;
    2829
     30import util.error.ErrLog;
    2931
    3032public class Main {
     
    5052
    5153            MacroExpander.buildAndApply(tree);
     54//          System.err.println("tree:\n"+tree);
     55            ParseStatementExpander.apply(tree);
     56           
     57//          System.err.println("tree:\n"+tree);
    5258            MoveLexdefsToBranchStarts.apply(tree);
    5359            LexicalCollector headCollector = ((ProgramBlockASTN)tree).getCollector();
    5460 
    5561            AssumptionIncorporator.apply(tree);
    56 //            System.err.println("tree:\n"+tree);
     62//          System.err.println("tree:\n"+tree);
    5763           
    5864            headCollector.putStructsInSymbolTable(tree.getSymbolTable());
     
    6369            MergeBlocks.apply(fragment);
    6470           
    65             ReuseAvailableExpressions.apply(headBlock);
     71            ReuseAvailableExpressions.apply(headBlock);         // make this global.
    6672
    6773            LivenessProperty.build(fragment);
     
    6975           
    7076            CopyRemover.apply(fragment);
    71 //            UseAndNot.apply(fragment);
    72            
    73             Pythonater.apply(tree.getSymbolTable(), headBlock);
     77//xx            UseAndNot.apply(fragment);
     78            if(ErrLog.hasError()) {
     79                ErrLog.reportError("Errors found.  No code produced.");
     80            }
     81            else {
     82                Pythonater.apply(tree.getSymbolTable(), headBlock);
     83            }
    7484           
    7585        } catch (RecognitionException e) {
  • proto/pebble/trunk/src/parser/Pebble.g

    r1261 r1287  
    1414 
    1515  import ast.*;
     16  import ast.baseNodes.VariableNameExprImp;
    1617  import ast.exprNodes.*;
    1718  import ast.nodes.*;
     
    148149        | e=expandStatement {$asTree = $e.asTree;}
    149150        | n=newStatement        {$asTree = $n.asTree;}
    150         ;
    151 
     151        | p=parseStatement      {$asTree = $p.asTree;}
     152        ;
     153
     154parseStatement returns [AST asTree]
     155        :       'parse' format=ParseFormatString pdb=parseDefinitionBlock {
     156                        $asTree = new ParseStatementASTN($format.text);
     157                        $asTree.addChild($pdb.asTree);
     158                }
     159        ;
     160parseDefinitionBlock returns [AST asTree]
     161        :       '{' pd=parseDefinitionList '}' {
     162                        $asTree = new ParseBlockASTN();
     163                        for(AST defn: $pd.defns) {
     164                                $asTree.addChild(defn);
     165                        }
     166                }
     167        ;
     168parseDefinitionList returns [List<AST> defns]
     169@init {
     170        $defns = new ArrayList<AST>();
     171}
     172        : ( pd=parseDefn {
     173                        $defns.add($pd.asTree);
     174                }
     175        )+
     176        ;
     177       
     178parseDefn returns [AST asTree]
     179        : key=Identifier ':' c1=bExpression {
     180                        $asTree = new AssignmentASTN();
     181                        $asTree.addChild(VariableASTB.make($key.text));
     182                        $asTree.addChild($c1.asTree);
     183                }
     184        | key='start' ':' c2=bExpression {
     185                        $asTree = new AssignmentASTN();
     186                        $asTree.addChild(VariableASTB.make($key.text));
     187                        $asTree.addChild($c2.asTree);
     188                }
     189        | key='error' ':' c3=taggedCompoundVariable {
     190                        $asTree = new AssignmentASTN();
     191                        $asTree.addChild(VariableASTB.make($key.text));
     192                        $asTree.addChild($c3.asTree);
     193                }
     194        | key='markers' ':' c4=taggedCompoundVariableTuple {
     195                        $asTree = new AssignmentASTN();
     196                        $asTree.addChild(VariableASTB.make($key.text));
     197                        $asTree.addChild($c4.asTree);
     198                }
     199        ;
     200       
     201taggedCompoundVariableTuple returns [AST asTree]
     202@init {
     203        $asTree = TupleASTB.make();
     204}
     205        : '(' c=taggedCompoundVariable {
     206                                $asTree.addChild($c.asTree);
     207                        }
     208            (',' c=taggedCompoundVariable{
     209                                $asTree.addChild($c.asTree);
     210                        }
     211            )*
     212          ')'
     213        ;
     214       
     215       
    152216newStatement returns [AST asTree]
    153217        :       'new' '<' type=Identifier '>' name=Identifier {
     
    201265                                operation = ScanThroughASTB.make($t.variable, $expr.asTree);
    202266                        }
     267                        else if ($op.text.equals(">+>=")) {
     268                                ScanThroughASTB scan = ScanThroughASTB.make($t.variable, $expr.asTree);
     269                                scan.setShifted(true);
     270                                operation = scan;
     271                        }
    203272                       
    204273                        assign.addChild(operation);
     
    229298
    230299assignOp
    231         : '&=' | '|=' | '^=' | '+>='
     300        : '&=' | '|=' | '^=' | '+>=' | '>+>='
    232301        ;
    233302unaryAssignOp
     
    248317                }
    249318        ;
     319
     320taggedCompoundVariable returns [ASTVariable asTree]
     321        : cv=compoundVariable (orFlag='|')? {
     322                        $asTree = $cv.asTree;
     323                        if($orFlag != null) {
     324                                $asTree.setAccumulatorVariable(true);
     325                        }
     326                }
     327       
     328        ;
     329       
     330       
    250331       
    251332        // wrong associativity, but it doesn't (currently) nest so there's no problem.
    252 compoundVariable returns [AST asTree]
     333compoundVariable returns [ASTVariable asTree]
    253334        : s=Identifier ('.' f=Identifier)? {
    254335                        $asTree = VariableASTB.make($s.text);
     
    351432                                $asTree = $b7.asTree;
    352433                        }
    353                 (op=('+>'|'<>') b7b=bExpression7 {
    354                                 if($op.text.equals("+>")) {
    355                                         $asTree = ScanThroughASTB.make($asTree, $b7b.asTree);
     434                (op=('+>'|'<>'|'>+>') b7b=bExpression7 {
     435                                if($op.text.equals("<>")) {
     436                                        $asTree = SpanASTB.make($asTree, $b7b.asTree);
    356437                                }
    357438                                else {
    358                                         $asTree = SpanASTB.make($asTree, $b7b.asTree);
     439                                        ScanThroughASTB result = ScanThroughASTB.make($asTree, $b7b.asTree);
     440                                        if($op.text.equals(">+>")) {
     441                                                result.setShifted(true);
     442                                        }
     443                                        $asTree = result;
    359444                                }
    360445                        }
     
    471556      }
    472557    ;
    473 
    474 
     558//singleLetterIdentifier
     559//      : ('a'..'z'|'A'..'Z')
     560//      ;
    475561///////////////////////////////////////////////////////////////////////////////
    476562//
     
    482568        : '<<' Non_RAngle* '>>'
    483569        ;
    484 
     570       
     571ParseFormatString
     572        : '`' ('a'..'z'|'A'..'Z'|','|'+'|'*'|'?'|'('|')'|'~'|'>')* '`'
     573        ;
    485574Identifier
    486575        :       IdentiFrag ;
     
    562651fragment
    563652IdentiFrag
    564 //              WARNING!  dot ('.') hacked into here for allowing structure-reference!
    565 //                                      clean it up!
    566653//              '$' included for array indexing.
    567654        :       ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|'0'..'9'|'_'|'$')*
  • proto/pebble/trunk/src/util/VariableNamer.java

    r1242 r1287  
    3636        private String userVariablePrefix;
    3737        private int baseLengthMax;
     38
     39        private int parseStatementNumber;
     40        private String parseStatementPrefix;
    3841       
    3942        // an item (key) is either a CharClass or Sequence.
     
    4447        private VariableNamer(String prefix, int baseLengthMax) {
    4548                uniqueNumber = 0;
     49                parseStatementNumber = 0;
    4650               
    4751                this.prefix = prefix.intern();
     
    5054                this.temporaryVariablePrefix  = (this.prefix + "t_").intern();
    5155                this.userVariablePrefix       = (this.prefix + "u_").intern();
     56                this.parseStatementPrefix     = (this.prefix + "p").intern();
    5257               
    5358                this.baseLengthMax = baseLengthMax;
     
    6469        }       
    6570
     71        public String newParseStatement() {
     72                parseStatementNumber++;
     73                return currentParsePrefix();
     74        }
     75        private String currentParsePrefix() {
     76                return parseStatementPrefix + parseStatementNumber + "_";
     77        }
     78        public String newParseCursor() {
     79                return currentParsePrefix() + "cursor";
     80        }
     81        public String newParseError() {
     82                return currentParsePrefix() + "error";
     83        }
     84        public String newParseMarker(int markerNumber) {
     85                return currentParsePrefix() + "marker" + markerNumber;
     86        }
     87        public String parseClassName(String variable) {
     88                return currentParsePrefix() + variable;
     89        }
     90       
    6691        // not yet in use.  I can't decide if/how to create new variables
    6792        // for the same user var name in different scopes
     
    207232                return instance;
    208233        }
     234
     235
    209236}
Note: See TracChangeset for help on using the changeset viewer.