Changeset 3380 for proto


Ignore:
Timestamp:
Jul 3, 2013, 1:56:31 PM (6 years ago)
Author:
ksherdy
Message:

Partial check in marked for reversion. Progress towards S->S, S->B, B->B translation. Added rudimentary AdvanceN implementation.

Location:
proto/pabloj/trunk/src/toolchain/pabloS
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltinTranslator.java

    r3379 r3380  
    77
    88
     9import java.util.ArrayList;
    910import java.util.List;
    1011
     
    4344            ASTNode pabloBlkFuncCall = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, pabloBlkFuncCallArgs);
    4445           
    45             ASTNode immediatValue       = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
    46            
    47            
    48             return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, immediatValue, pabloBlkFuncCall);
     46            ASTNode srliValue       = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
     47           
     48           
     49            return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, srliValue, pabloBlkFuncCall);
    4950                }
    5051        },
    5152
    5253        ADVANCEN_TRANSLATION {
    53                 public void translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Counter counter, Context context, pabloS.ast.ASTNode returnValue) {
    54                     pabloS.ast.ASTNode formatValue = toolchain.pabloS.ast.Accessors.argument(snode, 1);
     54                public ASTNode translate(PabloSBuiltin builtin, pabloS.ast.FuncCallNode snode, Context context, List<ASTNode> childResults, int carryNPosition) {
     55                    Locator locator = Generators.makeToken(snode.getToken());
     56                       
     57                        pabloS.ast.ASTNode formatValue = toolchain.pabloS.ast.Accessors.argument(snode, 1);
    5558                    String value = toolchain.pabloS.ast.Accessors.lexeme(formatValue);
    56                     List<pabloS.ast.ASTNode> arguments = removeAdvanceNConstantArg(snode);
    57 
    5859                    String templateCode = context.getCode(builtin);
    59                     String formattedAdvanceN = String.format(templateCode, value);         
    60                     pabloS.inputHandler.Locator locator = snode;
    61 
     60                    String pabloBlkCallFuncName = String.format(templateCode, value);         
     61           
     62            ASTNode getCarryCall = Generators.makePending64Call(locator, carryNPosition, context);
     63            ASTNode returnValue = childResults.get(0);
     64            ASTNode[] pabloBlkFuncCallArgs = makePabloBlkArgs(locator, removeAdvanceNConstantArg(childResults), getCarryCall, returnValue);
     65           
     66            ASTNode pabloBlkFuncCall = Generators.makeFuncCallNode(locator, pabloBlkCallFuncName, pabloBlkFuncCallArgs);
     67            ASTNode srliValue       = Generators.makeIntegerConstantNode(locator, BITBLOCK_SIZE - 1);
    6268                   
    63                    
    64 //                  makePabloBlkFuncCall(snode,
    65 //                          formattedAdvanceN,
    66 //                          arguments,
    67 //                          toolchain.pabloS.ast.Generators.makeGetCallCarryForBuiltin(locator, builtin, counter.value(), context), 
    68 //                          returnValue);
    69 
     69                    return Generators.makeIdisaFuncCallNode(locator, BITBLOCK_SRLI, BITBLOCK_SIZE, srliValue, pabloBlkFuncCall);
    7070                }
    7171
    72         private List<pabloS.ast.ASTNode> removeAdvanceNConstantArg(pabloS.ast.FuncCallNode node) {
    73             List<pabloS.ast.ASTNode> arguments = toolchain.pabloS.ast.Accessors.argsList(node);
    74                     arguments.remove(arguments.size()-1);
    75             return arguments;
     72        private List<ASTNode> removeAdvanceNConstantArg(List<ASTNode> childResults) {
     73                List<ASTNode> args = new ArrayList<ASTNode>();
     74                for(int i=0; i<childResults.size(); i++) {
     75                        args.add(childResults.get(i));
     76                }
     77            return args;
    7678        }
    7779        },
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/InfoSetMap.java

    r3379 r3380  
    6969        public void visitLeave(FuncCallNode node) {
    7070           
    71             PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition); // next values
    7271           
    73             if(BuiltinCallUtil.isCarry1(node)) {
    74                 carry1Position += 1;
    75             } else if (BuiltinCallUtil.isCarryN(node)) {
    76                 carryNPosition += 1;
     72           
     73            if(BuiltinCallUtil.isCarry(node)) {
     74
     75                PropertyInfoSet propInfoSet = new PropertyInfoSet(carry1Position, carryNPosition); // next values
     76                infoSetMap.put(node, propInfoSet);
     77
     78                if(BuiltinCallUtil.isCarry1(node)) {
     79                        carry1Position += 1;
     80                } else if (BuiltinCallUtil.isCarryN(node)) {
     81                       
     82                        System.out.println("CarryN node");
     83                        System.out.println(node);
     84                       
     85                        carryNPosition += 1;
     86                }
     87
    7788            }
    78            
    79             infoSetMap.put(node, propInfoSet);
    8089        }
    8190        }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/infoSet/PropertyInfoSet.java

    r3376 r3380  
    2626
    2727    public PropertyInfoSet(int carry1Position, int carryNPosition, int carry1Count, int carryNCount, int lookAhead, int lookBehind) { 
    28         this.setCarry1Position(carry1Position);
    29         this.setCarryNPosition(carryNPosition);
    30         this.setCarry1Count(carry1Count);
    31         this.setCarryNCount(carryNCount);
    32         this.setLookAhead(lookAhead);
    33         this.setLookBehind(lookBehind);
    34         this.setCarry1InitialValues(new ArrayList<Integer>());
     28        this.carry1Position(carry1Position);
     29        this.carryNPosition(carryNPosition);
     30        this.carry1Count(carry1Count);
     31        this.carryNCount(carryNCount);
     32        this.lookAhead(lookAhead);
     33        this.lookBehind(lookBehind);
     34        this.carry1InitialValues(new ArrayList<Integer>());
    3535    }
    3636   
    37     public void setCarry1Init(int index, int element) {
    38         getCarry1InitialValues().set(index, element);
     37    public void carry1Init(int index, int element) {
     38        carry1InitialValues().set(index, element);
    3939    }
    4040
     
    4343    }
    4444
    45     private void setCarry1Position(int carry1Position) {
     45    private void carry1Position(int carry1Position) {
    4646        this.carry1Position = carry1Position;
    4747    }
    4848
    49     public int getCarry1Count() {
     49    public int carry1Count() {
    5050        return carry1Count;
    5151    }
    5252
    53     private void setCarry1Count(int carry1Count) {
     53    private void carry1Count(int carry1Count) {
    5454        this.carry1Count = carry1Count;
    5555    }
    5656   
    57     public int getCarryNPosition() {
     57    public int carryNPosition() {
    5858        return carryNPosition;
    5959    }
    6060
    61     public void setCarryNPosition(int carryNPosition) {
     61    public void carryNPosition(int carryNPosition) {
    6262        this.carryNPosition = carryNPosition;
    6363    }
    6464
    65     public int getCarryNCount() {
     65    public int carryNCount() {
    6666        return carryNCount;
    6767    }
    6868
    69     public void setCarryNCount(int carryNCount) {
     69    public void carryNCount(int carryNCount) {
    7070        this.carryNCount = carryNCount;
    7171    }
    7272
    73     public int getLookAhead() {
     73    public int lookAhead() {
    7474        return lookAhead;
    7575    }
    7676
    77     public void setLookAhead(int lookAhead) {
     77    public void lookAhead(int lookAhead) {
    7878        this.lookAhead = lookAhead;
    7979    }
    8080
    81     public int getLookBehind() {
     81    public int lookBehind() {
    8282        return lookBehind;
    8383    }
    8484
    85     public void setLookBehind(int lookBehind) {
     85    public void lookBehind(int lookBehind) {
    8686        this.lookBehind = lookBehind;
    8787    }
    8888   
    89     public ArrayList<Integer> getCarry1InitialValues() {
     89    public ArrayList<Integer> carry1InitialValues() {
    9090        return carry1InitialValues;
    9191    }
    9292
    93     private void setCarry1InitialValues(ArrayList<Integer> carry1InitialValues) {
     93    private void carry1InitialValues(ArrayList<Integer> carry1InitialValues) {
    9494        this.carry1InitialValues = carry1InitialValues;
    9595    }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/pabloS2PabloB/PabloS2PabloBXFormer.java

    r3379 r3380  
    6565        // Prepare
    6666        Map<pabloS.ast.ASTNode, PropertyInfoSet> infoSetMap = InfoSetMap.forTree(sASTree);
    67         Map<pabloS.ast.ASTNode, PropertyInfoSet> finalInfoSetMap = InfoSetMap.forTree(sASTree);
     67        Map<pabloS.ast.ASTNode, PropertyInfoSet> finalInfoSetMap = InfoSetMap.forTree(sFinalASTree);
    6868
    6969        ASTNode ASTree          = sASTree.accept(new ASTBuilder(infoSetMap,false));        // TODO - KH: context object stuff, property info set, ...
     
    362362        public ASTNode visitLeave(pabloS.ast.AssignNode snode, List<ASTNode> childResults) {
    363363
    364             pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
    365 
    366             if(BuiltinCallUtil.isCarry1(rhs)) {
    367                
    368                     int carry1Position = 0;
    369                     try {
    370                         carry1Position = infoSetMap.get(rhs).carry1Position();
    371                     } catch (Exception e) {
    372                         // TODO Auto-generated catch block
    373                         System.out.println(rhs);
    374                     }
    375                    
    376                    
    377                     Locator locator = Generators.makeToken(snode.getToken());
    378                     ASTNode getCarryCall = Generators.makeGetCarryCall(locator, carry1Position, context);
    379                     ASTNode lhs = childResults.get(0);
    380                     getCarryCall.appendChild(lhs);
    381                    
    382                     PabloSBuiltin builtin = BuiltinCallUtil.builtin(rhs);
    383                     PabloSBuiltinTranslator translator = builtin.getTranslator();
    384                     ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, childResults, carry1Position);
    385                    
    386                    
    387                    
    388                     ASTNode replacement = Generators.makeAssignNode(locator, getCarryCall, pabloBlkFuncCall);
    389                    
    390                     System.out.println(replacement);
    391 
    392                     return replacement;
    393  
    394             }
    395            
    396             ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
    397             appendChildResults(replacement, childResults);
    398             return replacement;
    399         }   
     364                pabloS.ast.ASTNode rhs = toolchain.pabloS.ast.Accessors.rhs(snode);
     365
     366                if(BuiltinCallUtil.isCarry(rhs)) {
     367
     368                        int carryPosition = 0;
     369
     370                        if(BuiltinCallUtil.isCarry1(rhs)) {
     371                                try {
     372                                                carryPosition = infoSetMap.get(rhs).carry1Position();
     373                                        } catch (Exception e) {
     374                                                //System.out.println(rhs);
     375                                        }
     376                        } else if(BuiltinCallUtil.isCarryN(rhs)) {
     377                               
     378                                if(!infoSetMap.containsKey(rhs)) {
     379                                        System.out.println("Not found.");
     380                                } else {
     381                                        System.out.println("Found.");
     382                                }
     383                                //try {
     384                                                carryPosition = infoSetMap.get(rhs).carryNPosition();
     385                                        //} catch (Exception e) {
     386                                               
     387                                                System.out.println(carryPosition);
     388                                               
     389                                                System.out.println("N");
     390                                                System.out.println(rhs);
     391                                        //}
     392                        }
     393
     394                        Locator locator = Generators.makeToken(snode.getToken());
     395                        ASTNode getCarryCall = Generators.makeGetCarryCall(locator, carryPosition, context);
     396                        ASTNode lhs = childResults.get(0);
     397                        getCarryCall.appendChild(lhs);
     398
     399                        PabloSBuiltin builtin = BuiltinCallUtil.builtin(rhs);
     400                        PabloSBuiltinTranslator translator = builtin.getTranslator();
     401                        ASTNode pabloBlkFuncCall = translator.translate(builtin, (pabloS.ast.FuncCallNode) rhs, context, childResults, carryPosition);
     402
     403                        ASTNode replacement = Generators.makeAssignNode(locator, getCarryCall, pabloBlkFuncCall);
     404
     405                        return replacement;
     406
     407                } 
     408       
     409        ASTNode replacement  = new AssignNode(Generators.makeToken(snode.getToken()));
     410        appendChildResults(replacement, childResults);
     411        return replacement;
     412    }   
    400413   
    401414    private static void surroundConditionWithBitBlockAny(ASTNode node, ASTNode condition) {
Note: See TracChangeset for help on using the changeset viewer.