Changeset 1304 for proto/pebble


Ignore:
Timestamp:
Aug 8, 2011, 11:27:33 PM (8 years ago)
Author:
shermer
Message:

Continued refactoring in the parseStatement package.

Location:
proto/pebble/trunk/src/parseStatement
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/src/parseStatement/SingleExpander.java

    r1303 r1304  
    33 */
    44package parseStatement;
    5 
    6 import static parseStatement.Plurality.*;
    75
    86import java.util.Deque;
     
    1917import ast.nodes.*;
    2018
    21 class SingleExpander {
     19import static parseStatement.ASTCodeUtils.*;
     20
     21
     22public class SingleExpander {
    2223        private ParseBlockASTN parseBlock;      // the AST of the parseBlock.  Used to look up definitions.
    2324        private Deque<AST> blocks;                      // stack: top is list of blocks we're adding to.
     
    2930        private Set<String> variablesUsed;      // prefixed? single-letter variable names used.
    3031
    31        
     32
     33
    3234        ////////////////////////////////////////////////////////////
    33         // public: constructor and writeParseRoutine
     35        // public: constructor, accessors, and writeParseRoutine
    3436        ////////////////////////////////////////////////////////////
    3537        public SingleExpander(ParseBlockASTN parseBlock) {
     
    3941               
    4042                this.blocks = new LinkedList<AST>();
     43        }
     44        public String getCursorVariable() {
     45                return cursor;
     46        }
     47        public String getErrorVariable() {
     48                return error;
    4149        }
    4250       
     
    5159                return blocks.pop();
    5260        }
    53        
    5461        ////////////////////////////////////////////////////////////
    55         // short parts of writeParseRoutine
     62        // parts of writeParseRoutine
    5663        ////////////////////////////////////////////////////////////
    5764        private void initializeParsingVariables() {
    5865                makeBaseVariableNames();
    59                 assignToZero(error);
    60                 assign(cursor, getRequiredDefn("start"));
     66                AST errorAST  = assignToZeroAST(error);
     67                AST cursorAST = assignAST(cursor, getRequiredDefn("start"));
     68               
     69                addCodeNode(errorAST);
     70                addCodeNode(cursorAST);
    6171        }
    6272        private void makeBaseVariableNames() {
     
    6575                error  = namer.newParseError();
    6676        }               
     77        public void addParsingCode(List<Step> steps) { 
     78                for(Step step: steps) {
     79                        step.generateCode(this);
     80                }
     81        }
    6782        private void assignErrorVariable() {
    6883                AST errorDefinition = parseBlock.lookup("error");
     
    7489                }
    7590               
    76                 updateVariable((ASTVariable)errorDefinition, var(error));
     91                AST updateAST = updateVariableAST(((ASTVariable)errorDefinition), VariableASTB.make(error));
     92                addCodeNode(updateAST);
    7793        }               
    7894        private void insertUsedVariables() {
     
    8096                        AST definition = getRequiredDefn(var);
    8197                        String vname = namer.parseClassName(var);
    82                         insertAssign(vname, definition);
     98                        AST assignAST = assignAST(vname, definition);
     99                        insertCodeNode(assignAST);
    83100                }
    84101        }       
     
    86103       
    87104        ////////////////////////////////////////////////////////////
    88         // addParsingCode is the main (recursive) step of writeParseRoutine.
    89         //
    90         // It has four children, for each of the child cases:
    91         //              generateHasMarkerCode
    92         //              generateIsAnyCharCode
    93         //              generateHasChildrenCode
    94         //              generateHasVariableCode
     105        // getRequiredDefn : get a definition from the parseBlock,
     106        //                                       or give an error if it isn't there.
    95107        ////////////////////////////////////////////////////////////
    96108
    97         private void addParsingCode(List<Step> steps) {
    98                 for(Step step: steps) {
    99                        
    100                         // step may need subclasses...this is clearly a type switch.
    101                         if(step.hasMarker()) {
    102                                 generateHasMarkerCode(step);
    103                         }
    104                         else if(step.isAnyChar()) {
    105                                 generateIsAnyCharCode(step);
    106                         }
    107                         else if(step.isSubgroup()) {
    108                                 generateHasChildrenCode(step);
    109                         }
    110                         else { // step.hasVariable()
    111                                 generateHasVariableCode(step);
    112                         }
    113                 }
    114         }
    115 
    116         /**
    117          *  generateHasMarkerCode simply updates a marker variable.
    118          *              markerVariable[#]  = cursor, or
    119          *              markerVariable[#] |= cursor, if it's an accumulator.   
    120          */
    121         private void generateHasMarkerCode(Step step) {
    122                 AST definition = getRequiredDefn("markers");
    123                 if(!(definition instanceof TupleASTB)) {
    124                         ErrLog.reportError("parse statement marker definition not a tuple.");
    125                         return;
    126                 }
    127 
    128                 TupleASTB tuple = (TupleASTB)(definition);
    129                 if(tuple.nChildren()-1 < step.getMarker()) {
    130                         ErrLog.reportError("parse statement marker tuple not long enough.");
    131                         return;
    132                 }
    133 
    134                 AST markerName = tuple.getChild(step.getMarker());
    135                 if(!markerName.isVariableName()) {
    136                         ErrLog.reportError("parse statement marker tuple entry " + markerName + " is not a variable.");
    137                         return;
    138                 }
    139 
    140                 updateVariable((ASTVariable)markerName, var(cursor));
    141         }
    142        
    143         /**
    144          *  generateIsAnyCharCode moves the cursor forward one position.
    145          *              cursor = >cursor
    146          */
    147         private void generateIsAnyCharCode(Step step) {
    148                 AST shift = ShiftASTB.make(var(cursor), 1);
    149                 assign(cursor, shift);
    150         }
    151 
    152         /**
    153          *  generateHasChildrenCode makes a conditional.
    154          *              if cursor & childrenStartChar not allzero {
    155          *                      <<... children's code>>
    156          *              }
    157          *
    158          */
    159         private void generateHasChildrenCode(Step step) {
    160                 if(step.getPlurality()!=OPTIONAL) {
    161                         ErrLog.reportError("nonoptional parse statement child steps not implemented");
    162                         return;
    163                 }
    164 
    165                 ConditionASTN cond = hasChildrenCondition(step);
    166                 BlockStatementASTN thenBlock = new BlockStatementASTN();
    167                
    168                 IfStatementASTN ifStmt = hasChildrenIfStatment(cond, thenBlock);
    169                 blocks.peek().addChild(ifStmt);
    170                
    171                 blocks.push(thenBlock);
    172                 addParsingCode(step.getChildren());
    173                 blocks.pop();   // thenBlock comes off, but it's already a child of ifStmt.                             
    174         }
    175 
    176         // makes an IfStatementASTN with children cond and thenBlock.
    177         private IfStatementASTN hasChildrenIfStatment(ConditionASTN cond, BlockStatementASTN thenBlock) {
    178                 IfStatementASTN ifStmt = new IfStatementASTN();
    179                 ifStmt.addChild(cond);
    180                 ifStmt.addChild(thenBlock);
    181                 return ifStmt;
    182         }
    183 
    184         // makes the condition:
    185         //              cursor & childrenStartChar not allzero
    186         private ConditionASTN hasChildrenCondition(Step step) {
    187                 AST branchChars = childContentStartAST(step);
    188                 AST and = AndASTB.make(var(cursor), branchChars);
    189                 return new ConditionASTN(0, true, and);
    190         }
    191 
    192        
    193         private void generateHasVariableCode(Step step) {
    194                 switch(step.getPlurality()) {
    195                 case ONE:
    196                         generateErrorCheckCode(step);
    197                         assign(cursor, ShiftASTB.make(var(cursor), 1));
    198                         break;
    199 
    200                 case PLUS:
    201                         generateErrorCheckCode(step);
    202                         assign(cursor, ScanThroughASTB.make(var(cursor), makeHasVariableBaseAST(step)));
    203                         break;
    204 
    205                 case STAR:
    206                         // verify that scanThrough leaves cursors unchanged if they aren't in the mask.
    207                         assign(cursor, ScanThroughASTB.make(var(cursor), makeHasVariableBaseAST(step)));
    208                         break;
    209                        
    210                 case OPTIONAL:
    211                         ErrLog.reportError("parse statement optional step not implemented");
    212                         break;         
    213                 }
    214         }
    215 
    216         private void generateErrorCheckCode(Step step) {
    217                 if(step.isAnyChar()) {
    218                         return;
    219                 }
    220                 AST errorChars = NotASTB.make(makeHasVariableBaseAST(step));
    221                 AST isError = AndASTB.make(var(cursor), errorChars);
    222                 orAssign(error, isError);
    223         }
    224                
    225         // get the AST for checking the first char of a child list.
    226         public AST childContentStartAST(Step step) {   
    227                 if(step.isComplemented()) {
    228                         ErrLog.reportError("Cannot complement optional clause. Place complements inside");
    229                         return placeholder();
    230                 }
    231                 if(!step.isSubgroup()) {
    232                         ErrLog.reportCompilerError("child content sought on non-parent step.");
    233                         return placeholder();
    234                 }
    235 
    236                 List<Step> children = step.getChildren();
    237                 for(Step child: children) {
    238                         if(child.hasMarker()) {
    239                                 continue;
    240                         }
    241                         else if(child.isAnyChar()) {
    242                                 ErrLog.reportError("Optional clauses may not start with wildcard '>'.");
    243                                 return placeholder();
    244                         }
    245                         else if(child.isSubgroup()) {
    246                                 ErrLog.reportError("Clauses may not nest.");
    247                                 return placeholder();
    248                         }
    249                         else { // child.hasVariable()
    250                                 if(child.getPlurality() == STAR || child.getPlurality() == OPTIONAL) {
    251                                         ErrLog.reportError("Optional clause must start with definite character.");
    252                                         return placeholder();
    253                                 }
    254                                 return makeHasVariableBaseAST(child);
    255                         }
    256                 }
    257                 ErrLog.reportError("Optional clause must start with definite character.");
    258                 return placeholder();
    259         }
    260                
    261         private AST makeHasVariableBaseAST(Step step) {
    262                 String vname = namer.parseClassName(step.getVariable());
    263                 variablesUsed.add(step.getVariable());
    264 
    265                 AST result = VariableASTB.make(vname);
    266                 if(step.isComplemented()) {
    267                         result = NotASTB.make(result);
    268                 }
    269                 return result;
    270         }
    271        
    272                
    273         private AST getRequiredDefn(String string) {
     109        public AST getRequiredDefn(String string) {
    274110                AST definition = parseBlock.lookup(string);
    275111                if(definition == null) {
    276112                        ErrLog.reportError("parse statement is missing required definition " + string);
    277                         return placeholder();
     113                        return VariableASTB.make("error placeholder");
    278114                }
    279115                return definition;
     
    281117
    282118
     119        ////////////////////////////////////////////////////////////
     120        // access to code storage (for Step subclasses to use)
     121        ////////////////////////////////////////////////////////////
    283122
    284 
    285         /////////////////////////////////////////////////////////////
    286         // convenient expression trees
    287         // var(symbol)                                  : VariableASTB
    288         // orAssign(name, AST)                  : name |= AST   (& add to end of block)
    289         // assign(name, AST)                    : name = AST    (& add to end of block)
    290         // insertAssign(name, AST)              : name = AST    (& add to start of block)
    291         // assignToZero(name)                   : name = 0              (& add to end of block)
    292         // updateVaraible(vDefn, AST)   : vDefn = value or vDefn |= value, as appropriate.
    293         // placeholder()                                : something to return when errors happen
    294         /////////////////////////////////////////////////////////////
    295 
    296         private AST var(String symbol) {
    297                 return VariableASTB.make(symbol);
     123        public void addCodeNode(AST ast) {
     124                blocks.peek().addChild(ast);
    298125        }
    299         private void orAssign(String name, AST rhs) {
    300                 AST var = StructFieldASTB.make(name);
    301                 AST var2 = StructFieldASTB.make(name);
    302                 AST or = OrASTB.make(var2, rhs);
    303                 AST assn = new AssignmentASTN(var, or);
    304                 blocks.peek().addChild(assn);
     126        public void insertCodeNode(AST ast) {
     127                blocks.peek().insertChild(ast);
    305128        }
    306         private void assign(String name, AST rhs) {
    307                 AST var = StructFieldASTB.make(name);
    308                 AST assn = new AssignmentASTN(var, rhs);
    309                 blocks.peek().addChild(assn);
     129        public void push(BlockStatementASTN block) {
     130                blocks.push(block);
    310131        }
    311         private void assignToZero(String name) {
    312                 AST zero = FalseLiteralASTB.make();
    313                 assign(name, zero);
     132        public AST pop() {
     133                return blocks.pop();
     134        }
     135        public void addVariableUsage(String variable) {
     136                variablesUsed.add(variable);
    314137        }
    315138
    316         private void insertAssign(String name, AST rhs) {
    317                 AST var = StructFieldASTB.make(name);
    318                 AST assn = new AssignmentASTN(var, rhs);
    319                 blocks.peek().insertChild(assn);
    320         }
    321         private void updateVariable(ASTVariable vDefinition, AST value) {
    322                 if(vDefinition.isAccumulatorVariable()) {
    323                         orAssign(vDefinition.getName(), value);
    324                 }
    325                 else {
    326                         assign(vDefinition.getName(), value);
    327                 }
    328         }
    329         private VariableASTB placeholder() {
    330                 return VariableASTB.make("error placeholder");
    331         }
    332139}
  • proto/pebble/trunk/src/parseStatement/Step.java

    r1303 r1304  
    11package parseStatement;
    2 
    3 import java.util.List;
    4 
    52
    63import util.PStringBuilder;
     
    96// base class for steps in the parsing algorithm
    107public abstract class Step {
    11         static final int NO_MARKER = -1;
    12 
    13        
    14         //      four types of main content:
    15         //              1) variable: a single char representing a stream
    16         //              2) children: a list of steps that are substeps
    17         //              3) wildcard: '>' represents any character
    18         //              4) marker: ',' denotes a marker
    19         //
    20         //      only variable can be complemented.
    21         //      marker and anychar may not have plurality other than ONE.
    22         //  children must have plurality OPTIONAL
    23         //  variable has any plurality except OPTIONAL.
    24         //
    25        
     8        protected SingleExpander expander;
    269        boolean isComplemented;
    2710        Plurality plurality;
     11
    2812       
    2913        public Step() {
    3014                isComplemented = false;
    3115                plurality = Plurality.ONE;
    32         }
    33         public boolean hasContent() {
    34                 return isSubgroup();
     16                expander = null;
    3517        }
    3618
    3719        // issue an error if there is a problem with the object
    3820        abstract public void validate();
    39        
    40         /////////////////////////////////////////////////////////////
    41         // markers
    42         /////////////////////////////////////////////////////////////
    43         public boolean hasMarker() {
    44                 return false;
    45         }
    46         public int getMarker() {
    47                 return NO_MARKER;
    48         }
    49 
    50         /////////////////////////////////////////////////////////////
    51         // wildcard
    52         /////////////////////////////////////////////////////////////
    53         public boolean isAnyChar() {
    54                 return false;
    55         }
    56 
    57         /////////////////////////////////////////////////////////////
    58         // children
    59         /////////////////////////////////////////////////////////////
    60         public boolean isSubgroup() {
    61                 return false;
    62         }
    63         public List<Step> getChildren() {
    64                 return null;
    65         }
    66         public void setChildren(List<Step> steps) {
    67         }
    68        
    69        
    70         /////////////////////////////////////////////////////////////
    71         // variable
    72         /////////////////////////////////////////////////////////////
    73         public boolean hasVariable() {
    74                 return false;
    75         }
    76         public String getVariable() {
    77                 System.err.println(this);
    78                 return "getVariable called on non-variable step";
    79         }
    80        
    8121
    8222       
    8323        /////////////////////////////////////////////////////////////
    84         // non-content properties
     24        // property accessors/mutators
    8525        /////////////////////////////////////////////////////////////
    8626        public boolean isComplemented() {
     
    9030                isComplemented = value;
    9131        }
    92        
    9332       
    9433        public void setPluralityForChar(char c) {
     
    13372
    13473       
    135 
    136 
    137 
     74        /////////////////////////////////////////////////////////////
     75        // parsing code generation
     76        /////////////////////////////////////////////////////////////
     77        public void generateCode(SingleExpander expander) {
     78                this.expander = expander;
     79                generateCode();
     80        }
     81        abstract public void generateCode();
    13882}
  • proto/pebble/trunk/src/parseStatement/steps/MarkerStep.java

    r1303 r1304  
    11package parseStatement.steps;
    22
     3import ast.AST;
     4import ast.ASTVariable;
     5import ast.exprNodes.TupleASTB;
    36import parseStatement.Plurality;
    47import parseStatement.Step;
    58import util.error.ErrLog;
     9
     10import static parseStatement.ASTCodeUtils.*;
     11
    612
    713public class MarkerStep extends Step {
     
    1319       
    1420        int markerNumber;
     21        public static final int NO_MARKER = -1;
    1522       
    1623        private MarkerStep(int markerNumber) {
     
    4350                return "marker " + markerNumber;
    4451        }
     52       
     53
     54        /////////////////////////////////////////////////////////////
     55        // parsing code generation
     56        /////////////////////////////////////////////////////////////
     57        /**
     58         *  MarkerStep.generateCode simply updates a marker variable.</p>
     59         *  <ul>
     60         *              <li>markerVariable[#]  = cursor, or</li>
     61         *              <li>markerVariable[#] |= cursor, if it's an accumulator.</li>
     62         * </ul>       
     63         * @param expander TODO
     64         */
     65        public void generateCode() {
     66                AST definition = expander.getRequiredDefn("markers");
     67                if(!(definition instanceof TupleASTB)) {
     68                        ErrLog.reportError("parse statement marker definition not a tuple.");
     69                        return;
     70                }
     71       
     72                TupleASTB tuple = (TupleASTB)(definition);
     73                if(tuple.nChildren()-1 < getMarker()) {
     74                        ErrLog.reportError("parse statement marker tuple not long enough.");
     75                        return;
     76                }
     77       
     78                AST markerName = tuple.getChild(getMarker());
     79                if(!markerName.isVariableName()) {
     80                        ErrLog.reportError("parse statement marker tuple entry " + markerName + " is not a variable.");
     81                        return;
     82                }
     83       
     84                ASTVariable vDefinition = (ASTVariable)markerName;
     85                AST updateAST = updateVariableAST(vDefinition, var(expander.getCursorVariable()));
     86                expander.addCodeNode(updateAST);
     87        }
    4588}
  • proto/pebble/trunk/src/parseStatement/steps/SubgroupStep.java

    r1303 r1304  
    11package parseStatement.steps;
    22
     3import static parseStatement.Plurality.OPTIONAL;
     4import static parseStatement.Plurality.STAR;
     5
    36import java.util.List;
     7
     8import ast.AST;
     9import ast.exprNodes.AndASTB;
     10import ast.exprNodes.VariableASTB;
     11import ast.nodes.BlockStatementASTN;
     12import ast.nodes.ConditionASTN;
     13import ast.nodes.IfStatementASTN;
    414
    515import parseStatement.Plurality;
     
    717import util.PStringBuilder;
    818import util.error.ErrLog;
     19
     20import static parseStatement.ASTCodeUtils.*;
    921
    1022public class SubgroupStep extends Step {
     
    6375                }
    6476        }
     77       
     78
     79        /////////////////////////////////////////////////////////////
     80        // parsing code generation
     81        /////////////////////////////////////////////////////////////
     82        /**
     83         *  SubgroupStep.generateCode makes a conditional.
     84         *              if cursor & childrenStartChar not allzero {
     85         *                      <<... children's code>>
     86         *              }
     87         *
     88         */
     89        public void generateCode() {
     90                if(getPlurality()!=OPTIONAL) {
     91                        ErrLog.reportError("nonoptional parse statement child steps not implemented");
     92                        return;
     93                }
     94       
     95                ConditionASTN cond = hasChildrenCondition();
     96                BlockStatementASTN thenBlock = new BlockStatementASTN();
     97               
     98                IfStatementASTN ifStmt = hasChildrenIfStatment(cond, thenBlock);
     99                expander.addCodeNode(ifStmt);
     100               
     101                expander.push(thenBlock);
     102                expander.addParsingCode(getChildren());
     103                expander.pop();                 // thenBlock comes off, but it's already a child of ifStmt.                             
     104        }
     105       
     106        // makes an IfStatementASTN with children cond and thenBlock.
     107        private IfStatementASTN hasChildrenIfStatment(ConditionASTN cond, BlockStatementASTN thenBlock) {
     108                IfStatementASTN ifStmt = new IfStatementASTN();
     109                ifStmt.addChild(cond);
     110                ifStmt.addChild(thenBlock);
     111                return ifStmt;
     112        }
     113
     114        // makes the condition:
     115        //              cursor & childrenStartChar not allzero
     116        private ConditionASTN hasChildrenCondition() {
     117                AST branchChars = childContentStartAST();
     118                AST and = AndASTB.make(var(expander.getCursorVariable()), branchChars);
     119                return new ConditionASTN(0, true, and);
     120        }
     121        public AST childContentStartAST() {     
     122                if(isComplemented()) {
     123                        ErrLog.reportError("Cannot complement optional clause. Place complements inside");
     124                        return placeholder();
     125                }
     126       
     127                List<Step> children = getChildren();
     128                for(Step child: children) {
     129                        // type switch.  Think about replacing with abstract method on Step.
     130                        if(child instanceof MarkerStep) {
     131                                continue;
     132                        }
     133                        else if(child instanceof WildcardStep) {
     134                                ErrLog.reportError("Optional clauses may not start with wildcard '>'.");
     135                                return placeholder();
     136                        }
     137                        else if(child instanceof SubgroupStep) {
     138                                ErrLog.reportError("Clauses may not nest.");
     139                                return placeholder();
     140                        }
     141                        else if(child instanceof VariableStep) {
     142                                if(child.getPlurality() == STAR || child.getPlurality() == OPTIONAL) {
     143                                        ErrLog.reportError("Optional clause must start with definite character.");
     144                                        return placeholder();
     145                                }
     146                                return ((VariableStep)child).makeBaseAST(expander);
     147                        }
     148                        else {
     149                                assert false: "unknown child type in SubgroupStep.childContentStartAST";
     150                        }
     151                }
     152                ErrLog.reportError("Optional clause must start with definite character.");
     153                return placeholder();
     154        }
     155
     156        public VariableASTB placeholder() {
     157                return VariableASTB.make("error placeholder");
     158        }
    65159}
  • proto/pebble/trunk/src/parseStatement/steps/VariableStep.java

    r1303 r1304  
    11package parseStatement.steps;
    22
     3import ast.AST;
     4import ast.exprNodes.AndASTB;
     5import ast.exprNodes.NotASTB;
     6import ast.exprNodes.ScanThroughASTB;
     7import ast.exprNodes.ShiftASTB;
     8import ast.exprNodes.VariableASTB;
    39import parseStatement.Plurality;
     10import parseStatement.SingleExpander;
    411import parseStatement.Step;
     12import util.VariableNamer;
    513import util.error.ErrLog;
     14
     15import static parseStatement.ASTCodeUtils.*;
    616
    717public class VariableStep extends Step {
     
    4252                return "variable " + variable;
    4353        }
     54       
     55
     56        /////////////////////////////////////////////////////////////
     57        // parsing code generation
     58        /////////////////////////////////////////////////////////////
     59        public void generateCode() {
     60                switch(getPlurality()) {
     61                case ONE:
     62                        generateErrorCheckCode(expander);
     63                        AST oneAST = assignAST(expander.getCursorVariable(), ShiftASTB.make(var(expander.getCursorVariable()), 1));
     64                        expander.addCodeNode(oneAST);
     65                        break;
     66       
     67                case PLUS:
     68                        generateErrorCheckCode(expander);
     69                        AST plusAST = assignAST(expander.getCursorVariable(), ScanThroughASTB.make(var(expander.getCursorVariable()), makeBaseAST(expander)));
     70                        expander.addCodeNode(plusAST);
     71                        break;
     72       
     73                case STAR:
     74                        // verify that scanThrough leaves cursors unchanged if they aren't in the mask.
     75                        AST starAST = assignAST(expander.getCursorVariable(), ScanThroughASTB.make(var(expander.getCursorVariable()), makeBaseAST(expander)));
     76                        expander.addCodeNode(starAST);
     77                        break;
     78                       
     79                case OPTIONAL:
     80                        ErrLog.reportError("parse statement optional step not implemented");
     81                        break;         
     82                }
     83        }
     84       
     85        public AST makeBaseAST(SingleExpander expander) {
     86                VariableNamer namer = VariableNamer.getInstance();
     87                String vname = namer.parseClassName(getVariable());
     88               
     89                expander.addVariableUsage(getVariable());
     90       
     91                AST result = VariableASTB.make(vname);
     92                if(isComplemented()) {
     93                        result = NotASTB.make(result);
     94                }
     95                return result;
     96        }
     97       
     98        public void generateErrorCheckCode(SingleExpander singleExpander) {
     99                AST errorChars = NotASTB.make(makeBaseAST(singleExpander));
     100                AST isError = AndASTB.make(var(singleExpander.getCursorVariable()), errorChars);
     101                singleExpander.addCodeNode(orAssignAST(singleExpander.getErrorVariable(), isError));
     102        }
    44103}
  • proto/pebble/trunk/src/parseStatement/steps/WildcardStep.java

    r1303 r1304  
    11package parseStatement.steps;
    22
     3import ast.AST;
     4import ast.exprNodes.ShiftASTB;
    35import parseStatement.Plurality;
    46import parseStatement.Step;
    57import util.error.ErrLog;
     8
     9import static parseStatement.ASTCodeUtils.*;
    610
    711public class WildcardStep extends Step {
     
    3741                return "wildcard";
    3842        }
     43
     44
     45        /////////////////////////////////////////////////////////////
     46        // parsing code generation
     47        /////////////////////////////////////////////////////////////
     48        /**
     49         *  generateIsAnyCharCode moves the cursor forward one position.
     50         *  <ul>
     51         *              <li> cursor = >cursor
     52         *  </ul>
     53         * @param expander TODO
     54         */
     55        public void generateCode() {
     56                AST shift = ShiftASTB.make(var(expander.getCursorVariable()), 1);
     57                expander.addCodeNode(assignAST(expander.getCursorVariable(), shift));
     58        }
    3959}
Note: See TracChangeset for help on using the changeset viewer.