Changeset 2331


Ignore:
Timestamp:
Aug 29, 2012, 2:45:30 PM (7 years ago)
Author:
bhull
Message:

Character class code and new repetition strategy.

Location:
proto/RE/src
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • proto/RE/src/applications/VisitAbstractSyntaxTree.java

    r2311 r2331  
    1010import java.io.PrintStream;
    1111
     12import codeGenerator.CharacterClassOutputGenerator;
    1213import codeGenerator.CodeGenerator;
    1314import codeGenerator.PythonGenerator;
     
    4344        CodeGenerator codeGenerator = new CodeGenerator(visitor.getNodeStates(),visitor.getCharacterClassVariables(), new PythonGenerator());
    4445        System.out.println(codeGenerator.generateCode(syntaxTree));
     46        System.out.println(CharacterClassOutputGenerator.generateCharacterClassOutput(visitor.getCharacterClassVariables()));
     47       
    4548    }
    4649}
  • proto/RE/src/codeGenerator/CharacterClassVariableGenerator.java

    r2310 r2331  
    22
    33public class CharacterClassVariableGenerator {
     4       
    45        public CharacterClassVariableGenerator() {
    56                super();
    67                position=0;
     8                prefix ="cc";
    79        }
     10        public CharacterClassVariableGenerator(String prefix) {
     11                super();
     12                position=0;
     13                this.prefix = prefix;
     14        }
     15        private String prefix;
    816        private int position;
    917        public String getNextCharacterClassVariable()
    1018        {
    11                 String out = "cc"+this.position;
     19                String out = prefix+this.position;
    1220                position+=1;
    1321                return out;
  • proto/RE/src/codeGenerator/CodeGenerator.java

    r2310 r2331  
    2929        }
    3030        private Output genCode(RepetitionNode node) {
    31                 //TODO: strategy for character class child
    3231       
    3332                //only one child?
     
    3736        NodeState childState = nodeStates.get(child);
    3837               
    39                 //is this the right way to do this?
    4038        LextantToken lT = (LextantToken) node.getToken();
    4139                String repetitionType = lT.getLextant().getPrimaryLexeme();
     
    4341                Output cursorAssign = oG.makeAssignment(oG.makeVariable(childState.getCursorVariable()), oG.makeVariable(nodeState.getCursorVariable()));
    4442                Output out = null;
     43               
     44                //TODO: better solution for alternate strategies
    4545
    46                 //too many assignments.  is the compiler going to do this reasonably well?  fix is messy
    47                 if (repetitionType == "?") {
    48                         out = oG.combineStatements(cursorAssign, body);
    49                         out = oG.combineStatements(out, oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()),oG.makeOr(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable()))));
     46                if (childState.isCharacterClass() && (repetitionType.equals("*")||repetitionType.equals("+"))) {
     47                        //is this the fastest way to do this?                   
     48                        if (repetitionType.equals("*")) {
     49                                Output add = oG.makeAdd(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(characterClassVariables.get(childState.getCharacterClassRepresentationString())));
     50                                Output xor = oG.makeXOr(add, oG.makeVariable(characterClassVariables.get(childState.getCharacterClassRepresentationString())));
     51                                Output or = oG.makeOr(xor, oG.makeVariable(nodeState.getCursorVariable()));
     52                                out = oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), or);
     53                        }
     54                        if (repetitionType.equals("+")) {
     55                                out = oG.combineStatements(cursorAssign, body);
     56                                out = oG.combineStatements(out, oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable())));
     57                                Output add = oG.makeAdd(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(characterClassVariables.get(childState.getCharacterClassRepresentationString())));
     58                                Output xor = oG.makeXOr(add, oG.makeVariable(characterClassVariables.get(childState.getCharacterClassRepresentationString())));
     59                                Output or = oG.makeOr(xor, oG.makeVariable(nodeState.getCursorVariable()));
     60                                out = oG.combineStatements(out,oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), or));
     61                        }
     62                       
     63                } else {
    5064               
     65                        //too many assignments.  is the compiler going to do this reasonably well?  fix is messy
     66                        if (repetitionType.equals("?")) {
     67                                out = oG.combineStatements(cursorAssign, body);
     68                                out = oG.combineStatements(out, oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()),oG.makeOr(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable()))));
     69                       
     70                        }
     71                        if (repetitionType.equals("*")) {
     72                                out = oG.combineStatements(cursorAssign, body);
     73                                out = oG.combineStatements(out, oG.makeWhile(oG.makeAnd(oG.makeNot(oG.makeVariable(nodeState.getCursorVariable())),oG.makeVariable(childState.getCursorVariable())), oG.combineStatements(oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeOr(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable()))),body)));
     74                       
     75                        }
     76                        if (repetitionType.equals("+")) {
     77               
     78                                out = oG.combineStatements(cursorAssign, body);
     79                                out = oG.combineStatements(out, oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable())));
     80                                out = oG.combineStatements(out, body);
     81                                out = oG.combineStatements(out, oG.makeWhile(oG.makeAnd(oG.makeNot(oG.makeVariable(nodeState.getCursorVariable())),oG.makeVariable(childState.getCursorVariable())), oG.combineStatements(oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeOr(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable()))),body)));
     82                        }
    5183                }
    52                 if (repetitionType =="*") {
    53                         out = oG.combineStatements(cursorAssign, body);
    54                         out = oG.combineStatements(out, oG.makeWhile(oG.makeAnd(oG.makeNot(oG.makeVariable(nodeState.getCursorVariable())),oG.makeVariable(childState.getCursorVariable())), oG.combineStatements(oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeOr(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable()))),body)));
    55                
    56                 }
    57                 if (repetitionType =="+") {
    58 
    59                         out = oG.combineStatements(cursorAssign, body);
    60                         out = oG.combineStatements(out, oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable())));
    61                         out = oG.combineStatements(out, body);
    62                         out = oG.combineStatements(out, oG.makeWhile(oG.makeAnd(oG.makeNot(oG.makeVariable(nodeState.getCursorVariable())),oG.makeVariable(childState.getCursorVariable())), oG.combineStatements(oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeOr(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(childState.getCursorVariable()))),body)));
    63                 }
    64                
    6584                return out;
    6685    }
     
    95114                NodeState nodeState = nodeStates.get(node);
    96115                if (nodeState.isCharacterClass()) {
    97                         return oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeAdvance(oG.makeAnd(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(characterClassVariables.get(nodeState.getCharacterClassRepresentation())))));
     116                        return oG.makeAssignment(oG.makeVariable(nodeState.getCursorVariable()), oG.makeAdvance(oG.makeAnd(oG.makeVariable(nodeState.getCursorVariable()), oG.makeVariable(characterClassVariables.get(nodeState.getCharacterClassRepresentationString())))));
    98117                       
    99118                }
  • proto/RE/src/codeGenerator/NodeState.java

    r2310 r2331  
    11package codeGenerator;
     2
     3import java.util.Arrays;
    24
    35public class NodeState {
     
    68                super();
    79                this.isCharacterClass = false;
    8                 this.characterClassRepresentation = "";
     10                this.characterClassRepresentation = new Boolean[256];
     11Arrays.fill(this.characterClassRepresentation,false);
    912                this.cursorVariable = cursorVariable;
    1013        }
     
    1215        private boolean isCharacterClass;
    1316       
    14         //won't stay as a string
    15         private String characterClassRepresentation;
     17
     18        private Boolean[] characterClassRepresentation;
    1619       
    1720        private String cursorVariable;
     
    2528        }
    2629
    27         public String getCharacterClassRepresentation() {
     30        public Boolean[] getCharacterClassRepresentation() {
    2831                return characterClassRepresentation;
    2932        }
     33       
     34        public String getCharacterClassRepresentationString() {
     35                String result="";
     36                for (int i = 0;i < 256;i++) {
     37                        if (this.characterClassRepresentation[i]) {
     38                                if (result.length() >0) {
     39                                        result+=",";
     40                                }
     41                                result+=i;
     42                        }
     43                }
     44                return result;
     45        }
    3046
    31         public void setCharacterClassRepresentation(String characterClassRepresentation) {
     47        public void setCharacterClassRepresentation(Boolean[] characterClassRepresentation) {
    3248                this.characterClassRepresentation = characterClassRepresentation;
    3349        }
  • proto/RE/src/codeGenerator/OutputGenerator.java

    r2310 r2331  
    1010        public Output combineStatements(Output op1, Output op2);
    1111        public Output makeVariable(String variable);
     12        public Output makeXOr(Output op1, Output op2);
     13        public Output makeAdd(Output op1, Output op2);
    1214       
    1315       
  • proto/RE/src/codeGenerator/PythonGenerator.java

    r2310 r2331  
    1818        public Output makeAnd(Output op1, Output op2) {
    1919
    20                 return new PythonOutput(op1 +" & "+op2);
     20                return new PythonOutput("("+op1 +" & "+op2+")");
    2121        }
    2222
    2323        @Override
    2424        public Output makeOr(Output op1, Output op2) {
    25                 // TODO Auto-generated method stub
    26                 return new PythonOutput(op1+" | "+op2);
     25                return new PythonOutput("("+op1+" | "+op2+")");
    2726        }
    2827
    2928        @Override
     29        public Output makeXOr(Output op1, Output op2) {
     30                return new PythonOutput("("+op1+" ^ "+op2+")");
     31        }
     32       
     33        @Override
     34        public Output makeAdd(Output op1, Output op2) {
     35                return new PythonOutput("("+op1+" + "+op2+")");
     36        }
     37       
     38       
     39        @Override
    3040        public Output makeWhile(Output condition, Output body) {
    31                 // TODO Auto-generated method stub
    3241                return new PythonOutput("while "+condition+":"+lineBreak+indentBlock(body));
    3342        }
     
    3544        @Override
    3645        public Output makeNot(Output op) {
    37                 // TODO Auto-generated method stub
    3846                return new PythonOutput("~"+op);
    3947        }
  • proto/RE/src/codeGenerator/Visitor.java

    r2310 r2331  
    11package codeGenerator;
    22
     3import java.util.Arrays;
    34import java.util.List;
    45import java.util.HashMap;
     
    2021        private Map<ASTNode, NodeState> nodeStates;
    2122       
    22         //TODO: change with char class rep
    2323        private Map<String, String> characterClassVariables;
    2424       
     
    2929                nodeStates = new HashMap<ASTNode, NodeState>();
    3030               
    31                 //TODO:change with char class rep
    3231                characterClassVariables = new HashMap<String,String>();
    3332        }
     
    5251                        NodeState childState = nodeStates.get(child);
    5352                        if (childState.isCharacterClass()) {
    54                                 if (characterClassVariables.containsKey(childState.getCharacterClassRepresentation())==false)
     53                                if (characterClassVariables.containsKey(childState.getCharacterClassRepresentationString())==false)
    5554                                {
    56                                         characterClassVariables.put(childState.getCharacterClassRepresentation(), characterClassVariableGenerator.getNextCharacterClassVariable());                                     
     55                                        characterClassVariables.put(childState.getCharacterClassRepresentationString(), characterClassVariableGenerator.getNextCharacterClassVariable());                                       
    5756                                }
    5857                        }
     
    9695        defaultVisit(node);
    9796    }
    98     public void visitLeave(AlternationNode node) {
    99         NodeState currState = nodeStates.get(node);
    100        
     97    public ASTNode visitLeave(AlternationNode node, List<ASTNode> childresults) {
     98        NodeState currState = nodeStates.get(node);
    10199        boolean allCharacterClass = true;
    102100        for (ASTNode child: node.getChildren()) {
     
    110108                currState.setCharacterClassRepresentation(mergeCharacterClassRepresentations(node.getChildren()));
    111109        }
    112         defaultVisitLeave(node);
     110        return defaultVisitLeave(node);
    113111    }
    114112
     
    139137    }
    140138   
    141     private String generateCharacterClassRepresentation(ASTNode node) {
    142         //TODO: Code this
    143         return "temp"+node.hashCode();
    144     }
    145     private String mergeCharacterClassRepresentations(List<ASTNode> nodes) {
    146         //TODO: Code this
    147         return "mergetemp";
     139    private Boolean[] generateCharacterClassRepresentation(IdentifierNode node) {
     140        Boolean[] result = new Boolean[256];
     141        Arrays.fill(result, false);
     142        result[getCharacter(node)]=true;
     143        return result;
     144    }
     145    private Boolean[] generateCharacterClassRepresentation(CharNode node) {
     146        Boolean[] result = new Boolean[256];
     147        Arrays.fill(result, false);
     148        result[getCharacter(node)]=true;
     149        return result;
     150    }
     151    private Boolean[] generateCharacterClassRepresentation(RangeNode node) {
     152        Boolean[] result = new Boolean[256];
     153
     154        Arrays.fill(result, false);
     155        int start = getCharacter(node.child(0));
     156        int end = getCharacter(node.child(1));
     157        for(int i = start; i<=end; i++) {
     158                result[i]=true;
     159        }
     160        return result;
     161    }
     162    private Boolean[] generateCharacterClassRepresentation(CharacterClassNode node) {
     163        Boolean[] result;
     164        result = mergeCharacterClassRepresentations(node.getChildren());
     165        if (getAttributeValue(node, "complemented").equals("true")){
     166                for (int i = 0;i < 256;i++) {
     167                       
     168                        result[i]=!result[i];
     169                }
     170        }
     171       
     172        return result;
    148173    }
    149174   
    150 
    151 
     175    private Boolean[] mergeCharacterClassRepresentations(List<ASTNode> nodes) {
     176        Boolean[] result = new Boolean[256];
     177        Arrays.fill(result, false);
     178        for (int i = 0; i < nodes.size();i++) {
     179                for (int j = 0; j < 256;j++){
     180                        if (nodeStates.get(nodes.get(i)).getCharacterClassRepresentation()[j])
     181                        {
     182                                result[j] = true;
     183                        }
     184                }
     185        }
     186        return result;
     187    }
     188    private int getCharacter(ASTNode node) {
     189        if (getAttributeValue(node, "escaped").equals("true")) {
     190                String character = node.getToken().getLexeme();
     191                if (character.equals("t")) {
     192                        return 9;
     193                } else if (character.equals("r")) {
     194                        return 13;
     195                } else if (character.equals("l")) {
     196                        return 10;
     197                } else {
     198                        System.out.println("escaped character error");
     199                        return -1;
     200                }
     201        }       
     202        else {
     203                return node.getToken().getLexeme().codePointAt(0);
     204        }
     205       
     206    }
     207    private String getAttributeValue(ASTNode node, String attribute) {
     208                //TODO: probably move this somewhere else
     209        //TODO: how are multiple attributes split? assuming that it's with "," for now
     210        String[] attributePairs = node.attributeString().split(",");
     211        for (int i = 0;i< attributePairs.length;i++) {
     212                String[] equalSplit = attributePairs[i].split("=");
     213                if (equalSplit.length==2) {
     214                       
     215                        if (equalSplit[0].trim().equals(attribute.trim()))
     216                        {
     217                                return equalSplit[1].trim();
     218                        }
     219                }
     220               
     221        }
     222        return "";
     223    }
    152224
    153225        public Map<ASTNode, NodeState> getNodeStates() {
Note: See TracChangeset for help on using the changeset viewer.