Changeset 1248


Ignore:
Timestamp:
Jul 30, 2011, 8:57:28 PM (8 years ago)
Author:
shermer
Message:

v0.6.2
Made if-error compatible with python/pablo.
Cleaned up instruction printing and pythonating.
Fixed bug in copying ConditionASTN.

Location:
proto/pebble/trunk
Files:
8 edited

Legend:

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

    r1242 r1248  
    1010
    1111macro first {
    12         ccc = ddd
    13         eee = fff
    14         while eee not allzero {
    15                 ggg = hhh
    16                 iii = jjj
     12        a = b & c
     13        d = e | f
     14        g = h ^ i
     15        j = ~k
     16        l = m
     17        n = >>>o
     18        p = q +> r
     19        s = t <> u
     20       
     21        if v & w | x not allone then {
     22                x = 0
     23        }
     24        else {
     25                x = 1
     26        }
     27
     28        if y not allzero
     29                error <<this is an error>>
     30       
     31        z = 0
     32       
     33        while alpha not allone {
     34                beta = 0
     35                gamma = 1
     36                delta = 2
    1737        }
    1838}
     
    2242}
    2343
    24 macro normalize_line_breaks {
    25         control.CRLF = "\r\n"
    26        
    27         # Convert CRs to LFs (flip bits 5, 6 and 7 with xor).
    28         basis_bits.bit_5 ^= [\r]
    29         basis_bits.bit_6 ^= [\r]
    30         basis_bits.bit_7 ^= [\r]
    31 }
    32 
    33 macro add_multiliterals {
    34         PI_start = "<?"
    35         CtCD_start = "<!"
    36         EndTag_start = "</"
    37         CD_End = "]]>"
    38         DoubleHyphen = "--"
    39         PI_end = "?>"
    40 }
    41 
    42 macro parse_CtCDPI {
    43         CD_span = 0
    44         Ct_span = 0
    45        
    46         while CtCDPI_Cursor not allzero {
    47                 CtCDPI_starts |= CtCDPI_Cursor
    48                 PI_Cursor = CtCDPI_Cursor & "<?"
    49                 CD_Ct_Cursor = >(CtCDPI_Cursor & ~PI_Cursor)
    50                 CD_Cursor = CD_Ct_Cursor & [<]
    51 
    52                 PI_Cursor = PI_name_end +> PI_end_scan
    53                 CD_Cursor +>= CD_end_scan
    54                 Ct_Cursor = >(Ct_Cursor +> Ct_end_scan)
    55                
    56                 PI_ends |= PI_Cursor
    57                 CD_ends |= CD_Cursor
    58                 Ct_ends |= Ct_Cursor
    59         }
    60 }
    61 
    62 
    63 macro validate_no_CD_end {
    64          e = lex.CD_end & ~(markup1.CtCDPI_mask | tags.Tags)
    65 }
    6644
    6745
  • proto/pebble/trunk/src/ast/nodes/ConditionASTN.java

    r1242 r1248  
    5252                constant = constantValue;
    5353                this.notEqual = notEqual;
    54                 addChild(expression);
     54                if(expression != null) {
     55                        addChild(expression);
     56                }
    5557        }
    5658
     
    122124        @Override
    123125        public AST copyThisNode() {
    124                 return new ConditionASTN(constant, notEqual, getChild(0).copy());
     126                return new ConditionASTN(constant, notEqual, null);
    125127        }       
    126128        @Override
  • proto/pebble/trunk/src/incode/BasicBlock.java

    r1242 r1248  
    214214                }
    215215        }
     216        // this is a hack.  Do something better soon.
    216217        private boolean isOnlyJump() {
    217                 return (store.size()==0) || (store.size()==1 && lastIsJumpType());
     218                return (store.size()==0) || (store.size()==1 && lastIsJumpType() && !lastIsError());
    218219        }
    219220        private boolean lastIsJumpType() {
     
    222223                return instruction.isJumpType();
    223224        }
     225        private boolean lastIsError() {
     226                int length = store.size();
     227                Instruction instruction = store.get(length-1);
     228                return instruction.getOperation() == Op.ERROR;
     229        }
    224230        private void appendBBlockComment(PStringBuilder result) {
    225231                result.appendLineStart("# " + name);
     
    234240        private void appendInstructions(PStringBuilder result) {
    235241                for(Instruction i: store) {
    236                         result.appendLine(i.toString());
     242                        result.appendLine(i.toPython());
    237243                }
    238244        }
  • proto/pebble/trunk/src/incode/Instruction.java

    r1246 r1248  
    11package incode;
    2 
    3 import util.PStringBuilder;
    42
    53public class Instruction {
     
    8583
    8684        public String toString() {
    87                 if(operation == Op.SCAN) {
    88                         return String.format("%s = scanThrough(%s, %s)",
    89                                 variable, operand[0], operand[1]);
    90                 }
    91                 if(operation == Op.TEST) {
    92                         String comparison = comparisonString();
    93                         return String.format("if %s %s 0 then:\t\t\t# goto %s ; else: goto %s ; join: goto %s",
    94                                         variable, comparison, operand[0], operand[1], operand[2]);
    95                 }
    96                 if(operation == Op.WHILE) {
    97                         String comparison = comparisonString();
    98                         return String.format("while %s %s 0:\t\t\t# do: %s ; done: goto %s",
    99                                         variable, comparison, operand[0], operand[1]);
    100                 }
    101                 if(operation == Op.ERROR) {
    102                         String comparison = comparisonString();
    103                         return String.format("if %s %s 0 then: goto %s; else: error(\"%s\")",
    104                                         variable, comparison, operand[0], operand[1]);
    105                 }
    106                 if(operation == Op.JUMP) {
    107                         return String.format("goto %s\t\t#jump", operand[0]);
    108                 }
    109                 if(operation == Op.ITER) {
    110                         return("");
    111 //                      return String.format("goto %s\t\t#iter", operand[0]);
    112                 }
    113                 if(operation == Op.JOIN) {
    114                         return("");
    115 //                      return String.format("goto %s\t\t#join", operand[0]);
    116                 }
    117                 if(operation == Op.COMMENT) {
    118                         return String.format("# %s", operand[0]);
    119                 }               
    120                 if(operation == Op.SHIFT) {
    121                         return String.format("%s = shift(%s, %s)", variable, operand[0], operand[1]);
    122                 }               
    123                 if(operation == Op.SPAN) {
    124                         return String.format("%s = %s - %s", variable, operand[1], operand[0]);
    125                 }
    126                 if(has0Operands()) {
    127                         return String.format("%s = %6s", variable, operation);
    128                 }
    129                 else if(has1Operand()) {
    130                         return String.format("%s = %s%s", variable, operation.symbol(), operand[0]);
    131                 }
    132                 else if(has2Operands()) {
    133                         return String.format("%s = %s %1s %s", variable, operand[0], operation.symbol(), operand[1]);
    134                 }
    135                 else {
    136 //                      return String.format("%s = %s ? %s : %s", variable, operand[0], operand[1], operand[2]);
    137                         return String.format("%s = (%s & %s) | (%s &~ %s)",
    138                                 variable, operand[1], operand[0], operand[2], operand[0]);
    139                 }
     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());
    14090        }
    14191       
     
    267217        }
    268218        public static Instruction makeError(String var, String falseName, String trueMessage, boolean notEqualsComparison) {
    269                 return makeTestType(Op.ERROR, var, falseName, trueMessage, null, !notEqualsComparison);
     219                return makeTestType(Op.ERROR, var, falseName, trueMessage, null, notEqualsComparison);
    270220        }
    271221       
  • proto/pebble/trunk/src/incode/Op.java

    r1242 r1248  
    6363                return this==TEST || this==WHILE;
    6464        }
     65       
     66        //Note: I chose to implement the following as a switch rather than as a constructor arg
     67        // so that the constructor calls do not get too large and uneven.  The default case
     68        // should perhaps be more forceful, such as an error message or assertion.
     69        // By examining format(), one should be able to see which operands do what in any
     70        // particular instruction.
     71       
     72        //
     73        // Format strings for use in a call with arguments as follows:
     74        //                                                        1$        2$          3$          4$          5$
     75        // String.format(Op.format(), variable, operand[0], operand[1], operand[2], comparisonString());
     76        public String format() {
     77                switch(this) {
     78                case AND:      return "%1$s = %2$s & %3$s";
     79                case OR:       return "%1$s = %2$s | %3$s";
     80                case XOR:      return "%1$s = %2$s ^ %3$s";
     81                case NOT:          return "%1$s = ~%2$s";
     82                case COPY:         return "%1$s = %2$s";
     83                case SEL:          return "%1$s = (%3$s & %2$s) | (%4$s &~ %2$s)";
     84                case ANDNOT:   return "%1$s = %2$s &~ %3$s";
     85                case SHIFT:    return "%1$s = shift(%2$s, %3$s)";
     86                case SCAN:     return "%1$s = scanThrough(%2$s, %3$s)";
     87                case SPAN:     return "%1$s = %3$s - %2$s";
     88                case NOP:          return "pass";
     89                case COMMENT:  return "# %2$s";
     90                case INVALID:  return "null instruction";
     91               
     92                case TEST:     return "if %1$s %5$s 0: \t\t\t# goto %2$s; else: goto %3$s; join: goto %4$s";
     93                case WHILE:    return "while %1$s %5$s 0: \t\t\t# do %2$s; done: goto %3$s";
     94                case JUMP:     return "goto %2$s\t\t\t# jump";
     95                case ITER:         return "";
     96                case JOIN:         return "";
     97                case ERROR:    return "if %1$s %5$s 0: error(\"%3$s\") \t\t\t# else: goto %2$s";
     98                default: return "unknown instruction";
     99                }
     100        }
     101        public String pythonFormat() {
     102                switch(this) {
     103                case AND:      return "%1$s = %2$s & %3$s";
     104                case OR:       return "%1$s = %2$s | %3$s";
     105                case XOR:      return "%1$s = %2$s ^ %3$s";
     106                case NOT:          return "%1$s = ~%2$s";
     107                case COPY:         return "%1$s = %2$s";
     108                case SEL:          return "%1$s = (%3$s & %2$s) | (%4$s &~ %2$s)";
     109                case ANDNOT:   return "%1$s = %2$s &~ %3$s";
     110                case SHIFT:    return "%1$s = bitutil.multiAdvance(%2$s, %3$s)";
     111                case SCAN:     return "%1$s = bitutil.scanThru(%2$s, %3$s)";
     112                case SPAN:     return "%1$s = %3$s - %2$s";
     113                case NOP:          return "pass";
     114                case COMMENT:  return "# %2$s";
     115                case INVALID:  return "null instruction";
     116               
     117                case TEST:     return "if %1$s %5$s 0: \t\t\t# goto %2$s; else: goto %3$s; join: goto %4$s";
     118                case WHILE:    return "while %1$s %5$s 0: \t\t\t# do %2$s; done: goto %3$s";
     119                case JUMP:     return "goto %2$s\t\t\t# jump";
     120                case ITER:         return "";
     121                case JOIN:         return "";
     122                case ERROR:    return "if %1$s %5$s 0: error_tracker.reportError(\"%3$s\", %1$s) \t# else: goto %2$s";
     123                default: return "unknown instruction";
     124                }
     125        }
    65126}
  • proto/pebble/trunk/src/incode/Pythonater.java

    r1246 r1248  
    7272                out.println(python);
    7373        }
    74 
    75 
    7674}
  • proto/pebble/trunk/src/parser/Pebble.g

    r1246 r1248  
    293293                }
    294294        | 'error' m=StringConstant {
    295                         $message = $m.text;
     295                        int length = $m.text.length();
     296                        $message = $m.text.substring(2, length-2);
    296297                        $falseTree = null;
    297298                        $trueTree = null;
Note: See TracChangeset for help on using the changeset viewer.