source: proto/pablo/src/compiler/backend/visitors/Bitwise2IDISAXFormer.java @ 2710

Last change on this file since 2710 was 2710, checked in by ksherdy, 6 years ago

General refactoring.

File size: 5.1 KB
Line 
1package compiler.backend.visitors;
2
3import ast.*;
4import lexicalAnalyzer.Lextant;
5import tokens.Token;
6import compiler.ast.Accessors;
7import compiler.ast.Generators;
8import compiler.lang.idisa.*;
9
10public class Bitwise2IDISAXFormer {
11        private ASTNode ASTTree;
12       
13        public Bitwise2IDISAXFormer(ASTNode ASTree) {
14                this.ASTTree = ASTree;
15        }
16       
17        public ASTNode XForm() { // Order AST tranversal Binary <- Unary <- General
18               
19                Bitwise2IDISABinaryOperatorXFormer binOpXformer = new Bitwise2IDISABinaryOperatorXFormer();
20                ASTTree.accept(binOpXformer);
21               
22                Bitwise2IDISAUnaryOperatorXFormer unOpXFormer = new Bitwise2IDISAUnaryOperatorXFormer();
23                ASTTree.accept(unOpXFormer);
24               
25                Bitwise2IDISAGeneralXFormer xFormer = new Bitwise2IDISAGeneralXFormer();
26                ASTTree.accept(xFormer);
27               
28                return ASTTree;
29        }
30       
31        private class Bitwise2IDISABinaryOperatorXFormer extends VoidVisitor.Default {
32
33                public void visitLeave(BinaryOperatorNode node) {
34                        Token token = node.getToken();
35                        if(token.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
36                                FuncCallNode funcCallNode = null;
37                                if(token.isLextant(Lextant.OR)) {
38                                        funcCallNode = Generators.makeFuncCallNode(SIMD.OR.idisaName(), 
39                                                                                                                                token, 
40                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
41                                } else if(token.isLextant(Lextant.AND)) {
42                                       
43                                        if (Accessors.rhs(node).getToken().isLextant(Lextant.NOT)) {                                           
44                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(), 
45                                                                                                                                        token, 
46                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node).child(0)});
47                                        } else if(Accessors.lhs(node).getToken().isLextant(Lextant.NOT)) {
48                                                funcCallNode = Generators.makeFuncCallNode(SIMD.ANDC.idisaName(), 
49                                                                                                                                        token, 
50                                                                                                                                        new ASTNode [] {Accessors.rhs(node), Accessors.lhs(node).child(0)});
51                                        } else { 
52                                                funcCallNode = Generators.makeFuncCallNode(SIMD.AND.idisaName(), 
53                                                                                                                                        token, 
54                                                                                                                                        new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});                                             
55                                        }
56                                       
57                                } else if (token.isLextant(Lextant.XOR)){
58                                        funcCallNode = Generators.makeFuncCallNode(SIMD.XOR.idisaName(), 
59                                                                                                                                token, 
60                                                                                                                                new ASTNode [] {Accessors.lhs(node), Accessors.rhs(node)});
61                                }
62                               
63                                node.updateSelf(funcCallNode);
64                        }
65                }
66        }       
67
68        private class Bitwise2IDISAUnaryOperatorXFormer extends VoidVisitor.Default {
69                public void visitLeave(UnaryOperatorNode node) {
70                        Token op = node.getToken();
71                        if(op.isLextant(Lextant.NOT)) {
72
73                                FuncCallNode FuncCallNode = 
74                                                Generators.makeFuncCallNode(SIMD.NOT.idisaName(), 
75                                                                                                                                op,
76                                                                                                                                new ASTNode [] {Accessors.operand(node)});                     
77                                node.updateSelf(FuncCallNode);
78                        }
79                }               
80        }       
81       
82        private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
83                /*
84                public void visitLeave(IntegerConstantNode node) {
85                        String name;
86                        int constantValue = ((IntegerConstantNode)(node)).getValue();
87                       
88                        if(constantValue == 0 || constantValue == -1) {
89                               
90                                int fieldWidth = 1;
91                                int constant = -1 * constantValue;
92                               
93                                name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
94                                FuncCallNode FuncCallNode = Generators.makeFuncCallNode(name, node.getToken());
95                                node.updateSelf(FuncCallNode);
96                        }
97                }
98                */
99                public void visitLeave(LocalVarDeclNode node) {
100                        if(Accessors.hasInitializationAssign(node)) {
101                                ASTNode rhs = Accessors.rhs(node);
102                                integerConstant2IDISA(node, rhs);
103                        }
104                }
105
106                public void visitLeave(AssignNode node) {
107                        ASTNode rhs = Accessors.rhs(node);
108                        integerConstant2IDISA(node, rhs);
109                }
110               
111                private void integerConstant2IDISA(ASTNode node, ASTNode rhs) {
112                        if(rhs instanceof IntegerConstantNode) {
113                       
114                                int constantValue = ((IntegerConstantNode) rhs).getValue();
115                               
116                                if(constantValue == 0 || constantValue == -1) {
117                                       
118                                        int fieldWidth = 1;
119                                        int constant = -1 * constantValue;
120                                       
121                                        String name = SIMD.CONSTANT.idisaConstantName(fieldWidth, constant);
122                                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(name, node.getToken());
123                                        rhs.updateSelf(FuncCallNode);
124                                }
125                        }
126                }               
127               
128//          def visit_If_Node(self, ifNode):
129//        self.generic_visit(ifNode)
130//        ifNode.test = makeCall('bitblock::any', [ifNode.test])
131//        return ifNode         
132                public void visitLeave(IfStmtNode node) {
133                        ASTNode ifTest = Accessors.ifTest(node);                       
134                        String FuncName = BitBlock.ANY.IDISAName();
135                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(FuncName, node.getToken(), new ASTNode [] {ifTest}); 
136                        node.replaceChild(ifTest, FuncCallNode);
137                }
138               
139//          def visit_While_Node(self, whileNode):
140//              self.generic_visit(whileNode)
141//              whileNode.test = makeCall('bitblock::any', [whileNode.test])
142//              return whileNode
143                public void visitLeave(WhileStmtNode node) {
144                        ASTNode whileTest = Accessors.whileCondition(node);                     
145                                                                                                                               
146                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
147                                        BitBlock.ANY.IDISAName(), 
148                                        node.getToken(), 
149                                        new ASTNode [] {whileTest});                           
150                       
151                        node.replaceChild(whileTest, FuncCallNode);
152                }
153        }
154}
155
Note: See TracBrowser for help on using the repository browser.