Changeset 3844


Ignore:
Timestamp:
Apr 22, 2014, 3:40:05 PM (3 years ago)
Author:
ksherdy
Message:

Minor cleanup.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2S2K/TranslateForeachStmtsToWhileStmts.java

    r3840 r3844  
    1212 * 'foreach' '(' indexStreamDeclList ')' 'in' '(' targetStreamDeclList ')'
    1313 * '{'
    14  *              stmt *
     14 *    stmt*
    1515 * '}'
    1616 *
    17  *  ==>         
     17 *  ==>         
    1818 * 
    19  *  varDeclInitStmts   
    20  *  'while' '(' condition ')'
    21  *  '{'
    22  *      stmt *
    23  *      advanceThenScanToNextStmts
    24  *  '}'
    25  *
    26  *
     19 * varDeclInitStmts   
     20 * 'while' '(' condition ')'
     21 * '{'
     22 *    stmt*
     23 *    advanceThenScanToNextStmts
     24 * '}'
     25 *
     26 * where,
     27 * 
    2728 * identifierList = StreamDeclListToIdentiferList(indexStreamDeclList)
    2829 *
    2930 * condition = MakeWhileCondition(identifierList) { 
    3031 *   if Length(identiferList) is 1 
    31  *     return Bitcast(stream<1>, Head(identifierList))
     32 *      return Bitcast(stream<1>, Head(identifierList))
    3233 *   
    33  *   condition = Head(identifierList) Or IdentifierListForeachCondition(Tail(identifierList))   
    34  *
     34 *   condition = Head(identifierList) 'Or' IdentifierListForeachCondition(Tail(identifierList))   
    3535 *   return condition
    3636 * }
    37  *
    38  *
     37 * 
    3938 * varDeclInitStmts = MakeIndexStreamDeclInitStmts(indexStreamDeclList,targetStreamDeclList) {
    40  *    stmts = []
    41  *    for i = 1 to Length(indexStreamDeclStmt) do
    42  *      Append(list, MakeVarDeclInit(indexStreamDecl[i],
    43  *                                                                      MakeFunctionCall('flow.ScanToFirst', GetIdentifier(targetStreamDeclList[i]))))
    44  *    return stmts
     39 *   stmts = []
     40 *   for i = 1 to Length(indexStreamDeclStmt) do
     41 *     Append(stmts, MakeVarDeclInit(indexStreamDecl[i],
     42 *                   MakeFunctionCall('flow.ScanToFirst', GetIdentifier(targetStreamDeclList[i]))))
     43 *   return stmts
    4544 * }
    46  *
    47  *     
     45 *     
    4846 * advanceThenScanToNextStmts = MakeAdvanceThenScanToNextAssignStmts(indexStreamDeclList,targetStreamDeclList) {
    49  *    stmts = []
    50  *    for i = 1 to Length(indexStreamDeclStmt) do
    51  *      Append(list, MakeAssignmentStmt(indexStreamDeclList[i],
    52  *                                                                      MakeFuncCall('flow.AdvanceThenScanToNext',
    53  *                                                                                      GetIdentifier(indexStreamDeclList[i]),
    54  *                                                  GetIdentifier(targetStreamDeclList[i]))))
    55  *    return stmts
     47 *   stmts = []
     48 *   for i = 1 to Length(indexStreamDeclStmt) do
     49 *     Append(stmts, MakeAssignmentStmt(indexStreamDeclList[i],
     50 *                   MakeFuncCall('flow.AdvanceThenScanToNext',
     51 *                   GetIdentifier(indexStreamDeclList[i]),
     52 *                   GetIdentifier(targetStreamDeclList[i]))))
     53 *   return stmts
    5654 * }
    5755 *
     
    7674
    7775public class TranslateForeachStmtsToWhileStmts {
    78        
    79         static public ASTNode apply(ASTNode ASTree) {
    80                 XFormer xformer = new XFormer();
    81                 ASTree.accept(xformer);
    82                 return ASTree;                          // root ASTree does not change
    83         }   
     76       
     77       static public ASTNode apply(ASTNode ASTree) {
     78              XFormer xformer = new XFormer();
     79              ASTree.accept(xformer);
     80               return ASTree;                            // root ASTree does not change
     81       }   
    8482
    8583   
    86        
     84       
    8785    static private class XFormer extends VoidVisitor.Default {
    88        
    89         public void visitEnter(ForeachStmtNode node) {
    90                
    91                 assertPreconditions(node);
    92                
    93                 StreamDeclListNode streamDeclListNode   = Accessors.indexStreamDeclList(node);
    94                 StreamDeclListNode targetDeclListNode   = Accessors.targetStreamDeclList(node);
    95 
    96                 List<VarDeclNode> declInitStmts = makeIndexStreamDeclInitStmts(streamDeclListNode, targetDeclListNode);
    97                
    98                 prependVarDeclInitStmts(node, declInitStmts);
    99                        
    100                         List<IdentifierNode> indexStreamIdentifiers = Accessors.indexStreamDeclIdentifierList(node);
    101                         ASTNode condition = makeWhileCondition(indexStreamIdentifiers);
    102                        
    103                         BlockStmtNode body = Accessors.body(node);
    104                         List<AssignNode> advanceThenScanToNextStmts = MakeAdvanceThenScanToNextAssignStmts(streamDeclListNode,  targetDeclListNode);
    105                         appendAdvanceThenScanToAssignStmts(body, advanceThenScanToNextStmts);
    106                        
    107                         WhileStmtNode replacement = Generators.makeWhileStmtNode(node.getLocation(), condition, body);
    108                         // System.out.println(condition);
    109                         node.updateSelf(replacement);
    110                        
    111         }
    112 
    113         // KH: move to semantic analysis pass
    114                 private void assertPreconditions(ForeachStmtNode node) {
    115                         assert Accessors.indexStreamDeclList(node).nChildren() != 0;
    116                 assert Accessors.indexStreamDeclList(node).nChildren() == Accessors.targetStreamDeclList(node).nChildren();
    117                
    118                 ListIterator<ASTNode> indexStreamDeclsIterator  = Accessors.indexStreamDeclList(node).getChildren().listIterator();
    119                 ListIterator<ASTNode> targetStreamDeclsIterator = Accessors.targetStreamDeclList(node).getChildren().listIterator();
    120                
    121                 while(indexStreamDeclsIterator.hasNext() && targetStreamDeclsIterator.hasNext()) {
    122                        
    123                         ASTNode indexStreamType         = Accessors.streamDeclType((StreamDeclNode) indexStreamDeclsIterator.next());
    124                         ASTNode targetStreamType        = Accessors.streamDeclType((StreamDeclNode) targetStreamDeclsIterator.next());
    125 
    126                         assert indexStreamType instanceof StreamTypeNode;
    127                         assert targetStreamType instanceof StreamTypeNode;
    128                         assert ((StreamTypeNode)indexStreamType).getFieldWidth() == 1;
    129                         assert ((StreamTypeNode)targetStreamType).getFieldWidth() == 1;
    130                 }
    131                 }
    132                
     86           
     87            public void visitEnter(ForeachStmtNode node) {
     88                   
     89               assertPreconditions(node);
     90               
     91               StreamDeclListNode streamDeclListNode        = Accessors.indexStreamDeclList(node);
     92               StreamDeclListNode targetDeclListNode        = Accessors.targetStreamDeclList(node);
     93
     94               List<VarDeclNode> declInitStmts = makeIndexStreamDeclInitStmts(streamDeclListNode, targetDeclListNode);
     95               
     96               prependVarDeclInitStmts(node, declInitStmts);
     97                     
     98               List<IdentifierNode> indexStreamIdentifiers = Accessors.indexStreamDeclIdentifierList(node);
     99               ASTNode condition = makeWhileCondition(indexStreamIdentifiers);
     100                     
     101               BlockStmtNode body = Accessors.body(node);
     102               List<AssignNode> advanceThenScanToNextStmts = MakeAdvanceThenScanToNextAssignStmts(streamDeclListNode,       targetDeclListNode);
     103               appendAdvanceThenScanToAssignStmts(body, advanceThenScanToNextStmts);
     104                     
     105               WhileStmtNode replacement = Generators.makeWhileStmtNode(node.getLocation(), condition, body);
     106               node.updateSelf(replacement);
     107                     
     108            }
     109
     110            // KH: move to semantic analysis pass
     111            private void assertPreconditions(ForeachStmtNode node) {
     112                     assert Accessors.indexStreamDeclList(node).nChildren() != 0;
     113                     assert Accessors.indexStreamDeclList(node).nChildren() == Accessors.targetStreamDeclList(node).nChildren();
     114               
     115                     ListIterator<ASTNode> indexStreamDeclsIterator  = Accessors.indexStreamDeclList(node).getChildren().listIterator();
     116                     ListIterator<ASTNode> targetStreamDeclsIterator = Accessors.targetStreamDeclList(node).getChildren().listIterator();
     117               
     118                     while(indexStreamDeclsIterator.hasNext() && targetStreamDeclsIterator.hasNext()) {
     119                     
     120                         ASTNode indexStreamType  = Accessors.streamDeclType((StreamDeclNode) indexStreamDeclsIterator.next());
     121                         ASTNode targetStreamType = Accessors.streamDeclType((StreamDeclNode) targetStreamDeclsIterator.next());
     122
     123                         assert indexStreamType instanceof StreamTypeNode;
     124                         assert targetStreamType instanceof StreamTypeNode;
     125                         assert ((StreamTypeNode)indexStreamType).getFieldWidth() == 1;
     126                         assert ((StreamTypeNode)targetStreamType).getFieldWidth() == 1;
     127                     }
     128              }
     129             
    133130        private List<VarDeclNode> makeIndexStreamDeclInitStmts(StreamDeclListNode indexStreamDeclListNode,
    134                                                                                                 StreamDeclListNode targetStreamDeclListNode) {
    135                
    136                         List<VarDeclNode> varDecls = new ArrayList<VarDeclNode>();
    137                        
    138                         ListIterator<ASTNode> indexStreamIterator  = indexStreamDeclListNode.getChildren().listIterator();
    139                         ListIterator<ASTNode> targetStreamIterator = targetStreamDeclListNode.getChildren().listIterator();
    140                        
    141                         while(indexStreamIterator.hasNext() && targetStreamIterator.hasNext()) {
    142                        
    143                                 ASTNode indexStreamDecl                 = indexStreamIterator.next().deepCopy();
    144                                 ASTNode targetStreamDecl                = targetStreamIterator.next().deepCopy();
    145                                
    146                                 StreamTypeNode indexStreamType                  = Accessors.streamDeclType((StreamDeclNode)indexStreamDecl);
    147                                 IdentifierNode indexStreamIdentifier    = Accessors.identifier((StreamDeclNode)indexStreamDecl);
    148                                 IdentifierNode targetStreamIdentifier   = Accessors.identifier((StreamDeclNode)targetStreamDecl);
    149                                 Locator locator                                                 = indexStreamDecl.getLocation();
    150                        
    151                         IdentifierNode  lhs     = indexStreamIdentifier.deepCopy();
    152                         FuncCallNode    rhs     = Generators.makeFuncCallNode(locator,
    153                                                                                                                         S2KBuiltins.FLOW_SCAN_TO_FIRST.packageName(),
    154                                                                                                                         S2KBuiltins.FLOW_SCAN_TO_FIRST.baseName(),
    155                                                                                                                         targetStreamIdentifier);
    156                                                        
    157                                 VarDeclNode varDecl = Generators.makeVarDeclNode(locator, indexStreamType, lhs, rhs);
    158                                
    159                                 varDecls.add(varDecl);
    160                         }
    161                        
    162                         return varDecls;
    163                
    164         }
    165         
     131                                                                                     StreamDeclListNode targetStreamDeclListNode) {
     132               
     133                     List<VarDeclNode> varDecls = new ArrayList<VarDeclNode>();
     134                     
     135                     ListIterator<ASTNode> indexStreamIterator  = indexStreamDeclListNode.getChildren().listIterator();
     136                     ListIterator<ASTNode> targetStreamIterator = targetStreamDeclListNode.getChildren().listIterator();
     137                     
     138                     while(indexStreamIterator.hasNext() && targetStreamIterator.hasNext()) {
     139                     
     140                            ASTNode indexStreamDecl                     = indexStreamIterator.next().deepCopy();
     141                            ASTNode targetStreamDecl                    = targetStreamIterator.next().deepCopy();
     142                           
     143                            StreamTypeNode indexStreamType              = Accessors.streamDeclType((StreamDeclNode)indexStreamDecl);
     144                            IdentifierNode indexStreamIdentifier        = Accessors.identifier((StreamDeclNode)indexStreamDecl);
     145                            IdentifierNode targetStreamIdentifier       = Accessors.identifier((StreamDeclNode)targetStreamDecl);
     146                            Locator locator                                           = indexStreamDecl.getLocation();
     147                     
     148                            IdentifierNode lhs                          = indexStreamIdentifier.deepCopy();
     149                            FuncCallNode rhs                            = Generators.makeFuncCallNode(locator,
     150                                                                                                          S2KBuiltins.FLOW_SCAN_TO_FIRST.packageName(),
     151                                                                                                             S2KBuiltins.FLOW_SCAN_TO_FIRST.baseName(),
     152                                                                                                             targetStreamIdentifier);
     153                                                 
     154                            VarDeclNode varDecl = Generators.makeVarDeclNode(locator, indexStreamType, lhs, rhs);
     155                           
     156                            varDecls.add(varDecl);
     157                     }
     158                     
     159                     return varDecls;
     160               
     161        }
     162            
    166163        private ASTNode makeWhileCondition(List<IdentifierNode> indexStreamIdentifiers) {
    167                
    168                 if (indexStreamIdentifiers.size() == 1) {
    169                         return indexStreamIdentifiers.get(0);
    170                 }
    171                
    172                 ASTNode lhs = indexStreamIdentifiers.get(0);
    173                 ASTNode rhs = makeWhileCondition(indexStreamIdentifiers.subList(1, indexStreamIdentifiers.size()));
    174                
    175                 ASTNode condition = Generators.makeBinaryOperatorNode(lhs, rhs, Generators.makeLextantToken(lhs.getLocation(), Lextant.OR));
    176                
    177                 return condition;
     164               
     165               if (indexStreamIdentifiers.size() == 1) { return indexStreamIdentifiers.get(0); }
     166               
     167               ASTNode lhs = indexStreamIdentifiers.get(0);
     168               ASTNode rhs = makeWhileCondition(indexStreamIdentifiers.subList(1, indexStreamIdentifiers.size()));
     169               ASTNode condition = Generators.makeBinaryOperatorNode(lhs, rhs, Generators.makeLextantToken(lhs.getLocation(), Lextant.OR));
     170               
     171               return condition;
    178172        }
    179173       
    180174        private List<AssignNode> MakeAdvanceThenScanToNextAssignStmts(StreamDeclListNode indexStreamDeclList,
    181                                                                                                                                                         StreamDeclListNode targetStreamDeclList) {
    182                                
    183                 List<AssignNode> list = new ArrayList<AssignNode>();
    184                
    185                         ListIterator<ASTNode> indexStreamIterator  = indexStreamDeclList.getChildren().listIterator();
    186                         ListIterator<ASTNode> targetStreamIterator = targetStreamDeclList.getChildren().listIterator();
    187                
    188                 while(indexStreamIterator.hasNext() && targetStreamIterator.hasNext()) {
    189                        
    190                         ASTNode indexStreamDecl                 = indexStreamIterator.next().deepCopy();
    191                                 ASTNode targetStreamDecl                = targetStreamIterator.next().deepCopy();
    192                        
    193                         IdentifierNode indexStream      = Accessors.identifier((StreamDeclNode)indexStreamDecl);
    194                         IdentifierNode targetStream     = Accessors.identifier((StreamDeclNode)targetStreamDecl);
    195                                 Locator locator                                 = indexStreamDecl.getLocation();
    196                                
    197                         IdentifierNode  lhs     = indexStream.deepCopy();
    198                         FuncCallNode    rhs     = Generators.makeFuncCallNode(indexStream.getLocation(),
    199                                                                                                                         S2KBuiltins.FLOW_ADVANCE_THEN_SCAN_TO.packageName(),
    200                                                                                                                         S2KBuiltins.FLOW_ADVANCE_THEN_SCAN_TO.baseName(),
    201                                                                                                                         indexStream,
    202                                                                                                                     targetStream);
    203                        
    204                         AssignNode assign = Generators.makeAssignNode(locator, lhs, rhs);
    205                         list.add(assign);
    206                 }
    207 
    208                 return list;
     175                                                                                                                                      StreamDeclListNode targetStreamDeclList) {
     176                             
     177               List<AssignNode> list = new ArrayList<AssignNode>();
     178               
     179                     ListIterator<ASTNode> indexStreamIterator  = indexStreamDeclList.getChildren().listIterator();
     180                     ListIterator<ASTNode> targetStreamIterator = targetStreamDeclList.getChildren().listIterator();
     181               
     182               while(indexStreamIterator.hasNext() && targetStreamIterator.hasNext()) {
     183                     
     184                      ASTNode indexStreamDecl            = indexStreamIterator.next().deepCopy();
     185                      ASTNode targetStreamDecl           = targetStreamIterator.next().deepCopy();
     186                     
     187                      IdentifierNode indexStream         = Accessors.identifier((StreamDeclNode)indexStreamDecl);
     188                      IdentifierNode targetStream        = Accessors.identifier((StreamDeclNode)targetStreamDecl);
     189                      Locator locator                    = indexStreamDecl.getLocation();
     190                           
     191                      IdentifierNode lhs                 = indexStream.deepCopy();
     192                      FuncCallNode rhs                   = Generators.makeFuncCallNode(indexStream.getLocation(),
     193                                                                                                          S2KBuiltins.FLOW_ADVANCE_THEN_SCAN_TO.packageName(),
     194                                                                                                             S2KBuiltins.FLOW_ADVANCE_THEN_SCAN_TO.baseName(),
     195                                                                                                             indexStream,
     196                                                                                                          targetStream);
     197                     
     198                      AssignNode assign = Generators.makeAssignNode(locator, lhs, rhs);
     199                      list.add(assign);
     200               }
     201
     202               return list;
    209203        }
    210204       
    211205        private void prependVarDeclInitStmts(ForeachStmtNode node,
    212                                 List<VarDeclNode> declInitStmts) {
    213                         for(VarDeclNode assignStmt : declInitStmts) {
    214                                 node.insertBeforeSelf(assignStmt);
    215                         }
    216                 }
     206                            List<VarDeclNode> declInitStmts) {
     207                     for(VarDeclNode assignStmt : declInitStmts) {
     208                            node.insertBeforeSelf(assignStmt);
     209                     }
     210              }
    217211       
    218                 private void appendAdvanceThenScanToAssignStmts(BlockStmtNode body,
    219                                 List<AssignNode> advanceThenScanToNextStmts) {
    220                         for(AssignNode assignStmt : advanceThenScanToNextStmts) {
    221                                 body.appendChild(assignStmt);
    222                         }
    223                 }
    224         }
     212        private void appendAdvanceThenScanToAssignStmts(BlockStmtNode body,
     213                            List<AssignNode> advanceThenScanToNextStmts) {
     214                     for(AssignNode assignStmt : advanceThenScanToNextStmts) {
     215                            body.appendChild(assignStmt);
     216                     }
     217        }
     218    }
    225219}
Note: See TracChangeset for help on using the changeset viewer.