Changeset 1253


Ignore:
Timestamp:
Jul 31, 2011, 4:49:39 PM (8 years ago)
Author:
shermer
Message:

v0.6.3
Work on eliminating jump statements in output, and preparing for global optimizations:

Changed ASTtoIncode to give While and If children their proper jump instructions for pythonation.
Added package incode.global, including predecessor-calculator and utility to merge "basic" blocks into real basic blocks.
Added property-list utility and added property list to BasicBlock?.
Made Fragment implement Iterable<BasicBlock?>.

Location:
proto/pebble/trunk
Files:
8 added
4 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/src/ast/transforms/ASTtoIncode.java

    r1249 r1253  
    253253                                addToBlock(instr);
    254254                               
    255                                 trueTail.addJumpTo(followBlock);
     255                                trueTail.addJoinTo(followBlock);
    256256                               
    257257                                blocks.pop();                           // removes block that ends with if-statement
     
    266266                                Fragment falseFragment = Fragment.make(falseBlockName);
    267267                                BasicBlock falseTail   = falseFragment.getTail();
    268                                 trueTail.addJumpTo(followBlock);
    269                                 falseTail.addJumpTo(followBlock);
     268                                trueTail.addJoinTo(followBlock);
     269                                falseTail.addJoinTo(followBlock);
    270270                               
    271271                                blocks.pop();                           // removes block that ends with if-statement
     
    332332                       
    333333                        loopTail.addJumpTo(conditionCalc2);
    334                         conditionCalc2.addJumpTo(whileBlock);
     334                        conditionCalc2.addIterTo(whileBlock);
    335335                       
    336336                        blocks.push(followBlock);
  • proto/pebble/trunk/src/incode/BasicBlock.java

    r1252 r1253  
    22
    33import static incode.Instruction.makeJump;
     4import static incode.Instruction.makeJoin;
     5import static incode.Instruction.makeIter;
    46
    57import java.util.ArrayList;
     
    911
    1012import util.PStringBuilder;
     13import util.property.Property;
     14import util.property.PropertyList;
    1115
    1216
     
    1822        private String name;
    1923        private List<Instruction> store;
     24        private PropertyList properties;
    2025       
    2126       
     
    2631        public BasicBlock() {
    2732                store = new ArrayList<Instruction>(16);
     33                properties = new PropertyList();
    2834                addToBlockMap();
    2935        }
     
    5359// add                          : add a single instruction
    5460// addJumpTo            : add a jump to a given block
     61// addJoinTo            : add a join to a given block
    5562// append                       : copy another block's instructions
    5663// numInstructions      : return the number of instructions held
    5764// instruction          : return the instruction at a given index
    5865// instructions         : return the entire list of instructions
     66// removeLast           : removes the last instruction
    5967///////////////////////////////////////////////////////////////////////////
    6068
     
    6977                String toBlockName = toBlock.getName();
    7078                add(makeJump(toBlockName));
     79        }
     80        public void addJoinTo(BasicBlock toBlock) {
     81                String toBlockName = toBlock.getName();
     82                add(makeJoin(toBlockName));
     83        }
     84        public void addIterTo(BasicBlock toBlock) {
     85                String toBlockName = toBlock.getName();
     86                add(makeIter(toBlockName));
    7187        }
    7288        /**
     
    90106                return store.size();
    91107        }
    92 
     108        public void removeLast() {
     109                store.remove(store.size()-1);
     110        }
    93111       
    94112///////////////////////////////////////////////////////////////////////////
    95113// copy                 : returns a copy of this block
    96 ///////////////////////////////////////////////////////////////////////////
    97 
     114//                                (but does not copy property list)
     115///////////////////////////////////////////////////////////////////////////
    98116        public BasicBlock copy() {
    99117                BasicBlock result = new BasicBlock();
     
    264282        }
    265283
     284///////////////////////////////////////////////////////////////////////////
     285// property list delegates
     286///////////////////////////////////////////////////////////////////////////     
     287        public void addProperty(Property p) {
     288                properties.add(p);
     289        }
     290        public boolean hasProperty(String propertyName) {
     291                return properties.hasProperty(propertyName);
     292        }
     293        public void removeProperty(String propertyName) {
     294                properties.remove(propertyName);
     295        }
     296        public Property getProperty(String propertyName) {
     297                return properties.get(propertyName);
     298        }
     299        public void clearProperties() {
     300                properties.clear();
     301        }
    266302       
    267303///////////////////////////////////////////////////////////////////////////
  • proto/pebble/trunk/src/incode/Fragment.java

    r1242 r1253  
    44import java.util.ArrayList;
    55import java.util.HashMap;
     6import java.util.Iterator;
    67import java.util.List;
    78import java.util.Map;
     
    1516// without polluting that class.
    1617
    17 public class Fragment {
     18public class Fragment implements Iterable<BasicBlock> {
    1819        private BasicBlock head;
    1920       
     
    100101                }
    101102        }       
    102 
    103103        private String leadsToString(BasicBlock block) {
    104104                PStringBuilder builder = new PStringBuilder();
     
    112112       
    113113       
     114        ///////////////////////////////////////////////////////////////////////////
     115        // Iterable<BasicBlock> implementation, and
     116        // blocks() - returns a list of the basic blocks in this fragment.
     117        ///////////////////////////////////////////////////////////////////////////
     118
     119        public Iterator<BasicBlock> iterator() {
     120                return blocks().iterator();
     121        }
     122        /**
     123         * Makes a fresh list of the blocks in this fragment.
     124         * @return the list of blocks.
     125         */
     126        public List<BasicBlock> blocks() {
     127                List<BasicBlock> result = new ArrayList<BasicBlock>();
     128               
     129                WorkList work = new WorkList(head);
     130                for(BasicBlock block: work) {
     131                        result.add(block);
     132                        work.addSuccessors(block);
     133                }
     134                return result;
     135        }
    114136       
    115137        ///////////////////////////////////////////////////////////////////////////
  • proto/pebble/trunk/src/main/Main.java

    r1246 r1253  
    11package main;
    22import incode.BasicBlock;
     3import incode.Fragment;
    34import incode.Pythonater;
     5import incode.global.MergeBlocks;
    46
    57import java.io.IOException;
     
    5153            LexicalCollector headCollector = ((ProgramBlockASTN)tree).getCollector();
    5254            BasicBlock headBlock = ASTtoIncode.apply(tree);
     55            MergeBlocks.apply(Fragment.make(headBlock), false);
    5356
    5457            Pythonater.apply(symbolTable, headCollector, headBlock);
Note: See TracChangeset for help on using the changeset viewer.