Changeset 3072 for proto/RE


Ignore:
Timestamp:
Apr 25, 2013, 3:14:01 AM (6 years ago)
Author:
ksherdy
Message:

Updated generated code. Updated code generator to allow Java compile. RE generator code will need to be updated to work with the new grammar.

Location:
proto/RE/src
Files:
17 added
1 deleted
25 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/src/ast/ASTNode.java

    r2311 r3072  
    1212import tokens.Token;
    1313
    14 public class ASTNode {
     14
     15
     16public class ASTNode  {
    1517        public static final ASTNode NO_PARENT = null;
    1618        public static final int NO_TAG = -1;
     
    1820        List<ASTNode>   children;
    1921        ASTNode parent;
     22       
    2023        Token token;
    21         int productionTag = NO_TAG;
    22 
     24        int productionTag;
    2325        boolean simplifiable;
    24 
     26       
     27       
    2528       
    2629        public ASTNode(Token token) {
     30                initChildren();
     31                this.parent = NO_PARENT;
     32       
    2733                this.token = token;
    28                 this.parent = NO_PARENT;
     34                this.productionTag = NO_TAG;
    2935                this.simplifiable = false;
    30                 initChildren();
    3136        }
    3237        // "detached" copy constructor.  Copies all info except tree info (parent and children)
    3338        public ASTNode(ASTNode node) {
     39                initChildren();
     40                this.parent = NO_PARENT;
     41                 
    3442                this.token = node.token;
    35         }
     43                this.productionTag = node.productionTag;
     44                this.simplifiable = node.simplifiable;
     45               
     46
     47        }
     48       
     49        public ASTNode deepCopy() {
     50                ASTNode parent = new ASTNode(this);
     51               
     52                for(ASTNode child: this.getChildren()) {
     53                        ASTNode copy = child.deepCopy();
     54                        parent.appendChild(copy);
     55                }
     56               
     57            return parent;             
     58        }
     59               
    3660        public Token getToken() {
    3761                return token;
     
    4670// attributes
    4771
     72       
     73        public void setProductionTag(int tag) {
     74                productionTag = tag;
     75        }
     76        public int getProductionTag() {
     77                return productionTag;
     78        }
     79       
    4880        public void setSimplifiable(boolean value) {
    4981                simplifiable = value;
     
    5284                return simplifiable;
    5385        }
    54         public void setProductionTag(int tag) {
    55                 productionTag = tag;
    56         }
    57         public int getProductionTag() {
    58                 return productionTag;
    59         }
    60        
    61        
     86
     87
     88
     89
    6290////////////////////////////////////////////////////////////////////////////////////
    6391// dealing with children and parent
     
    78106                return children.get(i);
    79107        }
     108        public ASTNode lastChild() {
     109                return children.get(children.size()-1);
     110        }       
    80111        public ASTNode reverseChild(int i) {
    81112                int index = children.size() - 1 - i;
     
    89120                children.add(0, child);
    90121                child.setParent(this);
    91         }
     122        }       
    92123        // adds a new child to this node (as last child) and sets its parent link.
    93124        public void appendChild(ASTNode child) {
    94125                children.add(child);
    95126                child.setParent(this);
    96         }
     127        }       
    97128        public int nChildren() {
    98129                return children.size();
     
    125156        }
    126157    }
    127        
    128        
     158        public void insertAfterChild(ASTNode node, ASTNode successor) {
     159        int index = children.indexOf(node);
     160        insertAfterChild(index, successor);
     161        successor.setParent(this);
     162    }
     163    private void insertAfterChild(int index, ASTNode successor) {
     164        if(index == children.size()-1) {
     165            children.add(successor);
     166        }
     167        else {
     168            children.add(index+1, successor);
     169        }       
     170    }   
     171
    129172////////////////////////////////////////////////////////////////////////////////////
    130173// Iterable<ASTNode> pathToRoot
     
    164207         */
    165208        public String attributeString() {
    166                 return "";
     209                String result = "";
     210
     211                if(result.isEmpty()) return result;
     212                int length = result.length();
     213                return result.substring(0, length-2);   
    167214        }
    168215       
  • proto/RE/src/ast/ASTTransformer.java

    r2311 r3072  
    1414        public ASTNode visit(AlternationNode node);
    1515
     16        public ASTNode visit(AnyNode node);
     17
     18        public ASTNode visit(BoundedRepetitionIndicatorNode node);
     19
    1620        public ASTNode visit(CharNode node);
    1721
     
    2024        public ASTNode visit(ConcatenationNode node);
    2125
     26        public ASTNode visit(EosNode node);
     27
    2228        public ASTNode visit(EpsilonNode node);
    2329
    2430        public ASTNode visit(ErrorNode node);
    2531
    26         public ASTNode visit(IdentifierNode node);
     32        public ASTNode visit(LowerBoundNode node);
    2733
    2834        public ASTNode visit(RangeNode node);
     
    3238        public ASTNode visit(RepetitionNode node);
    3339
     40        public ASTNode visit(SosNode node);
     41
    3442        public ASTNode visit(StartNode node);
     43
     44        public ASTNode visit(UpperBoundNode node);
    3545
    3646
     
    4959                }
    5060
     61                public ASTNode visit(AnyNode node) {
     62                        return defaultVisit(node);
     63                }
     64
     65                public ASTNode visit(BoundedRepetitionIndicatorNode node) {
     66                        return defaultVisit(node);
     67                }
     68
    5169                public ASTNode visit(CharNode node) {
    5270                        return defaultVisit(node);
     
    6179                }
    6280
     81                public ASTNode visit(EosNode node) {
     82                        return defaultVisit(node);
     83                }
     84
    6385                public ASTNode visit(EpsilonNode node) {
    6486                        return defaultVisit(node);
     
    6991                }
    7092
    71                 public ASTNode visit(IdentifierNode node) {
     93                public ASTNode visit(LowerBoundNode node) {
    7294                        return defaultVisit(node);
    7395                }
     
    85107                }
    86108
     109                public ASTNode visit(SosNode node) {
     110                        return defaultVisit(node);
     111                }
     112
    87113                public ASTNode visit(StartNode node) {
     114                        return defaultVisit(node);
     115                }
     116
     117                public ASTNode visit(UpperBoundNode node) {
    88118                        return defaultVisit(node);
    89119                }
  • proto/RE/src/ast/ASTVisitor.java

    r2311 r3072  
    1717        public T visitLeave(AlternationNode node, List<T> childResults);
    1818
     19        public void visitEnter(AnyNode node);
     20        public T visitLeave(AnyNode node, List<T> childResults);
     21
     22        public void visitEnter(BoundedRepetitionIndicatorNode node);
     23        public T visitLeave(BoundedRepetitionIndicatorNode node, List<T> childResults);
     24
    1925        public void visitEnter(CharNode node);
    2026        public T visitLeave(CharNode node, List<T> childResults);
     
    2632        public T visitLeave(ConcatenationNode node, List<T> childResults);
    2733
     34        public void visitEnter(EosNode node);
     35        public T visitLeave(EosNode node, List<T> childResults);
     36
    2837        public void visitEnter(EpsilonNode node);
    2938        public T visitLeave(EpsilonNode node, List<T> childResults);
     
    3241        public T visitLeave(ErrorNode node, List<T> childResults);
    3342
    34         public void visitEnter(IdentifierNode node);
    35         public T visitLeave(IdentifierNode node, List<T> childResults);
     43        public void visitEnter(LowerBoundNode node);
     44        public T visitLeave(LowerBoundNode node, List<T> childResults);
    3645
    3746        public void visitEnter(RangeNode node);
     
    4453        public T visitLeave(RepetitionNode node, List<T> childResults);
    4554
     55        public void visitEnter(SosNode node);
     56        public T visitLeave(SosNode node, List<T> childResults);
     57
    4658        public void visitEnter(StartNode node);
    4759        public T visitLeave(StartNode node, List<T> childResults);
     60
     61        public void visitEnter(UpperBoundNode node);
     62        public T visitLeave(UpperBoundNode node, List<T> childResults);
    4863
    4964
     
    7893                }
    7994
     95                public void visitEnter(AnyNode node) {
     96                        defaultVisitEnter(node);
     97                }
     98                public T visitLeave(AnyNode node, List<T> childResults) {
     99                        return defaultVisitLeave(node);
     100                }
     101
     102                public void visitEnter(BoundedRepetitionIndicatorNode node) {
     103                        defaultVisitEnter(node);
     104                }
     105                public T visitLeave(BoundedRepetitionIndicatorNode node, List<T> childResults) {
     106                        return defaultVisitLeave(node);
     107                }
     108
    80109                public void visitEnter(CharNode node) {
    81110                        defaultVisitEnter(node);
     
    99128                }
    100129
     130                public void visitEnter(EosNode node) {
     131                        defaultVisitEnter(node);
     132                }
     133                public T visitLeave(EosNode node, List<T> childResults) {
     134                        return defaultVisitLeave(node);
     135                }
     136
    101137                public void visitEnter(EpsilonNode node) {
    102138                        defaultVisitEnter(node);
     
    113149                }
    114150
    115                 public void visitEnter(IdentifierNode node) {
    116                         defaultVisitEnter(node);
    117                 }
    118                 public T visitLeave(IdentifierNode node, List<T> childResults) {
     151                public void visitEnter(LowerBoundNode node) {
     152                        defaultVisitEnter(node);
     153                }
     154                public T visitLeave(LowerBoundNode node, List<T> childResults) {
    119155                        return defaultVisitLeave(node);
    120156                }
     
    141177                }
    142178
     179                public void visitEnter(SosNode node) {
     180                        defaultVisitEnter(node);
     181                }
     182                public T visitLeave(SosNode node, List<T> childResults) {
     183                        return defaultVisitLeave(node);
     184                }
     185
    143186                public void visitEnter(StartNode node) {
    144187                        defaultVisitEnter(node);
    145188                }
    146189                public T visitLeave(StartNode node, List<T> childResults) {
     190                        return defaultVisitLeave(node);
     191                }
     192
     193                public void visitEnter(UpperBoundNode node) {
     194                        defaultVisitEnter(node);
     195                }
     196                public T visitLeave(UpperBoundNode node, List<T> childResults) {
    147197                        return defaultVisitLeave(node);
    148198                }
  • proto/RE/src/ast/AlternationNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class AlternationNode extends ASTNode  {
    13        
     15
     16
    1417        public AlternationNode(Token token) {
    1518                super(token);
    1619        }
    17         public AlternationNode(ASTNode node) {
     20        public AlternationNode(AlternationNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public AlternationNode deepCopy() {
     26                AlternationNode parent = new AlternationNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/CharNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class CharNode extends ASTNode implements EscapableNodeType {
    13        
     15        private boolean isEscape = false;
     16
     17
    1418        public CharNode(Token token) {
    1519                super(token);
    1620        }
    17         public CharNode(ASTNode node) {
     21        public CharNode(CharNode node) {
    1822                super(node);
     23                this.isEscape = node.isEscape;
     24
    1925        }
    2026       
     27        public CharNode deepCopy() {
     28                CharNode parent = new CharNode(this);
     29               
     30                for(ASTNode child: this.getChildren()) {
     31                        ASTNode copy = child.deepCopy();
     32                        parent.appendChild(copy);
     33                }
     34               
     35            return parent;             
     36        }
     37       
     38       
    2139        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     40        // attribute accessors
    2341
    24         private boolean escaped = false;
    25        
    26         public boolean getEscaped() {
    27                 return escaped;
     42        public boolean getIsEscape() {
     43                return isEscape;
    2844        }
    29         public void setEscaped(boolean scatterValueX) {
    30                 escaped = scatterValueX;
     45        public void setIsEscape(boolean _value_) {
     46                isEscape = _value_;
    3147        }
    3248       
     
    3854        @Override
    3955        public String attributeString() {
    40                 String result = "";
    41                 result += "escaped = " + escaped + ", ";
     56                String result = super.attributeString();
     57                if(!result.isEmpty()) {
     58                        result += ", ";
     59                }
     60                result += "isEscape = " + isEscape + ", ";
    4261
    4362                if(result.isEmpty()) return result;
  • proto/RE/src/ast/CharacterClassNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class CharacterClassNode extends ASTNode implements ComplementableNodeType {
    13        
     15        private boolean isComplemented = false;
     16
     17
    1418        public CharacterClassNode(Token token) {
    1519                super(token);
    1620        }
    17         public CharacterClassNode(ASTNode node) {
     21        public CharacterClassNode(CharacterClassNode node) {
    1822                super(node);
     23                this.isComplemented = node.isComplemented;
     24
    1925        }
    2026       
     27        public CharacterClassNode deepCopy() {
     28                CharacterClassNode parent = new CharacterClassNode(this);
     29               
     30                for(ASTNode child: this.getChildren()) {
     31                        ASTNode copy = child.deepCopy();
     32                        parent.appendChild(copy);
     33                }
     34               
     35            return parent;             
     36        }
     37       
     38       
    2139        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     40        // attribute accessors
    2341
    24         private boolean complemented = false;
    25        
    26         public boolean getComplemented() {
    27                 return complemented;
     42        public boolean getIsComplemented() {
     43                return isComplemented;
    2844        }
    29         public void setComplemented(boolean scatterValueX) {
    30                 complemented = scatterValueX;
     45        public void setIsComplemented(boolean _value_) {
     46                isComplemented = _value_;
    3147        }
    3248       
     
    3854        @Override
    3955        public String attributeString() {
    40                 String result = "";
    41                 result += "complemented = " + complemented + ", ";
     56                String result = super.attributeString();
     57                if(!result.isEmpty()) {
     58                        result += ", ";
     59                }
     60                result += "isComplemented = " + isComplemented + ", ";
    4261
    4362                if(result.isEmpty()) return result;
  • proto/RE/src/ast/ComplementableNodeType.java

    r2311 r3072  
    77package ast;
    88
     9
     10
    911public interface ComplementableNodeType  {
    1012
    11         public boolean getComplemented();
    12         public void setComplemented(boolean scatterValueX);
     13        public boolean getIsComplemented();
     14        public void setIsComplemented(boolean _value_);
    1315       
    1416
  • proto/RE/src/ast/ConcatenationNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class ConcatenationNode extends ASTNode  {
    13        
     15
     16
    1417        public ConcatenationNode(Token token) {
    1518                super(token);
    1619        }
    17         public ConcatenationNode(ASTNode node) {
     20        public ConcatenationNode(ConcatenationNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public ConcatenationNode deepCopy() {
     26                ConcatenationNode parent = new ConcatenationNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/EpsilonNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class EpsilonNode extends ASTNode  {
    13        
     15
     16
    1417        public EpsilonNode(Token token) {
    1518                super(token);
    1619        }
    17         public EpsilonNode(ASTNode node) {
     20        public EpsilonNode(EpsilonNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public EpsilonNode deepCopy() {
     26                EpsilonNode parent = new EpsilonNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/ErrorNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class ErrorNode extends ASTNode  {
    13        
     15
     16
    1417        public ErrorNode(Token token) {
    1518                super(token);
    1619        }
    17         public ErrorNode(ASTNode node) {
     20        public ErrorNode(ErrorNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public ErrorNode deepCopy() {
     26                ErrorNode parent = new ErrorNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/EscapableNodeType.java

    r2311 r3072  
    77package ast;
    88
     9
     10
    911public interface EscapableNodeType  {
    1012
    11         public boolean getEscaped();
    12         public void setEscaped(boolean scatterValueX);
     13        public boolean getIsEscape();
     14        public void setIsEscape(boolean _value_);
    1315       
    1416
  • proto/RE/src/ast/RangeNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class RangeNode extends ASTNode  {
    13        
     15
     16
    1417        public RangeNode(Token token) {
    1518                super(token);
    1619        }
    17         public RangeNode(ASTNode node) {
     20        public RangeNode(RangeNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public RangeNode deepCopy() {
     26                RangeNode parent = new RangeNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/RepetitionIndicatorNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class RepetitionIndicatorNode extends ASTNode  {
    13        
     15
     16
    1417        public RepetitionIndicatorNode(Token token) {
    1518                super(token);
    1619        }
    17         public RepetitionIndicatorNode(ASTNode node) {
     20        public RepetitionIndicatorNode(RepetitionIndicatorNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public RepetitionIndicatorNode deepCopy() {
     26                RepetitionIndicatorNode parent = new RepetitionIndicatorNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/RepetitionNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class RepetitionNode extends ASTNode  {
    13        
     15
     16
    1417        public RepetitionNode(Token token) {
    1518                super(token);
    1619        }
    17         public RepetitionNode(ASTNode node) {
     20        public RepetitionNode(RepetitionNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public RepetitionNode deepCopy() {
     26                RepetitionNode parent = new RepetitionNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/SimpleVisitor.java

    r2311 r3072  
    1515        public void visit(AlternationNode node);
    1616
     17        public void visit(AnyNode node);
     18
     19        public void visit(BoundedRepetitionIndicatorNode node);
     20
    1721        public void visit(CharNode node);
    1822
     
    2125        public void visit(ConcatenationNode node);
    2226
     27        public void visit(EosNode node);
     28
    2329        public void visit(EpsilonNode node);
    2430
    2531        public void visit(ErrorNode node);
    2632
    27         public void visit(IdentifierNode node);
     33        public void visit(LowerBoundNode node);
    2834
    2935        public void visit(RangeNode node);
     
    3339        public void visit(RepetitionNode node);
    3440
     41        public void visit(SosNode node);
     42
    3543        public void visit(StartNode node);
     44
     45        public void visit(UpperBoundNode node);
    3646
    3747
     
    5060                }
    5161
     62                public void visit(AnyNode node) {
     63                        defaultVisit(node);
     64                }
     65
     66                public void visit(BoundedRepetitionIndicatorNode node) {
     67                        defaultVisit(node);
     68                }
     69
    5270                public void visit(CharNode node) {
    5371                        defaultVisit(node);
     
    6280                }
    6381
     82                public void visit(EosNode node) {
     83                        defaultVisit(node);
     84                }
     85
    6486                public void visit(EpsilonNode node) {
    6587                        defaultVisit(node);
     
    7092                }
    7193
    72                 public void visit(IdentifierNode node) {
     94                public void visit(LowerBoundNode node) {
    7395                        defaultVisit(node);
    7496                }
     
    86108                }
    87109
     110                public void visit(SosNode node) {
     111                        defaultVisit(node);
     112                }
     113
    88114                public void visit(StartNode node) {
     115                        defaultVisit(node);
     116                }
     117
     118                public void visit(UpperBoundNode node) {
    89119                        defaultVisit(node);
    90120                }
  • proto/RE/src/ast/StartNode.java

    r2311 r3072  
    1010import java.util.List;
    1111
     12
     13
    1214public class StartNode extends ASTNode  {
    13        
     15
     16
    1417        public StartNode(Token token) {
    1518                super(token);
    1619        }
    17         public StartNode(ASTNode node) {
     20        public StartNode(StartNode node) {
    1821                super(node);
     22
    1923        }
    2024       
     25        public StartNode deepCopy() {
     26                StartNode parent = new StartNode(this);
     27               
     28                for(ASTNode child: this.getChildren()) {
     29                        ASTNode copy = child.deepCopy();
     30                        parent.appendChild(copy);
     31                }
     32               
     33            return parent;             
     34        }
     35       
     36       
    2137        ////////////////////////////////////////////////////////////
    22         // attributes and their accessors
     38        // attribute accessors
    2339
    24        
    2540
    2641       
     
    3045        @Override
    3146        public String attributeString() {
    32                 String result = "";
     47                String result = super.attributeString();
     48                if(!result.isEmpty()) {
     49                        result += ", ";
     50                }
    3351
    3452                if(result.isEmpty()) return result;
  • proto/RE/src/ast/VoidVisitor.java

    r2311 r3072  
    1515        public void visitLeave(AlternationNode node);
    1616
     17        public void visitEnter(AnyNode node);
     18        public void visitLeave(AnyNode node);
     19
     20        public void visitEnter(BoundedRepetitionIndicatorNode node);
     21        public void visitLeave(BoundedRepetitionIndicatorNode node);
     22
    1723        public void visitEnter(CharNode node);
    1824        public void visitLeave(CharNode node);
     
    2430        public void visitLeave(ConcatenationNode node);
    2531
     32        public void visitEnter(EosNode node);
     33        public void visitLeave(EosNode node);
     34
    2635        public void visitEnter(EpsilonNode node);
    2736        public void visitLeave(EpsilonNode node);
     
    3039        public void visitLeave(ErrorNode node);
    3140
    32         public void visitEnter(IdentifierNode node);
    33         public void visitLeave(IdentifierNode node);
     41        public void visitEnter(LowerBoundNode node);
     42        public void visitLeave(LowerBoundNode node);
    3443
    3544        public void visitEnter(RangeNode node);
     
    4251        public void visitLeave(RepetitionNode node);
    4352
     53        public void visitEnter(SosNode node);
     54        public void visitLeave(SosNode node);
     55
    4456        public void visitEnter(StartNode node);
    4557        public void visitLeave(StartNode node);
     58
     59        public void visitEnter(UpperBoundNode node);
     60        public void visitLeave(UpperBoundNode node);
    4661
    4762
     
    7590                }
    7691
     92                public void visitEnter(AnyNode node) {
     93                        defaultVisitEnter(node);
     94                }
     95                public void visitLeave(AnyNode node) {
     96                        defaultVisitLeave(node);
     97                }
     98
     99                public void visitEnter(BoundedRepetitionIndicatorNode node) {
     100                        defaultVisitEnter(node);
     101                }
     102                public void visitLeave(BoundedRepetitionIndicatorNode node) {
     103                        defaultVisitLeave(node);
     104                }
     105
    77106                public void visitEnter(CharNode node) {
    78107                        defaultVisitEnter(node);
     
    96125                }
    97126
     127                public void visitEnter(EosNode node) {
     128                        defaultVisitEnter(node);
     129                }
     130                public void visitLeave(EosNode node) {
     131                        defaultVisitLeave(node);
     132                }
     133
    98134                public void visitEnter(EpsilonNode node) {
    99135                        defaultVisitEnter(node);
     
    110146                }
    111147
    112                 public void visitEnter(IdentifierNode node) {
    113                         defaultVisitEnter(node);
    114                 }
    115                 public void visitLeave(IdentifierNode node) {
     148                public void visitEnter(LowerBoundNode node) {
     149                        defaultVisitEnter(node);
     150                }
     151                public void visitLeave(LowerBoundNode node) {
    116152                        defaultVisitLeave(node);
    117153                }
     
    138174                }
    139175
     176                public void visitEnter(SosNode node) {
     177                        defaultVisitEnter(node);
     178                }
     179                public void visitLeave(SosNode node) {
     180                        defaultVisitLeave(node);
     181                }
     182
    140183                public void visitEnter(StartNode node) {
    141184                        defaultVisitEnter(node);
    142185                }
    143186                public void visitLeave(StartNode node) {
     187                        defaultVisitLeave(node);
     188                }
     189
     190                public void visitEnter(UpperBoundNode node) {
     191                        defaultVisitEnter(node);
     192                }
     193                public void visitLeave(UpperBoundNode node) {
    144194                        defaultVisitLeave(node);
    145195                }
  • proto/RE/src/codeGenerator/Visitor.java

    r2360 r3072  
    1010import ast.CharNode;
    1111import ast.CharacterClassNode;
    12 import ast.IdentifierNode;
     12
     13// DNE
     14//import ast.IdentifierNode;
    1315import ast.RangeNode;
    1416import ast.RepetitionNode;
     
    112114
    113115        //Use this for character classes
     116    /* DNE
     117   
    114118    public ASTNode visitLeave(IdentifierNode node, List<ASTNode> childresults) {
    115119        NodeState currState = nodeStates.get(node);
     
    118122        return defaultVisitLeave(node);
    119123    }
     124    */
     125   
    120126    public ASTNode visitLeave(CharacterClassNode node, List<ASTNode> childresults) {
    121127        NodeState currState = nodeStates.get(node);
     
    137143    }
    138144   
     145    /* DNE
    139146    private Boolean[] generateCharacterClassRepresentation(IdentifierNode node) {
    140147        Boolean[] result = new Boolean[256];
     
    143150        return result;
    144151    }
     152    */
     153   
    145154    private Boolean[] generateCharacterClassRepresentation(CharNode node) {
    146155        Boolean[] result = new Boolean[256];
  • proto/RE/src/lexicalAnalyzer/LexicalController.java

    r2311 r3072  
    3232                scanners.put("main", Scanner.makeMainContext(bookmarkStream));
    3333                scanners.put("charClass", Scanner.makeCharClassContext(bookmarkStream));
     34                scanners.put("boundedRepetition", Scanner.makeBoundedRepetitionContext(bookmarkStream));
    3435               
    3536                currentScanner = scanners.get("main");
  • proto/RE/src/lexicalAnalyzer/LexicalType.java

    r2311 r3072  
    99
    1010public enum LexicalType {
    11         IDENTIFIER,
     11        INTEGER_CONST,
    1212        CHARACTER,
    1313        IGNORE,
  • proto/RE/src/lexicalAnalyzer/Lextant.java

    r2311 r3072  
    1818
    1919public enum Lextant {
     20        ANY(".", "main"),
    2021        RIGHTSQUARE("]", "charClass", "]", "main"),
    21         BACKSLASH("\\", "charClass"),
     22        BACKSLASH("\\", "charClass", "\\", "main"),
    2223        OR("|", "main"),
    23         NOT("~", "charClass"),
     24        NOT("^", "charClass"),
    2425        OPTIONAL("?", "main"),
    2526        STAR("*", "main"),
    2627        PLUS("+", "main"),
     28        RIGHTCURLY("}", "boundedRepetition", "}", "main"),
    2729        LEFTROUND("(", "main"),
    2830        RIGHTROUND(")", "main"),
    29         THROUGH("..", "charClass", "-", "charClass"),
     31        THROUGH("-", "charClass"),
     32        SOS("^", "main"),
    3033        LEFTSQUARE("[", "main"),
     34        EOS("!", "main"),
     35        LEFTCURLY("{", "main"),
     36        COMMA(",", "boundedRepetition", ",", "main"),
    3137
    3238       
  • proto/RE/src/lexicalAnalyzer/Scanner.java

    r2311 r3072  
    7272                return new Scanner(charStream,
    7373                        new WhitespaceTokenRecognizer(charStream, IGNORE),
    74                         new IdentifierTokenRecognizer(charStream, IDENTIFIER, context),
    75                         new CommentTokenRecognizer(charStream, IGNORE, "//", "\n"),
     74                        new CommentTokenRecognizer(charStream, IGNORE, "(?#", ")"),
     75                        new CharacterTokenRecognizer(charStream, CHARACTER, "(", ")", "[", "|", "?", "*", "+", ".", "^", "!", "\\", "{"),
    7676                        new PunctuatorTokenRecognizer(charStream, LEXTANT, context),
    7777                        new EndOfInputTokenRecognizer(charStream, NONE)
     
    8484                return new Scanner(charStream,
    8585                        new WhitespaceTokenRecognizer(charStream, IGNORE),
     86                        new CharacterTokenRecognizer(charStream, CHARACTER, "]", "^", "-", "\\"),
    8687                        new PunctuatorTokenRecognizer(charStream, LEXTANT, context),
    87                         new CharacterTokenRecognizer(charStream, CHARACTER),
     88                        new EndOfInputTokenRecognizer(charStream, NONE)
     89                );
     90        }
     91       
     92        public static Scanner makeBoundedRepetitionContext(BookmarkCharStream charStream) {
     93                String context = "boundedRepetition";
     94               
     95                return new Scanner(charStream,
     96                        new WhitespaceTokenRecognizer(charStream, IGNORE),
     97                        new IntegerTokenRecognizer(charStream, INTEGER_CONST),
     98                        new PunctuatorTokenRecognizer(charStream, LEXTANT, context),
    8899                        new EndOfInputTokenRecognizer(charStream, NONE)
    89100                );
  • proto/RE/src/lexicalAnalyzer/tokenRecognizers/CharacterTokenRecognizer.java

    r2311 r3072  
    1010import tokens.CharacterToken;
    1111import tokens.Token;
     12import tokens.NullToken;
    1213import inputHandler.BookmarkCharStream;
    1314import inputHandler.LocatedChar;
    1415import inputHandler.TextLocation;
     16import inputHandler.LocatedCharStream;
    1517
    1618public class CharacterTokenRecognizer extends TokenRecognizerImp {
    17         public CharacterTokenRecognizer(BookmarkCharStream input, LexicalType lexicalType) {
     19
     20        private String [] excludedCharacters = null;
     21
     22        public CharacterTokenRecognizer(BookmarkCharStream input, LexicalType lexicalType, String ... excludedCharacters) {
    1823                super(input, lexicalType);
     24               
     25                this.excludedCharacters = new String [excludedCharacters.length];
     26                for(int i=0;i<excludedCharacters.length;i++) {
     27                        this.excludedCharacters[i] = excludedCharacters[i];
     28                }
    1929        }
    2030
    2131        protected Result tryToReadToken() {
     32               
     33                if(isEndOfInput(input.peek())) {
     34                        setToken(NullToken.make(lexicalType));
     35                        return Result.NOT_FOUND;
     36                }
     37               
     38                // ?
     39                if(inputStartsWithAny(excludedCharacters)) {
     40                        return Result.NOT_FOUND;
     41                }       
     42
    2243                LocatedChar firstChar = input.next();
    2344                TextLocation location = firstChar.getLocation();
     
    2950                return Result.FOUND;
    3051        }
     52       
     53        private boolean isEndOfInput(LocatedChar c) {
     54                return c == LocatedCharStream.FLAG_END_OF_INPUT;
     55        }
    3156}
    3257
  • proto/RE/src/lexicalAnalyzer/tokenRecognizers/TokenRecognizerImp.java

    r2311 r3072  
    115115                return result;
    116116        }
     117       
     118        // ?
     119        protected boolean inputStartsWithAny(String ... lexemes) {
     120                Bookmark bookmark = input.bookmark();
     121                boolean result = false;
     122               
     123                for(int i=0; i<lexemes.length; i++) {
     124                        result = sloppyInputStartsWith(lexemes[i], input.peek().getCharacter());
     125                       
     126                        if(result) {
     127                                break;
     128                        }
     129                }       
     130               
     131                input.moveback(bookmark);
     132                return result;
     133        }
     134
     135        // ? single character prefix without progressing the input stream
     136        private boolean sloppyInputStartsWith(String lexeme, char c) {
     137                for(int i=0; i<lexeme.length(); i++) {
     138                        if(c != lexeme.charAt(i)) {
     139                                return false;
     140                        }
     141                }
     142                return true;
     143        }
     144       
    117145        private boolean sloppyInputStartsWith(String lexeme) {
    118146                for(int i=0; i<lexeme.length(); i++) {
  • proto/RE/src/parser/Parser.java

    r2311 r3072  
    4444        }
    4545        public ASTNode parseStart() {
    46                 if( !(nowReading.isLextant(Lextant.LEFTROUND, Lextant.LEFTSQUARE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    47                         return syntaxErrorNode("start² [IDENTIFIER¹, LEFTROUND¹, LEFTSQUARE¹]");
     46                if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     47                        return syntaxErrorNode("start² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
    4848                }
    4949       
     
    6464         
    6565        public ASTNode parseRe() {
    66                 if( !(nowReading.isLextant(Lextant.LEFTROUND, Lextant.LEFTSQUARE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    67                         return syntaxErrorNode("re² [IDENTIFIER¹, LEFTROUND¹, LEFTSQUARE¹]");
     66                if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     67                        return syntaxErrorNode("re² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
    6868                }
    6969       
     
    8484         
    8585        public ASTNode parseAlternation() {
    86                 if( !(nowReading.isLextant(Lextant.LEFTROUND, Lextant.LEFTSQUARE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    87                         return syntaxErrorNode("alternation² [IDENTIFIER¹, LEFTROUND¹, LEFTSQUARE¹]");
     86                if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     87                        return syntaxErrorNode("alternation² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
    8888                }
    8989       
     
    113113         
    114114        public ASTNode parseConcatenation() {
    115                 if( !(nowReading.isLextant(Lextant.LEFTROUND, Lextant.LEFTSQUARE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    116                         return syntaxErrorNode("concatenation² [IDENTIFIER¹, LEFTROUND¹, LEFTSQUARE¹]");
     115                if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     116                        return syntaxErrorNode("concatenation² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
    117117                }
    118118       
     
    127127                                allChildren.add(child);
    128128                        }
    129                 } while( nowReading.isLextant(Lextant.LEFTROUND, Lextant.LEFTSQUARE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) );
     129                } while( nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER)) );
    130130                if(allowCompression) {
    131131                        return compressIfPossible(result);
     
    135135         
    136136        public ASTNode parseRepetition() {
    137                 if( !(nowReading.isLextant(Lextant.LEFTROUND, Lextant.LEFTSQUARE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    138                         return syntaxErrorNode("repetition² [IDENTIFIER¹, LEFTROUND¹, LEFTSQUARE¹]");
     137                if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     138                        return syntaxErrorNode("repetition² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
    139139                }
    140140       
     
    148148                        allChildren.add(child);
    149149                }
    150                 if( nowReading.isLextant(Lextant.OPTIONAL, Lextant.PLUS, Lextant.STAR) ) {
    151                         {
    152                                 ASTNode child = parseRepetitionIndicator();
    153                                 // node omitted - no result.appendChild(child);
    154                                 allChildren.add(child);
    155                                 result.setToken( child.getToken() );
    156                                 allowCompression = false;
     150                if( nowReading.isLextant(Lextant.LEFTCURLY, Lextant.OPTIONAL, Lextant.PLUS, Lextant.STAR) ) {
     151                        if( nowReading.isLextant(Lextant.OPTIONAL, Lextant.PLUS, Lextant.STAR) ) {
     152                                {
     153                                        ASTNode child = parseRepetitionIndicator();
     154                                        result.appendChild(child);
     155                                        allChildren.add(child);
     156                                }
     157                        }
     158                        else if( nowReading.isLextant(Lextant.LEFTCURLY) ) {
     159                                {
     160                                        ASTNode child = parseBoundedRepetitionIndicator();
     161                                        result.appendChild(child);
     162                                        allChildren.add(child);
     163                                }
    157164                        }
    158165                }
     
    163170        }
    164171         
     172        public ASTNode parseRepetitionIndicator() {
     173                if( !(nowReading.isLextant(Lextant.OPTIONAL, Lextant.PLUS, Lextant.STAR)) ) {
     174                        return syntaxErrorNode("repetitionIndicator² [OPTIONAL¹, PLUS¹, STAR¹]");
     175                }
     176       
     177                boolean allowCompression = true;
     178                ASTNode result = new RepetitionIndicatorNode(nowReading);
     179                result.setProductionTag(6);
     180                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     181                if( nowReading.isLextant(Lextant.OPTIONAL) ) {
     182                        expect(Lextant.OPTIONAL);
     183                }
     184                else if( nowReading.isLextant(Lextant.STAR) ) {
     185                        expect(Lextant.STAR);
     186                }
     187                else if( nowReading.isLextant(Lextant.PLUS) ) {
     188                        expect(Lextant.PLUS);
     189                }
     190                if(allowCompression) {
     191                        return result;
     192                }
     193                return result;
     194        }
     195         
     196        public ASTNode parseBoundedRepetitionIndicator() {
     197                if( !(nowReading.isLextant(Lextant.LEFTCURLY)) ) {
     198                        return syntaxErrorNode("boundedRepetitionIndicator² [LEFTCURLY¹]");
     199                }
     200       
     201                boolean allowCompression = true;
     202                ASTNode result = new BoundedRepetitionIndicatorNode(nowReading);
     203                result.setProductionTag(7);
     204                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     205                lexController.pushTo("boundedRepetition");
     206                expect(Lextant.LEFTCURLY);
     207                if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     208                        {
     209                                ASTNode child = parseLowerBound();
     210                                result.appendChild(child);
     211                                allChildren.add(child);
     212                        }
     213                }
     214                if( nowReading.isLextant(Lextant.COMMA) ) {
     215                        expect(Lextant.COMMA);
     216                        {
     217                                ASTNode temp_1 = result;
     218                                RepeatableNodeType temp_3 = (RepeatableNodeType)temp_1;
     219                                boolean temp_4 = true;
     220                                temp_3.setIsRange( temp_4 );
     221                        }
     222                        if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     223                                {
     224                                        ASTNode child = parseUpperBound();
     225                                        result.appendChild(child);
     226                                        allChildren.add(child);
     227                                }
     228                        }
     229                }
     230                lexController.pop();
     231                expect(Lextant.RIGHTCURLY);
     232                if(allowCompression) {
     233                        return result;
     234                }
     235                return result;
     236        }
     237         
     238        public ASTNode parseLowerBound() {
     239                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     240                        return syntaxErrorNode("lowerBound² [INTEGER_CONST¹]");
     241                }
     242       
     243                boolean allowCompression = true;
     244                ASTNode result = new LowerBoundNode(nowReading);
     245                result.setProductionTag(8);
     246                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     247                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     248                        return syntaxErrorNode("INTEGER_CONST");
     249                }
     250                readToken();
     251                {
     252                        ASTNode temp_5 = result;
     253                        IntValuedNodeType temp_7 = (IntValuedNodeType)temp_5;
     254                        IntConstantToken temp_10 = (IntConstantToken)previouslyRead;
     255                        int temp_9 = temp_10.getValue();
     256                        temp_7.setValue( temp_9 );
     257                }
     258                if(allowCompression) {
     259                        return result;
     260                }
     261                return result;
     262        }
     263         
     264        public ASTNode parseUpperBound() {
     265                if( !((nowReading.isLexicalType(LexicalType.INTEGER_CONST))) ) {
     266                        return syntaxErrorNode("upperBound² [INTEGER_CONST¹]");
     267                }
     268       
     269                boolean allowCompression = true;
     270                ASTNode result = new UpperBoundNode(nowReading);
     271                result.setProductionTag(9);
     272                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     273                if( !(nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
     274                        return syntaxErrorNode("INTEGER_CONST");
     275                }
     276                readToken();
     277                {
     278                        ASTNode temp_11 = result;
     279                        IntValuedNodeType temp_13 = (IntValuedNodeType)temp_11;
     280                        IntConstantToken temp_16 = (IntConstantToken)previouslyRead;
     281                        int temp_15 = temp_16.getValue();
     282                        temp_13.setValue( temp_15 );
     283                }
     284                if(allowCompression) {
     285                        return result;
     286                }
     287                return result;
     288        }
     289         
    165290        public ASTNode parseAtom() {
    166                 if( !(nowReading.isLextant(Lextant.LEFTROUND, Lextant.LEFTSQUARE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    167                         return syntaxErrorNode("atom² [IDENTIFIER¹, LEFTROUND¹, LEFTSQUARE¹]");
     291                if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.EOS, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.SOS) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     292                        return syntaxErrorNode("atom² [ANY¹, BACKSLASH¹, CHARACTER¹, EOS¹, LEFTROUND¹, LEFTSQUARE¹, SOS¹]");
    168293                }
    169294       
    170295                boolean allowCompression = true;
    171296                ASTNode result = new ASTNode(nowReading);
    172                 result.setProductionTag(6);
     297                result.setProductionTag(10);
    173298                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    174299                if( nowReading.isLextant(Lextant.LEFTROUND) ) {
     
    181306                        expect(Lextant.RIGHTROUND);
    182307                }
    183                 else if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    184                         {
    185                                 ASTNode child = parseIdentifier();
     308                else if( nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     309                        {
     310                                ASTNode child = parseChar();
    186311                                result.appendChild(child);
    187312                                allChildren.add(child);
     
    195320                        }
    196321                }
     322                else if( nowReading.isLextant(Lextant.ANY) ) {
     323                        {
     324                                ASTNode child = parseAny();
     325                                result.appendChild(child);
     326                                allChildren.add(child);
     327                        }
     328                }
     329                else if( nowReading.isLextant(Lextant.SOS) ) {
     330                        {
     331                                ASTNode child = parseSos();
     332                                result.appendChild(child);
     333                                allChildren.add(child);
     334                        }
     335                }
     336                else if( nowReading.isLextant(Lextant.EOS) ) {
     337                        {
     338                                ASTNode child = parseEos();
     339                                result.appendChild(child);
     340                                allChildren.add(child);
     341                        }
     342                }
    197343                if(allowCompression) {
    198344                        return compressIfPossible(result);
     
    201347        }
    202348         
    203         public ASTNode parseIdentifier() {
    204                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    205                         return syntaxErrorNode("identifier² [IDENTIFIER¹]");
    206                 }
    207        
    208                 boolean allowCompression = true;
    209                 ASTNode result = new IdentifierNode(nowReading);
    210                 result.setProductionTag(7);
    211                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    212                 if( !(nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    213                         return syntaxErrorNode("IDENTIFIER");
    214                 }
    215                 readToken();
     349        public ASTNode parseChar() {
     350                if( !(nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     351                        return syntaxErrorNode("char² [BACKSLASH¹, CHARACTER¹]");
     352                }
     353       
     354                boolean allowCompression = true;
     355                ASTNode result = new CharNode(nowReading);
     356                result.setProductionTag(11);
     357                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     358                if( (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     359                        if( !(nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     360                                return syntaxErrorNode("CHARACTER");
     361                        }
     362                        readToken();
     363                }
     364                else if( nowReading.isLextant(Lextant.BACKSLASH) ) {
     365                        expect(Lextant.BACKSLASH);
     366                        {
     367                                ASTNode child = parseEscapedChar();
     368                                result.appendChild(child);
     369                                allChildren.add(child);
     370                        }
     371                        {
     372                                ASTNode temp_17 = allChildren.revGet(0);
     373                                EscapableNodeType temp_19 = (EscapableNodeType)temp_17;
     374                                boolean temp_20 = true;
     375                                temp_19.setIsEscape( temp_20 );
     376                        }
     377                }
     378                if(allowCompression) {
     379                        return compressIfPossible(result);
     380                }
     381                return result;
     382        }
     383         
     384        public ASTNode parseEscapedChar() {
     385                if( !(nowReading.isLextant(Lextant.ANY, Lextant.BACKSLASH, Lextant.COMMA, Lextant.EOS, Lextant.LEFTCURLY, Lextant.LEFTROUND, Lextant.LEFTSQUARE, Lextant.OPTIONAL, Lextant.OR, Lextant.PLUS, Lextant.RIGHTROUND, Lextant.SOS, Lextant.STAR) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     386                        return syntaxErrorNode("escapedChar² [ANY¹, BACKSLASH¹, CHARACTER¹, COMMA¹, EOS¹, LEFTCURLY¹, LEFTROUND¹, LEFTSQUARE¹, OPTIONAL¹, OR¹, PLUS¹, RIGHTROUND¹, SOS¹, STAR¹]");
     387                }
     388       
     389                boolean allowCompression = true;
     390                ASTNode result = new CharNode(nowReading);
     391                result.setProductionTag(12);
     392                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     393                if( (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     394                        if( !(nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     395                                return syntaxErrorNode("CHARACTER");
     396                        }
     397                        readToken();
     398                }
     399                else if( nowReading.isLextant(Lextant.LEFTROUND) ) {
     400                        expect(Lextant.LEFTROUND);
     401                }
     402                else if( nowReading.isLextant(Lextant.RIGHTROUND) ) {
     403                        expect(Lextant.RIGHTROUND);
     404                }
     405                else if( nowReading.isLextant(Lextant.LEFTSQUARE) ) {
     406                        expect(Lextant.LEFTSQUARE);
     407                }
     408                else if( nowReading.isLextant(Lextant.LEFTCURLY) ) {
     409                        expect(Lextant.LEFTCURLY);
     410                }
     411                else if( nowReading.isLextant(Lextant.COMMA) ) {
     412                        expect(Lextant.COMMA);
     413                }
     414                else if( nowReading.isLextant(Lextant.OR) ) {
     415                        expect(Lextant.OR);
     416                }
     417                else if( nowReading.isLextant(Lextant.OPTIONAL) ) {
     418                        expect(Lextant.OPTIONAL);
     419                }
     420                else if( nowReading.isLextant(Lextant.STAR) ) {
     421                        expect(Lextant.STAR);
     422                }
     423                else if( nowReading.isLextant(Lextant.PLUS) ) {
     424                        expect(Lextant.PLUS);
     425                }
     426                else if( nowReading.isLextant(Lextant.ANY) ) {
     427                        expect(Lextant.ANY);
     428                }
     429                else if( nowReading.isLextant(Lextant.SOS) ) {
     430                        expect(Lextant.SOS);
     431                }
     432                else if( nowReading.isLextant(Lextant.EOS) ) {
     433                        expect(Lextant.EOS);
     434                }
     435                else if( nowReading.isLextant(Lextant.BACKSLASH) ) {
     436                        expect(Lextant.BACKSLASH);
     437                }
    216438                if(allowCompression) {
    217439                        return result;
     
    227449                boolean allowCompression = true;
    228450                ASTNode result = new CharacterClassNode(nowReading);
    229                 result.setProductionTag(8);
     451                result.setProductionTag(13);
    230452                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    231453                lexController.pushTo("charClass");
     
    234456                        expect(Lextant.NOT);
    235457                        {
    236                                 ASTNode temp_1 = result;
    237                                 ComplementableNodeType temp_3 = (ComplementableNodeType)temp_1;
    238                                 boolean temp_4 = true;
    239                                 temp_3.setComplemented( temp_4 );
     458                                ASTNode temp_21 = result;
     459                                ComplementableNodeType temp_23 = (ComplementableNodeType)temp_21;
     460                                boolean temp_24 = true;
     461                                temp_23.setIsComplemented( temp_24 );
    240462                        }
    241463                }
     
    262484                boolean allowCompression = true;
    263485                ASTNode result = new RangeNode(nowReading);
    264                 result.setProductionTag(9);
     486                result.setProductionTag(14);
    265487                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    266488                {
    267                         ASTNode child = parseChar();
     489                        ASTNode child = parseCharacterClassChar();
    268490                        result.appendChild(child);
    269491                        allChildren.add(child);
     
    273495                        expect(Lextant.THROUGH);
    274496                        {
    275                                 ASTNode child = parseChar();
     497                                ASTNode child = parseCharacterClassChar();
    276498                                result.appendChild(child);
    277499                                allChildren.add(child);
     
    284506        }
    285507         
    286         public ASTNode parseChar() {
     508        public ASTNode parseCharacterClassChar() {
    287509                if( !(nowReading.isLextant(Lextant.BACKSLASH) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    288                         return syntaxErrorNode("char² [BACKSLASH¹, CHARACTER¹]");
     510                        return syntaxErrorNode("characterClassChar² [BACKSLASH¹, CHARACTER¹]");
    289511                }
    290512       
    291513                boolean allowCompression = true;
    292514                ASTNode result = new CharNode(nowReading);
    293                 result.setProductionTag(10);
     515                result.setProductionTag(15);
    294516                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    295517                if( (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     
    302524                        expect(Lextant.BACKSLASH);
    303525                        {
    304                                 ASTNode child = parseEscapedChar();
    305                                 result.appendChild(child);
    306                                 allChildren.add(child);
    307                         }
    308                         {
    309                                 ASTNode temp_5 = allChildren.revGet(0);
    310                                 EscapableNodeType temp_7 = (EscapableNodeType)temp_5;
    311                                 boolean temp_8 = true;
    312                                 temp_7.setEscaped( temp_8 );
     526                                ASTNode child = parseCharacterClassEscapedChar();
     527                                result.appendChild(child);
     528                                allChildren.add(child);
     529                        }
     530                        {
     531                                ASTNode temp_25 = allChildren.revGet(0);
     532                                EscapableNodeType temp_27 = (EscapableNodeType)temp_25;
     533                                boolean temp_28 = true;
     534                                temp_27.setIsEscape( temp_28 );
    313535                        }
    314536                }
     
    319541        }
    320542         
    321         public ASTNode parseEscapedChar() {
    322                 if( !(nowReading.isLextant(Lextant.BACKSLASH, Lextant.RIGHTSQUARE) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
    323                         return syntaxErrorNode("escapedChar² [BACKSLASH¹, CHARACTER¹, RIGHTSQUARE¹]");
     543        public ASTNode parseCharacterClassEscapedChar() {
     544                if( !(nowReading.isLextant(Lextant.BACKSLASH, Lextant.NOT, Lextant.RIGHTSQUARE, Lextant.THROUGH) || (nowReading.isLexicalType(LexicalType.CHARACTER))) ) {
     545                        return syntaxErrorNode("characterClassEscapedChar² [BACKSLASH¹, CHARACTER¹, NOT¹, RIGHTSQUARE¹, THROUGH¹]");
    324546                }
    325547       
    326548                boolean allowCompression = true;
    327549                ASTNode result = new CharNode(nowReading);
    328                 result.setProductionTag(11);
     550                result.setProductionTag(16);
    329551                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    330552                if( (nowReading.isLexicalType(LexicalType.CHARACTER)) ) {
     
    334556                        readToken();
    335557                }
     558                else if( nowReading.isLextant(Lextant.NOT) ) {
     559                        expect(Lextant.NOT);
     560                }
     561                else if( nowReading.isLextant(Lextant.THROUGH) ) {
     562                        expect(Lextant.THROUGH);
     563                }
    336564                else if( nowReading.isLextant(Lextant.BACKSLASH) ) {
    337565                        expect(Lextant.BACKSLASH);
     
    346574        }
    347575         
    348         public ASTNode parseRepetitionIndicator() {
    349                 if( !(nowReading.isLextant(Lextant.OPTIONAL, Lextant.PLUS, Lextant.STAR)) ) {
    350                         return syntaxErrorNode("repetitionIndicator² [OPTIONAL¹, PLUS¹, STAR¹]");
    351                 }
    352        
    353                 boolean allowCompression = true;
    354                 ASTNode result = new RepetitionIndicatorNode(nowReading);
    355                 result.setProductionTag(12);
    356                 RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    357                 if( nowReading.isLextant(Lextant.OPTIONAL) ) {
    358                         expect(Lextant.OPTIONAL);
    359                 }
    360                 else if( nowReading.isLextant(Lextant.STAR) ) {
    361                         expect(Lextant.STAR);
    362                 }
    363                 else if( nowReading.isLextant(Lextant.PLUS) ) {
    364                         expect(Lextant.PLUS);
    365                 }
     576        public ASTNode parseAny() {
     577                if( !(nowReading.isLextant(Lextant.ANY)) ) {
     578                        return syntaxErrorNode("any² [ANY¹]");
     579                }
     580       
     581                boolean allowCompression = true;
     582                ASTNode result = new AnyNode(nowReading);
     583                result.setProductionTag(17);
     584                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     585                expect(Lextant.ANY);
     586                if(allowCompression) {
     587                        return result;
     588                }
     589                return result;
     590        }
     591         
     592        public ASTNode parseSos() {
     593                if( !(nowReading.isLextant(Lextant.SOS)) ) {
     594                        return syntaxErrorNode("sos² [SOS¹]");
     595                }
     596       
     597                boolean allowCompression = true;
     598                ASTNode result = new SosNode(nowReading);
     599                result.setProductionTag(18);
     600                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     601                expect(Lextant.SOS);
     602                if(allowCompression) {
     603                        return result;
     604                }
     605                return result;
     606        }
     607         
     608        public ASTNode parseEos() {
     609                if( !(nowReading.isLextant(Lextant.EOS)) ) {
     610                        return syntaxErrorNode("eos² [EOS¹]");
     611                }
     612       
     613                boolean allowCompression = true;
     614                ASTNode result = new EosNode(nowReading);
     615                result.setProductionTag(19);
     616                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     617                expect(Lextant.EOS);
    366618                if(allowCompression) {
    367619                        return result;
Note: See TracChangeset for help on using the changeset viewer.