Changeset 1305 for proto/pebble


Ignore:
Timestamp:
Aug 10, 2011, 2:36:43 PM (8 years ago)
Author:
shermer
Message:

v0.7.1
Work on clarifying semantics of parse statements.

Added stringConstant AST node,
Added \s escape character for space
Changed VariableNamer? to produce variable names starting with _.

Also added 'doc' directory with the BriefTour? document.

Location:
proto/pebble/trunk
Files:
7 added
15 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/inputs/input-12.pbl

    r1287 r1305  
    1010        local_part_start
    1111}
     12struct Refs {
     13        HexRef_starts, HexRef_ends,
     14        DecRef_starts, DecRef_ends,
     15        GenRef_starts, GenRef_ends,
     16}
    1217
     18macro n {
     19        new<Refs> refs
     20       
     21//      parse `(a (p ( x,h+,s)?:(,d+,s) )?:( ,n+,s ) @)?` {
     22//      parse `(a (p (xh+s | d+s)) |(,n+,s) @)?` {
     23//      parse `(a (p (xN)?:(D))?:(N)  s@)?` {
     24//              A:
     25//              N: ,n+,
     26//              H: ,h+,
     27//              D: ,d+,
     28               
     29        parse `(a  (p (x,h+,)?:( ,d+,)) ?: (,n+,)  s@)?` {
     30                a: [&]
     31                    p: [#]
     32                       x: [x]
     33                h: [0-9a-fA-F]
     34                d: [0-9]
     35                n: nameScan
     36                s: [;]
     37               
     38                start: [&]
     39                markers: (refs.HexRef_starts, refs.HexRef_ends,
     40                                  refs.DecRef_starts, refs.DecRef_ends,
     41                                  refs.GenRef_starts, refs.GenRef_ends)
     42                complaints: <<Reference error found>>
     43        }
     44}
    1345macro m_first {
    1446        new<First> first
     
    1648        x.a >+>= x.b
    1749//      parse `xn+,(c,n+)?~c` {
    18         parse `(xn+)?,,(c>,n+)?~c` {
     50//      parse `(xn+)?,,(c>,n+)?~c` {
     51//      parse `(aaa)?:(bbb)?:(ccc)` {
     52//      parse `(x(aaa)?:(bbb))?:(ccc)?` {
     53        parse `ab ab (aba) ab` {
    1954                x: [abcdef]
    2055                n: nameScan & [^:]
     56                a: [a]
     57                b: [b]
    2158                c: [:]
    2259                start: name_start
     
    2966defblock main {
    3067        nameScan = [A-Za-z0-9_:]
     68        expand n
    3169        expand m_first
    3270}
  • proto/pebble/trunk/inputs/xmlwf2.pbl

    r1303 r1305  
    343343        #
    344344        # Initiate the scan                     # TS: need to translate ScanToFirst
    345         context_Cursor = bitutil.ScanToFirst(context_opener)
     345        #context_Cursor = bitutil.ScanToFirst(context_opener)
     346        context_Cursor = 1 +> context_opener
    346347       
    347348        while context_Cursor not allzero {
     
    382383                        start: CD_Ct_Cursor
    383384                        markers: (context.CD_starts|, contexts.CD_ends|, context_ends|)
    384                         error: CD_error_ignored
     385                        # there can be no errors.
    385386                }
    386                                                                         # CD_error is dead code; there can be no errors.
    387387                                                                       
    388388                # Comment processing
     
    393393                        start: CD_Ct_Cursor
    394394                        markers: (contexts.Ct_starts|, contexts.Ct_ends|, context_ends|)
    395                         error: Ct_error
     395                        complaints: <<Error in comment syntax>>
    396396                }
    397                 if Ct_error not allzero
    398                         error <<Error in comment syntax>>
    399397
    400398                # Common processing
     
    404402
    405403                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    406                 ctCDPI_error = context_mask&~ EOF_mask
     404                ctCDPI_error = context_mask &~ EOF_mask
    407405       
    408406                if ctCDPI_error:
     
    541539
    542540macro Parse_refs {                      #(lex, marker, refs):
     541
     542        parse `(a (p (x,h+,s)?:(,d+,s) )?:(,n+,s) @)?` {
     543                a: [&]
     544                p: [#]
     545                x: [x]
     546                h: [0-9a-fA-F]
     547                d: [0-9]
     548                n: nameScan
     549                s: [;]
     550               
     551                start: [&]
     552                markers: (refs.HexRef_starts, refs.HexRef_ends,
     553                                  refs.DecRef_starts, refs.DecRef_ends,
     554                                  refs.GenRef_starts, refs.GenRef_ends)
     555                complaint: <<Reference error found>>
     556        }
     557       
    543558        ref_error = 0
    544 
    545559        # All remaining "&" must be reference start characters; parse them.
    546560        if [&] not allzero {
  • proto/pebble/trunk/src/ast/ASTVisitor.java

    r1287 r1305  
    107107        public void visitEnter(SpanASTB node);
    108108        public void visitLeave(SpanASTB node);
     109        public void visitEnter(StringConstantASTB node);
     110        public void visitLeave(StringConstantASTB node);
    109111       
    110112        public void visitEnter(StructBlockASTN node);
     
    194196                public void visitEnter(SpanASTB node) { defaultVisitEnter(node); }
    195197                public void visitLeave(SpanASTB node) { defaultVisitLeave(node); }
     198                public void visitEnter(StringConstantASTB node) { defaultVisitEnter(node); }
     199                public void visitLeave(StringConstantASTB node) { defaultVisitLeave(node); }
    196200               
    197201                public void visitEnter(StructBlockASTN node) { defaultVisitEnter(node); }
  • proto/pebble/trunk/src/ast/exprNodes/TupleASTB.java

    r1287 r1305  
    4242                return true;
    4343        }
    44         public static AST make(AST ... exprs) {
     44        public static TupleASTB make(AST ... exprs) {
    4545                return new TupleASTB(exprs);
    4646        }
  • proto/pebble/trunk/src/parseStatement/ASTCodeUtils.java

    r1304 r1305  
    33import ast.AST;
    44import ast.ASTVariable;
     5import ast.exprNodes.AndASTB;
    56import ast.exprNodes.FalseLiteralASTB;
    67import ast.exprNodes.OrASTB;
     
    1516        // assignAST(name, AST)                         : name = AST   
    1617        // orAssignAST(name, AST)                       : name |= AST   
     18        // orAssignAST(name, AST)                       : name &= AST   
    1719        // assignToZeroAST(name)                        : name = 0
    1820        // updateVaraibleAST(vDefn, AST)        : vDefn = value or vDefn |= value, as appropriate.
     
    3234        }
    3335        public static AST orAssignAST(String name, AST rhs) {
    34                 AST var = StructFieldASTB.make(name);
     36                AST var  = StructFieldASTB.make(name);
    3537                AST var2 = StructFieldASTB.make(name);
    36                 AST or = OrASTB.make(var2, rhs);
     38                AST or   = OrASTB.make(var2, rhs);
    3739                AST assn = new AssignmentASTN(var, or);
     40                return assn;
     41        }
     42        public static AST andAssignAST(String name, AST rhs) {
     43                AST var  = StructFieldASTB.make(name);
     44                AST var2 = StructFieldASTB.make(name);
     45                AST and  = AndASTB.make(var2, rhs);
     46                AST assn = new AssignmentASTN(var, and);
    3847                return assn;
    3948        }
  • proto/pebble/trunk/src/parseStatement/ParseFormatDecoder.java

    r1303 r1305  
    1212        String format;
    1313        int markerNumber;
     14        int complaintNumber;
    1415
    1516        public ParseFormatDecoder(String qformat) {
    1617                format = qformat.substring(1, qformat.length()-1);
    1718                markerNumber = 0;
     19                complaintNumber = 0;
    1820        }
    1921        public List<Step> getSteps() {
     
    2729                List<Step> result = new ArrayList<Step>();
    2830                boolean seenComplement = false;
     31                boolean awaitingElse = false;
    2932                Step current = null;
    3033               
     
    3336                        char c = format.charAt(index);
    3437                        switch(c) {
     38                        case ' ': case '\t': case '\n': case '\r':      // ignore white space
     39                                index++;
     40                                continue;       // don't do after-switch code.
     41                               
    3542                        case '~':
    3643                                issueComplementationErrors(seenComplement);
     
    4754                                index++;
    4855                                continue;       // don't do after-switch code.
     56                       
     57                        case ':':               // else clause
     58                                awaitingElse = true;
     59                                index++;
     60                                continue;
    4961                               
    5062                        case '(':
    5163                                int closingIndex = findClosingParenthesisIndex(format, index);
    5264                                List<Step> children = parseFormat(format.substring(index+1, closingIndex));
    53                                 current = SubgroupStep.make(seenComplement, children);
     65                                current = SubgroupStep.make(seenComplement, awaitingElse, children);
    5466                               
    5567                                index = closingIndex;   // gets incremented after switch at bottom of loop.
     
    5769                               
    5870                        case ',':
    59                                 current = MarkerStep.make(seenComplement, markerNumber++);
     71                                current = MarkerStep.make(seenComplement, awaitingElse, markerNumber++);
    6072                                break;
    61 
     73                               
     74                        case '@':
     75                                current = ComplaintStep.make(seenComplement, awaitingElse, complaintNumber++);
     76                                break;
     77                               
    6278                        case '>':       
    63                                 current = WildcardStep.make(seenComplement);
     79                                current = WildcardStep.make(seenComplement, awaitingElse);
    6480                                break;
    6581       
    6682                        default:
    67                                 current = VariableStep.make(seenComplement, "" + c);
     83                                current = VariableStep.make(seenComplement, awaitingElse, "" + c);
    6884                                break;
    6985                        }
     
    7288                        result.add(current);
    7389                        seenComplement = false;
     90                        awaitingElse = false;
    7491
    7592                        index++;
     
    95112                if(lastStep == null ) {
    96113                        ErrLog.reportError("malformed parse format string: found [+*?] without referent.");
    97                         return WildcardStep.make(false);        // as a placeholder.  Replace with NullStep if ever there is one.
     114                        return WildcardStep.make(false, false); // as a placeholder.  Replace with NullStep if ever there is one.
    98115                }
    99116                else if (seenComplement) {
    100117                        ErrLog.reportError("malformed parse format string: found complement before plurality.");
    101118                }
    102                 else if(lastStep.getPlurality() != lastStep.defaultPlurality()) {
     119                else if(lastStep.getPlurality() != Plurality.ONE) {
    103120                        ErrLog.reportError("malformed parse format string: found multiple [+*?] on same step.");
    104121                }
  • proto/pebble/trunk/src/parseStatement/SingleExpander.java

    r1304 r1305  
    124124                blocks.peek().addChild(ast);
    125125        }
     126        public void addElseNode(BlockStatementASTN childBlock) {
     127                AST block = blocks.peek();
     128                AST ifStmt = block.getChild(block.nChildren()-1);
     129               
     130                assert ifStmt.nChildren() == 2 || ifStmt.nChildren()==3;
     131               
     132                while(ifStmt.nChildren() == 3) {
     133                        assert ifStmt instanceof IfStatementASTN;
     134                        AST elseBlock = ifStmt.getChild(IfStatementASTN.ELSE_CLAUSE);
     135                        assert elseBlock instanceof BlockStatementASTN;
     136                        assert elseBlock.nChildren() == 1;
     137                        ifStmt = elseBlock.getChild(0);
     138                }
     139                assert ifStmt.nChildren() == 2;
     140                ifStmt.addChild(childBlock);
     141        }
    126142        public void insertCodeNode(AST ast) {
    127143                blocks.peek().insertChild(ast);
  • proto/pebble/trunk/src/parseStatement/Step.java

    r1304 r1305  
    77public abstract class Step {
    88        protected SingleExpander expander;
    9         boolean isComplemented;
    10         Plurality plurality;
     9        private boolean isComplemented;
     10        private boolean isElse;
     11        private Plurality plurality;
    1112
    1213       
    13         public Step() {
    14                 isComplemented = false;
     14        public Step(boolean isComplemented, boolean isElse) {
     15                this.isComplemented = isComplemented;
     16                this.isElse = isElse;
    1517                plurality = Plurality.ONE;
    1618                expander = null;
    1719        }
    18 
    19         // issue an error if there is a problem with the object
     20        /////////////////////////////////////////////////////////////
     21        // validation, with common requirements for subclasses to invoke.
     22        /////////////////////////////////////////////////////////////
    2023        abstract public void validate();
    21 
     24        protected void cannotBeComplemented(String type) {
     25                if(isComplemented()) {
     26                        ErrLog.reportError("malformed parse step: negation can not be applied to " + type + ".");
     27                }
     28        }
     29        protected void cannotHaveElse(String type) {
     30                if(isElse()) {
     31                        ErrLog.reportError("malformed parse step: else can not be applied to " + type + ".");
     32                }
     33        }
     34        protected void requiresPlurality(String type, Plurality...pluralities) {
     35                for(Plurality p: pluralities) {
     36                        if(p.equals(getPlurality()))
     37                                return;
     38                }
     39                ErrLog.reportError("malformed parse step:" + type + "may not have plurality" + getPlurality() + ".");
     40        }
    2241       
    2342        /////////////////////////////////////////////////////////////
     
    2948        public void setComplemented(boolean value) {
    3049                isComplemented = value;
     50        }
     51       
     52        public boolean isElse() {
     53                return isElse;
     54        }
     55        public void setIsElse(boolean value) {
     56                isElse = value;
    3157        }
    3258       
     
    4773                return plurality;
    4874        }
    49         public Plurality defaultPlurality() {
    50                 return Plurality.ONE;
     75        public boolean isPlurality(Plurality...pluralities) {
     76                for(Plurality plur: pluralities) {
     77                        if(plur==this.plurality)
     78                                return true;
     79                }
     80                return false;
    5181        }
     82
    5283       
    5384        /////////////////////////////////////////////////////////////
     
    80111        }
    81112        abstract public void generateCode();
     113        abstract public FirstChar firstChar();
    82114}
  • proto/pebble/trunk/src/parseStatement/steps/MarkerStep.java

    r1304 r1305  
    44import ast.ASTVariable;
    55import ast.exprNodes.TupleASTB;
     6import ast.exprNodes.VariableASTB;
     7import parseStatement.FirstChar;
    68import parseStatement.Plurality;
    79import parseStatement.Step;
     
    1214
    1315public class MarkerStep extends Step {
    14         public static MarkerStep make(boolean isComplemented, int markerNumber) {
    15                 MarkerStep result = new MarkerStep(markerNumber);
    16                 result.setComplemented(isComplemented);
    17                 return result;
     16        public static MarkerStep make(boolean isComplemented, boolean isElse, int markerNumber) {
     17                return new MarkerStep(isComplemented, isElse, markerNumber);
    1818        }
    1919       
     
    2121        public static final int NO_MARKER = -1;
    2222       
    23         private MarkerStep(int markerNumber) {
    24                 super();
     23        private MarkerStep(boolean isComplemented, boolean isElse, int markerNumber) {
     24                super(isComplemented, isElse);
    2525                this.markerNumber = markerNumber;
    2626        }
    2727        public void validate() {
    28                 if(isComplemented()) {
    29                         ErrLog.reportError("malformed parse step: negation can not be applied to markers.");
    30                 }
    31                 if( getPlurality() != Plurality.ONE) {
    32                         ErrLog.reportError("malformed parse step: marker may not have plurality.");
    33                 }
     28                String type = "marker";
     29                cannotHaveElse(type);
     30                cannotBeComplemented(type);
     31                requiresPlurality(type, Plurality.ONE);
    3432        }
    35        
     33
    3634        /////////////////////////////////////////////////////////////
    3735        // markers
    3836        /////////////////////////////////////////////////////////////
    39         public boolean hasMarker() {
    40                 return true;
    41         }
    4237        public int getMarker() {
    4338                return markerNumber;
     
    6156         *              <li>markerVariable[#] |= cursor, if it's an accumulator.</li>
    6257         * </ul>       
    63          * @param expander TODO
    6458         */
    6559        public void generateCode() {
    6660                AST definition = expander.getRequiredDefn("markers");
    67                 if(!(definition instanceof TupleASTB)) {
    68                         ErrLog.reportError("parse statement marker definition not a tuple.");
    69                         return;
    70                 }
     61                ASTVariable markerName = getCorrectChild(definition);
    7162       
    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()));
     63                AST updateAST = updateVariableAST(markerName, var(expander.getCursorVariable()));
    8664                expander.addCodeNode(updateAST);
    8765        }
     66        private ASTVariable getCorrectChild(AST definition) {
     67                if(!(definition instanceof TupleASTB)) {
     68                        return reportCompilerError("parse statement markers definition not a tuple.");
     69                }
     70                TupleASTB tuple = (TupleASTB)(definition);
     71               
     72                if(tuple.nChildren()-1 < getMarker()) {
     73                        return reportError("parse statement markers tuple not long enough.");
     74                }
     75                AST markerAST = tuple.getChild(getMarker());
     76               
     77                if(!(markerAST instanceof ASTVariable)) {
     78                        return reportCompilerError("parse statement markers tuple element of wrong type.");
     79                }
     80                return (ASTVariable)markerAST;
     81        }
     82       
     83        private ASTVariable reportError(String string) {
     84                ErrLog.reportError(string);
     85                return placeholder();
     86        }
     87        private ASTVariable reportCompilerError(String string) {
     88                ErrLog.reportCompilerError(string);
     89                return placeholder();
     90        }
     91        private ASTVariable placeholder() {
     92                return VariableASTB.make("erroneous marker placeholder");
     93        }
     94
     95        @Override
     96        public FirstChar firstChar() {
     97                FirstChar result = new FirstChar();
     98                result.isValid = false;
     99                return result;
     100        }
    88101}
  • proto/pebble/trunk/src/parseStatement/steps/SubgroupStep.java

    r1304 r1305  
    11package parseStatement.steps;
    22
    3 import static parseStatement.Plurality.OPTIONAL;
    4 import static parseStatement.Plurality.STAR;
     3import static parseStatement.Plurality.*;
    54
    65import java.util.List;
     
    1312import ast.nodes.IfStatementASTN;
    1413
     14import parseStatement.FirstChar;
    1515import parseStatement.Plurality;
    1616import parseStatement.Step;
     
    2121
    2222public class SubgroupStep extends Step {
    23         public static SubgroupStep make(boolean isComplemented, List<Step> children) {
    24                 SubgroupStep result = new SubgroupStep(children);
    25                 result.setComplemented(isComplemented);
    26                 return result;
     23        public static SubgroupStep make(boolean isComplemented, boolean isElse,  List<Step> children) {
     24                return new SubgroupStep(isComplemented, isElse, children);
    2725        }
    2826       
    2927        List<Step> children;
    3028       
    31         private SubgroupStep(List<Step> children) {
    32                 super();
     29        private SubgroupStep(boolean isComplemented, boolean isElse, List<Step> children) {
     30                super(isComplemented, isElse);
    3331                this.children = children;
    34                 this.setPluralityForChar('?');
    3532        }
    3633        public void validate() {
    37                 if(isComplemented()) {
    38                         ErrLog.reportError("malformed parse step: negation cannot be applied to subparse.");
    39                 }
    40                 if(getPlurality() != Plurality.OPTIONAL) {
    41                         ErrLog.reportError("malformed parse step: subparse may only have optional plurality.");
    42                 }
    43         }
    44         public Plurality defaultPlurality() {
    45                 return Plurality.OPTIONAL;
    46         }
     34                String type = "subgroup";
     35                cannotBeComplemented(type);
     36                requiresPlurality(type, Plurality.OPTIONAL, Plurality.ONE);
     37        }
     38       
    4739        /////////////////////////////////////////////////////////////
    4840        // children
     
    8880         */
    8981        public void generateCode() {
    90                 if(getPlurality()!=OPTIONAL) {
    91                         ErrLog.reportError("nonoptional parse statement child steps not implemented");
     82                BlockStatementASTN childBlock;
     83                if(getPlurality()==OPTIONAL) {
     84                        ConditionASTN cond = makeCondition();
     85                        BlockStatementASTN thenBlock = new BlockStatementASTN();
     86                        IfStatementASTN ifStmt = makeIfStatement(cond, thenBlock);
     87                       
     88                        FirstChar firstChar = firstChar();
     89                        if(firstChar.isDefinite) {
     90                                AST filter = andAssignAST(expander.getCursorVariable(), firstChar.characterTest );
     91                                thenBlock.addChild(filter);
     92                        }
     93                       
     94                        if(isElse()) {
     95                                BlockStatementASTN elseBlock = new BlockStatementASTN();
     96                                elseBlock.addChild(ifStmt);
     97                                expander.addElseNode(elseBlock);
     98                        }
     99                        else {
     100                                expander.addCodeNode(ifStmt);
     101                        }
     102                        childBlock = thenBlock;
     103                }
     104                else if(getPlurality()==ONE) {
     105                        childBlock = new BlockStatementASTN(); 
     106                        if(isElse()) {
     107                                expander.addElseNode(childBlock);
     108                        }
     109                        else {
     110                                expander.addCodeNode(childBlock);               // TODO: fix problems with raw BlockStatement children.
     111                        }
     112                }
     113                else {
     114                        ErrLog.reportError("subgroups may not be repeated with '*' or '+'.");
    92115                        return;
    93116                }
    94        
    95                 ConditionASTN cond = hasChildrenCondition();
    96                 BlockStatementASTN thenBlock = new BlockStatementASTN();
    97117               
    98                 IfStatementASTN ifStmt = hasChildrenIfStatment(cond, thenBlock);
    99                 expander.addCodeNode(ifStmt);
    100                
    101                 expander.push(thenBlock);
     118                expander.push(childBlock);
    102119                expander.addParsingCode(getChildren());
    103120                expander.pop();                 // thenBlock comes off, but it's already a child of ifStmt.                             
     
    105122       
    106123        // makes an IfStatementASTN with children cond and thenBlock.
    107         private IfStatementASTN hasChildrenIfStatment(ConditionASTN cond, BlockStatementASTN thenBlock) {
     124        private IfStatementASTN makeIfStatement(ConditionASTN cond, BlockStatementASTN thenBlock) {
    108125                IfStatementASTN ifStmt = new IfStatementASTN();
    109126                ifStmt.addChild(cond);
     
    113130
    114131        // 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);
     132        //              cursor & childrenFirstChar not allzero
     133        private ConditionASTN makeCondition() {
     134                FirstChar firstChar = firstChar();
     135                AST and = AndASTB.make(var(expander.getCursorVariable()), firstChar.characterTest);
    119136                return new ConditionASTN(0, true, and);
    120137        }
    121138        public AST childContentStartAST() {     
    122139                if(isComplemented()) {
    123                         ErrLog.reportError("Cannot complement optional clause. Place complements inside");
     140                        ErrLog.reportError("Cannot complement parse format subclause. Place complements inside");
    124141                        return placeholder();
    125142                }
     
    128145                for(Step child: children) {
    129146                        // type switch.  Think about replacing with abstract method on Step.
    130                         if(child instanceof MarkerStep) {
     147
     148                        FirstChar firstChar = child.firstChar();
     149                        if(!firstChar.isValid) {
    131150                                continue;
    132151                        }
    133152                        else if(child instanceof WildcardStep) {
    134                                 ErrLog.reportError("Optional clauses may not start with wildcard '>'.");
     153                                ErrLog.reportError("Parse format optional clauses may not start with wildcard '>'.");
    135154                                return placeholder();
    136155                        }
    137156                        else if(child instanceof SubgroupStep) {
    138                                 ErrLog.reportError("Clauses may not nest.");
    139                                 return placeholder();
     157                                if(/*child.getPlurality() == STAR ||*/ child.getPlurality() == OPTIONAL) {
     158                                        ErrLog.reportError("parse format optional clause must start with definite character.");
     159                                        return placeholder();
     160                                }
     161                                return ((SubgroupStep)child).childContentStartAST();
    140162                        }
    141163                        else if(child instanceof VariableStep) {
    142                                 if(child.getPlurality() == STAR || child.getPlurality() == OPTIONAL) {
    143                                         ErrLog.reportError("Optional clause must start with definite character.");
     164                                if(/*child.getPlurality() == STAR || */child.getPlurality() == OPTIONAL) {
     165                                        ErrLog.reportError("parse format optional clause must start with definite character.");
    144166                                        return placeholder();
    145167                                }
     
    150172                        }
    151173                }
    152                 ErrLog.reportError("Optional clause must start with definite character.");
     174                ErrLog.reportError("parse format optional clause must start with definite character.");
    153175                return placeholder();
    154176        }
     
    157179                return VariableASTB.make("error placeholder");
    158180        }
     181        @Override
     182        public FirstChar firstChar() {
     183                FirstChar result;
     184                for(Step child: getChildren()) {
     185                        result = child.firstChar();
     186                        if(result.isValid) {
     187                                return modifyDefiniteness(result);
     188                        }
     189                }
     190                ErrLog.reportError("unable to find first char for parse format optional clause.");
     191                result = new FirstChar();
     192                result.isValid = false;
     193                return result;
     194        }
     195       
     196        private FirstChar modifyDefiniteness(FirstChar result) {
     197                if(isPlurality(Plurality.STAR, Plurality.OPTIONAL)) {
     198                        result.isDefinite = false;
     199                }
     200                return result;
     201        }
    159202}
  • proto/pebble/trunk/src/parseStatement/steps/VariableStep.java

    r1304 r1305  
    77import ast.exprNodes.ShiftASTB;
    88import ast.exprNodes.VariableASTB;
     9import parseStatement.FirstChar;
    910import parseStatement.Plurality;
    1011import parseStatement.SingleExpander;
     
    1617
    1718public class VariableStep extends Step {
    18         public static VariableStep make(boolean isComplemented, String variable) {
    19                 VariableStep result = new VariableStep(variable);
    20                 result.setComplemented(isComplemented);
    21                 return result;
     19        public static VariableStep make(boolean isComplemented, boolean isElse, String variable) {
     20                return new VariableStep(isComplemented, isElse, variable);
    2221        }
    2322       
    2423        String variable;
    2524       
    26         private VariableStep(String variable) {
    27                 super();
     25        private VariableStep(boolean isComplemented, boolean isElse, String variable) {
     26                super(isComplemented, isElse);
    2827                this.variable = variable;
    2928        }
    3029        public void validate() {
    31                 if((getPlurality() == Plurality.OPTIONAL)) {
    32                         ErrLog.reportError("malformed parse step: variable may not have optional plurality.");
    33                 }
     30                String type = "variable";
     31                cannotHaveElse(type);
     32                requiresPlurality(type, Plurality.ONE, Plurality.STAR, Plurality.PLUS);
    3433        }
     34       
    3535        /////////////////////////////////////////////////////////////
    3636        // variable
     
    8787                String vname = namer.parseClassName(getVariable());
    8888               
    89                 expander.addVariableUsage(getVariable());
    90        
     89                if(expander != null) {
     90                        expander.addVariableUsage(getVariable());
     91                }
     92               
    9193                AST result = VariableASTB.make(vname);
    9294                if(isComplemented()) {
     
    101103                singleExpander.addCodeNode(orAssignAST(singleExpander.getErrorVariable(), isError));
    102104        }
     105       
     106        @Override
     107        public FirstChar firstChar() {
     108                FirstChar result = new FirstChar();
     109                result.characterTest = makeBaseAST(null);
     110                result.isAnyChar = false;
     111                result.isDefinite = (getPlurality() == Plurality.ONE) || (getPlurality() == Plurality.PLUS);
     112                return result;
     113        }
    103114}
  • proto/pebble/trunk/src/parseStatement/steps/WildcardStep.java

    r1304 r1305  
    33import ast.AST;
    44import ast.exprNodes.ShiftASTB;
     5import ast.exprNodes.TrueLiteralASTB;
     6import parseStatement.FirstChar;
    57import parseStatement.Plurality;
    68import parseStatement.Step;
    7 import util.error.ErrLog;
    89
    910import static parseStatement.ASTCodeUtils.*;
    1011
    1112public class WildcardStep extends Step {
    12         public static WildcardStep make(boolean isComplemented) {
    13                 WildcardStep result = new WildcardStep();
    14                 result.setComplemented(isComplemented);
    15                 return result;
     13        public static WildcardStep make(boolean isComplemented, boolean isElse) {
     14                return new WildcardStep(isComplemented, isElse);
    1615        }
    1716       
    18         private WildcardStep() {
    19                 super();
     17        private WildcardStep(boolean isComplemented, boolean isElse) {
     18                super(isComplemented, isElse);
    2019        }
    2120       
    2221        public void validate() {
    23                 if(isComplemented()) {
    24                         ErrLog.reportError("malformed parse step: negation may not be applied to wildcard.");
    25                 }
    26                 if(getPlurality() != Plurality.ONE) {
    27                         ErrLog.reportError("malformed parse step: wildcard may not have plurality.");
    28                 }
    29         }
    30         /////////////////////////////////////////////////////////////
    31         // wildcard
    32         /////////////////////////////////////////////////////////////
    33         public boolean isAnyChar() {
    34                 return true;
     22                String type = "wildcard";
     23                cannotBeComplemented(type);
     24                cannotHaveElse(type);
     25                requiresPlurality(type, Plurality.ONE);
    3526        }
    3627       
     
    5748                expander.addCodeNode(assignAST(expander.getCursorVariable(), shift));
    5849        }
     50
     51        @Override
     52        public FirstChar firstChar() {
     53                FirstChar result = new FirstChar();
     54                result.characterTest = TrueLiteralASTB.make();
     55                result.isAnyChar = true;
     56                return result;
     57        }
     58       
    5959}
  • proto/pebble/trunk/src/parser/Pebble.g

    r1287 r1305  
    192192                        $asTree.addChild($c3.asTree);
    193193                }
    194         | key='markers' ':' c4=taggedCompoundVariableTuple {
     194        | key='markers' ':' c4=taggedCompoundVariableSingleOrTuple {
    195195                        $asTree = new AssignmentASTN();
    196196                        $asTree.addChild(VariableASTB.make($key.text));
    197197                        $asTree.addChild($c4.asTree);
    198198                }
     199        | key='complaints' ':' c5=stringConstantSingleOrTuple {
     200                        $asTree = new AssignmentASTN();
     201                        $asTree.addChild(VariableASTB.make($key.text));
     202                        $asTree.addChild($c5.asTree);
     203                }
    199204        ;
    200        
    201 taggedCompoundVariableTuple returns [AST asTree]
     205
     206stringConstantSingleOrTuple returns [TupleASTB asTree]
     207        :       single=StringConstant {
     208                        $asTree = TupleASTB.make();
     209                        $asTree.addChild(StringConstantASTB.make($single.text));
     210                }
     211        |       tuple=stringConstantTuple { $asTree = $tuple.asTree;}
     212        ;
     213
     214stringConstantTuple returns [TupleASTB asTree]
     215@init {
     216        $asTree = TupleASTB.make();
     217}
     218        : '(' c=StringConstant {
     219                                $asTree.addChild(StringConstantASTB.make($c.text));
     220                        }
     221            (',' c=StringConstant{
     222                                $asTree.addChild(StringConstantASTB.make($c.text));
     223                        }
     224            )*
     225          ')'
     226        ;
     227       
     228               
     229taggedCompoundVariableSingleOrTuple returns [TupleASTB asTree]
     230        :       single=taggedCompoundVariable {
     231                        $asTree = TupleASTB.make();
     232                        $asTree.addChild($single.asTree);
     233                }
     234        |       tuple=taggedCompoundVariableTuple { $asTree = $tuple.asTree;}
     235        ;
     236taggedCompoundVariableTuple returns [TupleASTB asTree]
    202237@init {
    203238        $asTree = TupleASTB.make();
     
    570605       
    571606ParseFormatString
    572         : '`' ('a'..'z'|'A'..'Z'|','|'+'|'*'|'?'|'('|')'|'~'|'>')* '`'
     607        : '`' ('a'..'z'|'A'..'Z'|','|'+'|'*'|'?'|'('|')'|'~'|'>'|'@'|':'|Whitespace)* '`'
    573608        ;
    574609Identifier
     
    576611       
    577612IntegerConstant
    578         :       Digit* | '-' Digit*;
     613//      :       Digit* | '-' Digit*;    // TS Changed
     614        :       Digit+ | '-' Digit+;
    579615
    580616SequenceLiteral
     
    690726    ;
    691727   
    692 WS : (' ' |'\t' |'\n' |'\r' )+ {skip();} ;
    693 
     728WS : Whitespace+ {skip();} ;
     729
     730fragment
     731Whitespace
     732        : ' ' |'\t' |'\n' |'\r'
     733        ;
     734
  • proto/pebble/trunk/src/util/StringUtils.java

    r1242 r1305  
    2727                case 'f'        : return '\f';
    2828                case 'r'        : return '\r';
     29                case 's'        : return ' ';
    2930                case 't'        : return '\t';
    3031                case 'x'        : return Integer.parseInt(escape.substring(2), 16);
  • proto/pebble/trunk/src/util/VariableNamer.java

    r1287 r1305  
    228228        public static VariableNamer getInstance() {
    229229                if(instance == null) {
    230                         instance = new VariableNamer("p", 14);  // 14 includes prefix
     230                        instance = new VariableNamer("_p", 15); // 15 includes prefix
    231231                }
    232232                return instance;
Note: See TracChangeset for help on using the changeset viewer.