source: proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/Bitwise2IDISAXFormer.java @ 2952

Last change on this file since 2952 was 2952, checked in by ksherdy, 5 years ago

Restructed PabloJ compile to provide clear separation between PabloS and PabloB.

File size: 5.7 KB
Line 
1/*
2 * Transforms bitwise operations to IDISA operations.
3 *
4 * Transforms expressions to BitBlock::any(expr). BitBlock:any expects stream<1> type.
5 *
6 * TODO
7 *
8 * - Move to PabloB.
9 * - Remove transformation of integer constants to simd::constant<1>(0)
10 *
11 * @author Ken Herdy <ksherdy at sfu dot ca>
12 */
13
14package compilers.pabloS.semanticAnalyzer.visitors;
15
16import pabloS.ast.*;
17import pabloS.lexicalAnalyzer.Lextant;
18import pabloS.tokens.Token;
19
20import compilers.pabloB.lang.idisa.BitBlock;
21import compilers.pabloB.lang.idisa.SIMD;
22import compilers.pabloS.ast.Accessors;
23import compilers.pabloS.ast.Generators;
24
25public class Bitwise2IDISAXFormer {
26        private ASTNode ASTTree;
27       
28        public Bitwise2IDISAXFormer(ASTNode ASTree) {
29                this.ASTTree = ASTree;
30        }
31       
32        public ASTNode XForm() { 
33               
34                Bitwise2IDISABinaryOperatorXFormer binOpXformer = new Bitwise2IDISABinaryOperatorXFormer();
35                ASTTree.accept(binOpXformer);
36               
37                Bitwise2IDISAUnaryOperatorXFormer unOpXFormer = new Bitwise2IDISAUnaryOperatorXFormer();
38                ASTTree.accept(unOpXFormer);
39               
40                Bitwise2IDISAGeneralXFormer xFormer = new Bitwise2IDISAGeneralXFormer();
41                ASTTree.accept(xFormer);
42               
43                return ASTTree;
44        }
45       
46        private class Bitwise2IDISABinaryOperatorXFormer extends VoidVisitor.Default {
47
48                public void visitLeave(BinaryOperatorNode node) {
49                        Token token = node.getToken();
50                       
51                        if(token.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
52                                FuncCallNode funcCallNode = null;
53                                if(token.isLextant(Lextant.OR)) {
54                                        funcCallNode = Generators.makeFuncCallNode(SIMD.OR.IDISALexeme(), 
55                                                                                                                                token, 
56                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
57                                } else if(token.isLextant(Lextant.AND)) {
58                                       
59                                        if (Accessors.rhs(node).getToken().isLextant(Lextant.NOT)) {                                           
60                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(), 
61                                                                                                                                        token, 
62                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node).child(0)});
63                                        } else if(Accessors.lhs(node).getToken().isLextant(Lextant.NOT)) {
64                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.IDISALexeme(), 
65                                                                                                                                        token, 
66                                                                                                                                        new ASTNode [] {Accessors.rhs(node), Accessors.lhs(node).child(0)});
67                                        } else { 
68                                                funcCallNode = Generators.makeFuncCallNode(SIMD.AND.IDISALexeme(), 
69                                                                                                                                        token, 
70                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});                                             
71                                        }
72                                       
73                                } else if (token.isLextant(Lextant.XOR)){
74                                        funcCallNode = Generators.makeFuncCallNode(SIMD.XOR.IDISALexeme(), 
75                                                                                                                                token, 
76                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
77                                }
78                               
79                                //funcCallNode.setParent(node.getParent());
80                                //node = (BinaryOperatorNode)funcCallNode;
81                               
82                                node.updateSelf(funcCallNode);
83                               
84                                //System.out.println(funcCallNode);
85                               
86                        }               
87                       
88                }
89        }       
90
91        private class Bitwise2IDISAUnaryOperatorXFormer extends VoidVisitor.Default {
92                public void visitLeave(UnaryOperatorNode node) {
93                        Token op = node.getToken();
94                        if(op.isLextant(Lextant.NOT)) {
95
96                                FuncCallNode FuncCallNode = 
97                                                Generators.makeFuncCallNode(SIMD.NOT.IDISALexeme(), 
98                                                                                                                                op,
99                                                                                                                                new ASTNode [] {Accessors.operand(node)});                     
100                                node.updateSelf(FuncCallNode);
101                        }
102                }               
103        }       
104       
105        private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
106                /*
107                public void visitLeave(IntegerConstantNode node) {
108                        String name;
109                        int constantValue = ((IntegerConstantNode)(node)).getValue();
110                       
111                        if(constantValue == 0 || constantValue == -1) {
112                               
113                                int fieldWidth = 1;
114                                int constant = -1 * constantValue;
115                               
116                                name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
117                                FuncCallNode FuncCallNode = Generators.makeFuncCallNode(name, node.getToken());
118                                node.updateSelf(FuncCallNode);
119                        }
120                }
121                */
122               
123                /*
124                public void visitLeave(LocalVarDeclNode node) {
125                        if(Accessors.hasInitializationAssign(node)) {
126                                ASTNode rhs = Accessors.rhs(node);
127                                integerConstant2IDISA(node, rhs);
128                        }
129                }
130                */
131               
132                /*
133                public void visitLeave(StreamConstantNode node) {
134                        streamConstant2IDISA(node);
135                }
136                */
137               
138                /*
139                private void streamConstant2IDISA(ASTNode node) {                       
140                        if(node instanceof StreamConstantNode) {
141                       
142                                int value = ((StreamConstantNode) node).getValue();
143                               
144                                if(value == 0 || value == -1) {
145                                       
146                                        int fieldWidth = 1;
147                                        int constant = -1 * value;
148                                       
149                                        String name = SIMD.CONSTANT.IDISAConstantLexeme(Integer.toString(fieldWidth), Integer.toString(constant));
150                                        FuncCallNode funcCallNode = Generators.makeFuncCallNode(name, node.getToken());
151                                        node.updateSelf(funcCallNode);
152                                }
153                        }
154                }
155                */             
156               
157//          def visit_If_Node(self, ifNode):
158//        self.generic_visit(ifNode)
159//        ifNode.test = makeCall('bitblock::any', [ifNode.test])
160//        return ifNode         
161                public void visitLeave(IfStmtNode node) {
162                        ASTNode ifTest = Accessors.ifTest(node);                       
163                        String FuncName = BitBlock.ANY.IDISALexeme();
164                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest}); 
165                        node.replaceChild(ifTest, FuncCallNode);
166                }
167               
168//          def visit_While_Node(self, whileNode):
169//              self.generic_visit(whileNode)
170//              whileNode.test = makeCall('bitblock::any', [whileNode.test])
171//              return whileNode
172                public void visitLeave(WhileStmtNode node) {
173                        ASTNode whileTest = Accessors.whileTest(node);                 
174                                                                                                                               
175                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
176                                        BitBlock.ANY.IDISALexeme(), 
177                                        node.getToken(), 
178                                        new ASTNode [] {whileTest});                           
179                       
180                        node.replaceChild(whileTest, FuncCallNode);
181                }
182        }
183}
184
Note: See TracBrowser for help on using the repository browser.