Changeset 1252


Ignore:
Timestamp:
Jul 31, 2011, 2:01:20 PM (8 years ago)
Author:
shermer
Message:

Housekeeeping in the incode package:

Removed unused condition-handling code from BasicBlock?.
Fixed empty-block handling.
Cleaned and organized Instruction.java.
Moved "number of operands" responsibility from Instruction to Op.

Location:
proto/pebble/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/src/incode/BasicBlock.java

    r1248 r1252  
    1010import util.PStringBuilder;
    1111
    12 import ast.AST;
    13 
    1412
    1513public class BasicBlock {
     
    2018        private String name;
    2119        private List<Instruction> store;
    22         private List<AST> conditions;           // need a better condition rep than BoolExpr.
     20       
    2321       
    2422///////////////////////////////////////////////////////////////////////////
     
    2826        public BasicBlock() {
    2927                store = new ArrayList<Instruction>(16);
    30                 conditions = new ArrayList<AST>();
    3128                addToBlockMap();
    3229        }
     
    105102                }
    106103               
    107                 for(AST expr : conditions) {
    108                         result.addCondition(expr.copy());
    109                 }
    110104                return result;
    111105        }
    112106
    113107
    114 ///////////////////////////////////////////////////////////////////////////
    115 // conditions (things known to be true for this block - use for optimizations)
    116 ///////////////////////////////////////////////////////////////////////////
    117 
    118         public void addCondition(AST expr) {
    119                 conditions.add(expr);
    120         }
    121         public void clearConditions() {
    122                 conditions = new ArrayList<AST>();
    123         }
    124         public Iterable<AST> conditions() {
    125                 return conditions;
    126         }
    127        
    128108
    129109///////////////////////////////////////////////////////////////////////////
     
    137117        public String pythonate(int baseIndentLevel) {
    138118                PStringBuilder result = new PStringBuilder(baseIndentLevel);
    139 //              System.err.println("pythonate(" + getName() + ")");
    140 //              fragmentOverview(System.err);
    141119                WorkList work = new WorkList(this, 0);
    142120                pythonateWorkList(work, result);
     
    206184                appendBBlockComment(result);
    207185
    208 //              System.err.println("pythonate_one(" + getName() + ")");
    209                 if(isOnlyJump()) {
     186                if(isOnlyNonErrorJump()) {
    210187                        appendNoInstructions(result);
    211188                }
     
    214191                }
    215192        }
    216         // this is a hack.  Do something better soon.
    217         private boolean isOnlyJump() {
    218                 return (store.size()==0) || (store.size()==1 && lastIsJumpType() && !lastIsError());
    219         }
    220         private boolean lastIsJumpType() {
    221                 int length = store.size();
    222                 Instruction instruction = store.get(length-1);
    223                 return instruction.isJumpType();
    224         }
    225         private boolean lastIsError() {
    226                 int length = store.size();
    227                 Instruction instruction = store.get(length-1);
    228                 return instruction.getOperation() == Op.ERROR;
     193
     194        // block is just NOP and COMMENT, with a JumpType at the end, but not ERROR.
     195        private boolean isOnlyNonErrorJump() {
     196                for(Instruction instr: store) {
     197                        Op operation = instr.getOperation();
     198                        if(operation==Op.NOP || operation==Op.COMMENT)
     199                                continue;
     200                        if(operation.isJumpType()&& operation!=Op.ERROR)
     201                                return true;    // if instructions after this, tough cookies.
     202                        return false;
     203                }
     204                return false;
    229205        }
    230206        private void appendBBlockComment(PStringBuilder result) {
    231                 result.appendLineStart("# " + name);
    232                 for(AST condition : conditions) {
    233                         result.append(" " + condition + " = 0");
    234                 }
    235                 result.append("\n");
     207                result.appendLine("# " + name);
    236208        }
    237209        private void appendNoInstructions(PStringBuilder result) {
     
    292264        }
    293265
    294         public BasicBlock fragmentTail() {
    295                 return Fragment.make(this).getTail();
    296         }
    297266       
    298267///////////////////////////////////////////////////////////////////////////
  • proto/pebble/trunk/src/incode/Instruction.java

    r1248 r1252  
    88        private boolean liveOut;
    99        private boolean notEqualsComparison;    // for testType instructions.  False means ==0, True means !=0.
    10        
    11 
     10
     11       
     12        ///////////////////////////////////////////////////////////////////////////
     13        // constructors and helper
     14        ///////////////////////////////////////////////////////////////////////////
    1215        public Instruction(Op operation, String variable, String operand1, String operand2, String operand3) {
    1316                super();
     
    3639                this(operation, null, null, null, null);
    3740        }
    38 
    3941        private String translateArrayIndices(String operand) {
    4042                if(operand == null)
     
    5052                return base + '[' + index + ']';
    5153        }
     54
     55        ///////////////////////////////////////////////////////////////////////////
     56        // property accessors / mutators
     57        ///////////////////////////////////////////////////////////////////////////
    5258        public void markForDeletion() {
    5359                toBeDeleted = true;
     
    6874                return notEqualsComparison;
    6975        }
    70         private String comparisonString() {
    71                 return isNotEqualsComparison() ? "!=" : "==";
    72         }
    73 
    74        
    75         public boolean isCommutable() {
    76                 return operation.isCommutable();
    77         }
    78         public void commute() {
    79                 String temp = operand[0];
    80                 operand[0] = operand[1];
    81                 operand[1] = temp;
    82         }
    83 
    84         public String toString() {
    85                 return String.format(operation.format(), variable, operand[0], operand[1], operand[2], comparisonString());
    86         }
    87 
    88         public String toPython() {
    89                 return String.format(operation.pythonFormat(), variable, operand[0], operand[1], operand[2], comparisonString());
    90         }
    91        
     76
     77
     78        ///////////////////////////////////////////////////////////////////////////
     79        // component accessors / mutators
     80        ///////////////////////////////////////////////////////////////////////////
     81        public Op getOperation() {
     82                return operation;
     83        }
     84        public void setOperation(Op op) {
     85                this.operation = op;
     86        }
     87        public String getVariable() {
     88                return variable;
     89        }
     90        public void setVariable(String string) {
     91                variable = string;
     92        }
    9293        /**
    9394         * Gets an operand of the instruction.
     
    102103                operand[i] = string;
    103104        }
    104         public String getVariable() {
    105                 return variable;
    106         }
    107         public void setVariable(String string) {
    108                 variable = string;
    109         }
    110         public Op getOperation() {
    111                 return operation;
    112         }
    113         public void setOperation(Op op) {
    114                 this.operation = op;
    115         }
     105
     106
     107        ///////////////////////////////////////////////////////////////////////////
     108        // delegate property accessors
     109        ///////////////////////////////////////////////////////////////////////////
    116110        public boolean isJumpType() {
    117111                return operation.isJumpType();
     
    120114                return operation.isTestType();
    121115        }
     116        public boolean isCommutable() {
     117                return operation.isCommutable();
     118        }
     119        public int numOperands() {
     120                return operation.numberOfOperands();
     121        }
     122       
     123       
     124        ///////////////////////////////////////////////////////////////////////////
     125        // string representation
     126        ///////////////////////////////////////////////////////////////////////////
     127        public String toString() {
     128                return String.format(operation.format(), variable, operand[0], operand[1], operand[2], comparisonString());
     129        }
     130        public String toPython() {
     131                return String.format(operation.pythonFormat(), variable, operand[0], operand[1], operand[2], comparisonString());
     132        }
     133        private String comparisonString() {
     134                return isNotEqualsComparison() ? "!=" : "==";
     135        }
     136       
     137       
     138        ///////////////////////////////////////////////////////////////////////////
     139        // other services:
     140        //              varIgnoringHashCode     helps speed expression matching
     141        //              copy
     142        //              commute                                 switches operands 0 and 1
     143        ///////////////////////////////////////////////////////////////////////////
     144
     145        // this hashcode ignores the variable name, and is invariant under
     146        // permutation of operands.
    122147        public int varIgnoringHashCode() {
    123148                int result = operation.ordinal();
    124                 if(has0Operands()) return result;
    125                
    126                 result = result + operand[0].hashCode();
    127                 if(has1Operand()) return result;
    128 
    129                 result = result + operand[1].hashCode();
    130                 if(has2Operands()) return result;
    131                
    132                 return result + operand[2].hashCode();
    133         }
    134        
    135         public boolean has0Operands() {
    136                 return operand[0] == null;
    137         }
    138         public boolean has1Operand() {
    139                 return operand[0] != null && operand[1] == null;
    140         }
    141         public boolean has2Operands() {
    142                 return operand[1] != null && operand[2] == null;
    143         }
    144         public boolean has3Operands() {
    145                 return operand[2] != null;
    146         }
    147         public int numOperands() {
    148                 if(has0Operands()) return 0;
    149                 if(has1Operand( )) return 1;
    150                 if(has2Operands()) return 2;
    151                 return 3;
    152         }
    153 
    154 
    155         public static Instruction makeAnd(String var, String operand1, String operand2) {
    156                 return new Instruction(Op.AND, var, operand1, operand2);
    157         }
    158         public static Instruction makeOr(String var, String operand1, String operand2) {
    159                 return new Instruction(Op.OR, var, operand1, operand2);
    160         }
    161         public static Instruction makeXor(String var, String operand1, String operand2) {
    162                 return new Instruction(Op.XOR, var, operand1, operand2);
    163         }
    164         public static Instruction makeNot(String var, String operand1) {
    165                 return new Instruction(Op.NOT, var, operand1);
    166         }
    167         public static Instruction makeCopy(String var, String operand1) {
    168                 return new Instruction(Op.COPY, var, operand1);
    169         }
    170         public static Instruction makeSel(String var, String operand1, String operand2, String operand3) {
    171                 return new Instruction(Op.SEL, var, operand1, operand2, operand3);
    172         }
    173         public static Instruction makeAndNot(String var, String operand1, String operand2) {
    174                 return new Instruction(Op.ANDNOT, var, operand1, operand2);
    175         }
    176         public static Instruction makeShift(String var, String operand1, String operand2) {
    177                 return new Instruction(Op.SHIFT, var, operand1, operand2);
    178         }       
    179         public static Instruction makeScan(String var, String operand1, String operand2) {
    180                 return new Instruction(Op.SCAN, var, operand1, operand2);
    181         }
    182         public static Instruction makeSpan(String var, String operand1, String operand2) {
    183                 return new Instruction(Op.SPAN, var, operand1, operand2);
    184         }
    185 
    186 
    187         public static Instruction makeNop() {
    188                 return new Instruction(Op.NOP);
    189         }
    190         public static Instruction makeComment(String comment) {
    191                 return new Instruction(Op.COMMENT, "", comment);
    192         }
    193         public static Instruction makeNull() {
    194                 return new NullInstruction();
    195         }
    196        
    197         public static Instruction makeTest(String var, String trueName, String falseName, String joinName, boolean notEqualsComparison) {
    198                 return makeTestType(Op.TEST, var, trueName, falseName, joinName, notEqualsComparison);
    199         }
    200         public static Instruction makeWhile(String var, String loopName, String exitName, boolean notEqualsComparison) {
    201                 return makeTestType(Op.WHILE, var, loopName, exitName, null, notEqualsComparison);
    202         }
    203         private static Instruction makeTestType(Op op, String var,
    204                         String trueName, String falseName, String joinName, boolean notEqualComparison) {
    205                 Instruction instruction = new Instruction(op, var, trueName, falseName, joinName);
    206                 if(notEqualComparison) instruction.setNotEqualsComparison();
    207                 return instruction;
    208         }
    209         public static Instruction makeJump(String label) {
    210                 return new Instruction(Op.JUMP, "", label);
    211         }
    212         public static Instruction makeIter(String label) {
    213                 return new Instruction(Op.ITER, "", label);
    214         }
    215         public static Instruction makeJoin(String label) {
    216                 return new Instruction(Op.JOIN, "", label);
    217         }
    218         public static Instruction makeError(String var, String falseName, String trueMessage, boolean notEqualsComparison) {
    219                 return makeTestType(Op.ERROR, var, falseName, trueMessage, null, notEqualsComparison);
    220         }
    221        
     149                for(int i=0; i<numOperands(); i++) {
     150                        result = result + operand[i].hashCode();
     151                }
     152                return result;
     153        }
    222154        public Instruction copy() {
    223155                Instruction result = new Instruction(operation, variable, operand[0], operand[1], operand[2]);
     
    230162                return result;
    231163        }
    232        
     164        public void commute() {
     165                String temp = operand[0];
     166                operand[0] = operand[1];
     167                operand[1] = temp;
     168        }
     169       
     170       
     171        ///////////////////////////////////////////////////////////////////////////
     172        // static factories for each op-type
     173        ///////////////////////////////////////////////////////////////////////////
     174        public static Instruction makeAnd(String var, String operand1, String operand2) {
     175                return new Instruction(Op.AND, var, operand1, operand2);
     176        }
     177        public static Instruction makeOr(String var, String operand1, String operand2) {
     178                return new Instruction(Op.OR, var, operand1, operand2);
     179        }
     180        public static Instruction makeXor(String var, String operand1, String operand2) {
     181                return new Instruction(Op.XOR, var, operand1, operand2);
     182        }
     183        public static Instruction makeNot(String var, String operand1) {
     184                return new Instruction(Op.NOT, var, operand1);
     185        }
     186        public static Instruction makeCopy(String var, String operand1) {
     187                return new Instruction(Op.COPY, var, operand1);
     188        }
     189        public static Instruction makeSel(String var, String operand1, String operand2, String operand3) {
     190                return new Instruction(Op.SEL, var, operand1, operand2, operand3);
     191        }
     192        public static Instruction makeAndNot(String var, String operand1, String operand2) {
     193                return new Instruction(Op.ANDNOT, var, operand1, operand2);
     194        }
     195        public static Instruction makeShift(String var, String operand1, String operand2) {
     196                return new Instruction(Op.SHIFT, var, operand1, operand2);
     197        }       
     198        public static Instruction makeScan(String var, String operand1, String operand2) {
     199                return new Instruction(Op.SCAN, var, operand1, operand2);
     200        }
     201        public static Instruction makeSpan(String var, String operand1, String operand2) {
     202                return new Instruction(Op.SPAN, var, operand1, operand2);
     203        }
     204
     205        public static Instruction makeNop() {
     206                return new Instruction(Op.NOP);
     207        }
     208        public static Instruction makeComment(String comment) {
     209                return new Instruction(Op.COMMENT, "", comment);
     210        }
     211        public static Instruction makeNull() {
     212                return new NullInstruction();
     213        }
     214       
     215        public static Instruction makeTest(String var, String trueName, String falseName, String joinName, boolean notEqualsComparison) {
     216                return makeTestType(Op.TEST, var, trueName, falseName, joinName, notEqualsComparison);
     217        }
     218        public static Instruction makeWhile(String var, String loopName, String exitName, boolean notEqualsComparison) {
     219                return makeTestType(Op.WHILE, var, loopName, exitName, null, notEqualsComparison);
     220        }
     221        private static Instruction makeTestType(Op op, String var,
     222                        String trueName, String falseName, String joinName, boolean notEqualComparison) {
     223                Instruction instruction = new Instruction(op, var, trueName, falseName, joinName);
     224                if(notEqualComparison) instruction.setNotEqualsComparison();
     225                return instruction;
     226        }
     227        public static Instruction makeJump(String label) {
     228                return new Instruction(Op.JUMP, "", label);
     229        }
     230        public static Instruction makeIter(String label) {
     231                return new Instruction(Op.ITER, "", label);
     232        }
     233        public static Instruction makeJoin(String label) {
     234                return new Instruction(Op.JOIN, "", label);
     235        }
     236        public static Instruction makeError(String var, String falseName, String trueMessage, boolean notEqualsComparison) {
     237                return makeTestType(Op.ERROR, var, falseName, trueMessage, null, notEqualsComparison);
     238        }
     239       
     240
     241        ///////////////////////////////////////////////////////////////////////////
     242        // Null Object.  Use the makeNull factory, above, to create.
     243        ///////////////////////////////////////////////////////////////////////////
    233244        static private class NullInstruction extends Instruction {
    234245                public NullInstruction() {
     
    243254                }
    244255        }
    245 
    246256}
  • proto/pebble/trunk/src/incode/Op.java

    r1248 r1252  
    55
    66public enum Op {
    7         AND("&"),                       // most ops:  Instruction.variable = Op(Instruction.operand[0]...)
    8         OR("|"),
    9         XOR("^"),
    10         NOT("~"),
    11         COPY(" "),
    12         SEL("?"),
    13         ANDNOT("&~"),
    14         SHIFT(">>"),
    15         SCAN("+>"),
    16         SPAN("<>"),
     7        AND("&", 2),                    // most ops:  Instruction.variable = Op(Instruction.operand[0]...)
     8        OR("|", 2),
     9        XOR("^", 2),
     10        NOT("~", 1),
     11        COPY(" ", 1),
     12        SEL("?", 3),
     13        ANDNOT("&~", 2),
     14        SHIFT(">>", 2),
     15        SCAN("+>", 2),
     16        SPAN("<>", 2),
    1717       
    1818        // several flavors of do nothing
    19         NOP("nop"),
    20         COMMENT("#"),
    21         INVALID("null"),        // used by NullInstruction
     19        NOP("nop", 0),
     20        COMMENT("#", 1),
     21        INVALID("null", 0),     // used by NullInstruction
    2222
    2323        // several flavors of test & branch are distinguished for pythonating purposes.
     
    2626        //              the condition is "var==0"; otherwise,
    2727        //              the condition is "var!=0".
    28         TEST("test"),           // if variable is true, jump to argument0, else argument1
     28        TEST("test", 3),        // if variable is true, jump to argument0, else argument1
    2929                                                // argument2 is used as the block where the "then" and "else"
    3030                                                // clauses join.
    31         WHILE("while"),         // same as TEST, but to distinguish loops.  no argument2.
     31        WHILE("while", 2),      // same as TEST, but to distinguish loops.  no argument2.
    3232       
    3333        // several flavors of jump are distinguished, mainly for pythonating purposes.
    3434        // jump instructions do not use the "Instruction.variable" field.
    35         JUMP("jump"),           //
    36         ITER("iter"),           // backwards jump at the end of a loop.
    37         JOIN("join"),           // jump from the end of an if/else branch
     35        JUMP("jump", 1),        //
     36        ITER("iter", 1),        // backwards jump at the end of a loop.
     37        JOIN("join", 1),        // jump from the end of an if/else branch
    3838       
    3939        // error is a branch that is grouped with the jumps, as one branch (report error and halt)
    4040        // is not elaborated as a basic block in incode. 
    41         ERROR("error"),         // if condition is true
     41        ERROR("error", 2),      // if condition is true
    4242                                                //     then jump to block operand0
    4343                                                // else message operand1 is issued, and we exit.
     
    4545       
    4646        private String symbol;
     47        private int numberOfOperands;
    4748
    48         Op(String symbol) {
     49        Op(String symbol, int numberOfOperands) {
    4950                this.symbol = symbol;
     51                this.numberOfOperands = numberOfOperands;
    5052        }
    5153        public String symbol() {
    5254                return symbol;
     55        }
     56        public int numberOfOperands() {
     57                return numberOfOperands;
    5358        }
    5459        public boolean isCommutable() {
Note: See TracChangeset for help on using the changeset viewer.