001    package railo.transformer.bytecode.statement.java;
002    
003    import japa.parser.ast.body.MethodDeclaration;
004    import japa.parser.ast.body.VariableDeclaratorId;
005    import japa.parser.ast.expr.AssignExpr;
006    import japa.parser.ast.expr.BinaryExpr;
007    import japa.parser.ast.expr.BooleanLiteralExpr;
008    import japa.parser.ast.expr.CastExpr;
009    import japa.parser.ast.expr.CharLiteralExpr;
010    import japa.parser.ast.expr.DoubleLiteralExpr;
011    import japa.parser.ast.expr.IntegerLiteralExpr;
012    import japa.parser.ast.expr.IntegerLiteralMinValueExpr;
013    import japa.parser.ast.expr.LongLiteralExpr;
014    import japa.parser.ast.expr.LongLiteralMinValueExpr;
015    import japa.parser.ast.expr.NameExpr;
016    import japa.parser.ast.expr.NullLiteralExpr;
017    import japa.parser.ast.expr.ObjectCreationExpr;
018    import japa.parser.ast.expr.StringLiteralExpr;
019    import japa.parser.ast.expr.UnaryExpr;
020    import japa.parser.ast.expr.VariableDeclarationExpr;
021    import japa.parser.ast.stmt.BlockStmt;
022    import japa.parser.ast.stmt.ExpressionStmt;
023    import japa.parser.ast.stmt.IfStmt;
024    import japa.parser.ast.stmt.Statement;
025    import japa.parser.ast.type.ClassOrInterfaceType;
026    import japa.parser.ast.type.PrimitiveType;
027    import japa.parser.ast.visitor.VoidVisitorAdapter;
028    
029    import org.objectweb.asm.Label;
030    
031    import railo.commons.lang.ClassException;
032    import railo.commons.lang.ClassUtil;
033    import railo.commons.lang.StringUtil;
034    import railo.transformer.bytecode.ScriptBody;
035    import railo.transformer.bytecode.expression.Expression;
036    import railo.transformer.bytecode.expression.var.NullExpression;
037    import railo.transformer.bytecode.literal.LitBoolean;
038    import railo.transformer.bytecode.literal.LitDouble;
039    import railo.transformer.bytecode.literal.LitFloat;
040    import railo.transformer.bytecode.literal.LitInteger;
041    import railo.transformer.bytecode.literal.LitLong;
042    import railo.transformer.bytecode.literal.LitString;
043    import railo.transformer.bytecode.statement.ExpressionStatement;
044    
045    public class JavaParserVisitor extends VoidVisitorAdapter {
046    
047        private ScriptBody body;
048            private Label start;
049            private Label end;
050    
051            public JavaParserVisitor(ScriptBody body, Label start, Label end) {
052                    this.body=body;
053                    this.start=start;
054                    this.end=end;
055            }
056    
057    
058            /* (non-Javadoc)
059             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.stmt.BlockStmt, java.lang.Object)
060             */
061            @Override
062            public void visit(BlockStmt n, Object arg) {
063                    //print.o("visit(BlockStmt n, Object arg)");
064                    //print.o(n+":"+arg);
065                    
066                    super.visit(n, arg);
067            }
068    
069            /* (non-Javadoc)
070             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.stmt.IfStmt, java.lang.Object)
071             */     public void visit(IfStmt n, Object arg) {
072                    super.visit(n, arg);
073            }
074             
075    
076    
077            public void visit(MethodDeclaration n, Object arg) {
078                    super.visit(n, arg);
079        }
080    
081            private void statement(Statement statement) {
082                    System.out.println(statement);
083                    //System.err.println(statement.getData());
084                    //System.err.println(statement.getData());
085                    
086                    
087            }
088            
089            
090            
091            
092            
093            
094            
095            
096            
097    
098            public void visit(ExpressionStmt n, Object arg) {
099                    super.visit(n, arg);
100                    DataBag db=toDataBag(arg);
101                    Expression e=(Expression) db.rtn.pop();
102                    
103                    
104                    body.addStatement(new ExpressionStatement(e));
105                    db.rtn.clear();
106            }
107            
108            /**
109             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.body.VariableDeclaratorId, java.lang.Object)
110             */
111            public void visit(VariableDeclaratorId n, Object arg) {
112                    DataBag db=toDataBag(arg);
113                    append(db,n.getName());
114            }
115            
116    
117            /**
118             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.NameExpr, java.lang.Object)
119             */
120            public void visit(NameExpr n, Object arg) {
121                    DataBag db=toDataBag(arg);
122                    append(db,n.getName());
123            }
124            
125            /**
126             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.type.ClassOrInterfaceType, java.lang.Object)
127             */
128            public void visit(ClassOrInterfaceType n, Object arg) {
129                    DataBag db=toDataBag(arg);
130                    append(db,loadClass(n.toString()));
131                    
132            }
133            
134    
135            /**
136             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.type.PrimitiveType, java.lang.Object)
137             */
138            public void visit(PrimitiveType n, Object arg) {
139                    DataBag db=toDataBag(arg);
140                    append(db,loadPrimitiveClass(n.getType().toString()));
141            }
142            
143            
144            // OPERATORS
145            /**
146             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.BinaryExpr, java.lang.Object)
147             */
148            public void visit(BinaryExpr n, Object arg) {
149                    super.visit(n, arg);
150                    
151                    DataBag db=(DataBag)arg;
152                    Object right=db.rtn.pop();
153                    Object left=db.rtn.pop();
154                    
155                    append(db, new Operation(n.getBeginLine(), left, right, n.getOperator().name(), db));
156            }
157            
158            /**
159             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.UnaryExpr, java.lang.Object)
160             */
161            public void visit(UnaryExpr n, Object arg) {
162                    super.visit(n, arg);
163                    DataBag db=(DataBag)arg;
164                    Object operant=db.rtn.pop();
165                    
166                    append(db, new UnaryOp(n.getBeginLine(), operant, n.getOperator().name(), db));
167            }
168            
169            /* (non-Javadoc)
170             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.CastExpr, java.lang.Object)
171             */
172            public void visit(CastExpr n, Object arg) {
173                    super.visit(n, arg);
174                    DataBag db=(DataBag)arg;
175                    Object value=db.rtn.pop();
176                    Class type = (Class) db.rtn.pop();
177                    
178                    append(db, new CastOp(n.getBeginLine(), value, type, db));
179            }
180            
181            
182            
183            // VARIABLES
184            public void visit(AssignExpr n, Object arg) {
185                    super.visit(n, arg);
186                    DataBag db=(DataBag)arg;
187                    
188                    Object value=db.rtn.pop();
189                    String name = (String) db.rtn.pop();
190                    append(db, new Assign(n.getBeginLine(), name,value, n.getOperator().toString() ,db));// TODO line
191            }
192    
193            public void visit(VariableDeclarationExpr n, Object arg) {
194                    super.visit(n, arg);
195                    DataBag db=(DataBag)arg;
196                    if(db.rtn.size()>=3){
197                            Object value=db.rtn.pop();
198                            String name = (String) db.rtn.pop();
199                            Class type = (Class) db.rtn.pop();
200                            append(db, new VariableDecl(n.getBeginLine(), type, name, value,db));
201                    }
202                    else {
203                            String name = (String) db.rtn.pop();
204                            Class type = (Class) db.rtn.pop();
205                            append(db, new VariableDecl(n.getBeginLine(), type, name, null,db));
206                    }
207            }
208            
209            /* (non-Javadoc)
210             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.ObjectCreationExpr, java.lang.Object)
211             */
212            public void visit(ObjectCreationExpr n, Object arg) {
213                    System.err.println("ObjectCreationExpr:"+n);
214                    
215                    
216                    super.visit(n, arg);
217            }
218            
219            
220            // LITERAL
221            
222            /**
223             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.StringLiteralExpr, java.lang.Object)
224             */
225            public void visit(StringLiteralExpr n, Object arg) {
226                    DataBag db=toDataBag(arg);
227                    append(db, LitString.toExprString(n.getValue()));
228            }
229    
230            /**
231             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.BooleanLiteralExpr, java.lang.Object)
232             */
233            public void visit(BooleanLiteralExpr n, Object arg) {
234                    DataBag db=toDataBag(arg);
235                    append(db, LitBoolean.toExprBoolean(n.getValue()));
236            }
237    
238            /**
239             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.CharLiteralExpr, java.lang.Object)
240             */
241            public void visit(CharLiteralExpr n, Object arg) {
242                    String str=n.getValue();
243                    
244                    //BytecodeContext bc=toBytecodeContext(arg);
245                    //bc.getAdapter().push((int)str.charAt(0));
246                    
247                    //super.visit(n, arg);
248            }
249    
250            /* (non-Javadoc)
251             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.DoubleLiteralExpr, java.lang.Object)
252             */
253            public void visit(DoubleLiteralExpr n, Object arg) {
254                    String str=n.getValue().trim();
255                    DataBag db=toDataBag(arg);
256    
257                    // float
258                    if(StringUtil.endsWithIgnoreCase(str, "f")) {
259                            str=str.substring(0,str.length()-1);
260                            append(db, LitFloat.toExprFloat(Float.valueOf(str),n.getBeginLine()));
261                            return;
262                    }
263                    
264                    // double
265                    if(StringUtil.endsWithIgnoreCase(str, "d")) {
266                            str=str.substring(0,str.length()-1);    
267                    }
268                    append(db, LitDouble.toExprDouble(Double.valueOf(str),n.getBeginLine()));
269                    
270            }
271    
272            /* (non-Javadoc)
273             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.IntegerLiteralExpr, java.lang.Object)
274             */
275            public void visit(IntegerLiteralExpr n, Object arg) {
276                    String str=n.getValue();
277                    DataBag db=toDataBag(arg);
278                    append(db, LitInteger.toExpr(Integer.valueOf(str),n.getBeginLine()));// TODO 0X 0
279                    
280                    //super.visit(n, arg);
281            }
282    
283            /* (non-Javadoc)
284             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.IntegerLiteralMinValueExpr, java.lang.Object)
285             */
286            public void visit(IntegerLiteralMinValueExpr n, Object arg) {
287                    super.visit(n, arg);
288            }
289    
290            /* (non-Javadoc)
291             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.LongLiteralExpr, java.lang.Object)
292             */
293            public void visit(LongLiteralExpr n, Object arg) {
294                    String str=n.getValue();
295                    str=str.substring(0,str.length()-1);
296                    
297    
298                    DataBag db=toDataBag(arg);
299                    append(db, LitLong.toExpr(Long.parseLong(str),n.getBeginLine()));// TODO 0X 0
300                    
301            }
302    
303            /* (non-Javadoc)
304             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.LongLiteralMinValueExpr, java.lang.Object)
305             */
306            public void visit(LongLiteralMinValueExpr n, Object arg) {
307                    super.visit(n, arg);
308            }
309    
310            /**
311             * @see japa.parser.ast.visitor.VoidVisitorAdapter#visit(japa.parser.ast.expr.NullLiteralExpr, java.lang.Object)
312             */
313            @Override
314            public void visit(NullLiteralExpr n, Object arg) {
315                    DataBag db=toDataBag(arg);
316                    append(db,NullExpression.NULL_EXPRESSION);
317            }
318    
319            private void append(DataBag db, Object o) {
320                    db.rtn.add(o);
321            }
322    
323            private DataBag setLine(DataBag db) {
324                    // TODO Auto-generated method stub
325                    return db;
326            }
327    
328            private DataBag toDataBag(Object arg) {
329                    return toDataBag(arg,true);
330            }
331            
332            private DataBag toDataBag(Object arg, boolean setLine) {
333                    if(setLine) return setLine((DataBag)arg);
334                    return (DataBag)arg;
335            }
336    
337            private static Class loadClass(String type) {
338                    try {
339                            try {
340                                    return ClassUtil.loadClass(type);
341                            } catch (ClassException e) {
342                                    return ClassUtil.loadClass("java.lang."+type);
343                            }
344                    } catch (ClassException e) {
345                            throw new RuntimeException(e);
346                    }
347            }
348            private static Class loadPrimitiveClass(String type)  {
349                    if("byte".equalsIgnoreCase(type)) return byte.class;
350                    if("boolean".equalsIgnoreCase(type)) return boolean.class;
351                    if("char".equalsIgnoreCase(type)) return char.class;
352                    if("short".equalsIgnoreCase(type)) return short.class;
353                    if("int".equalsIgnoreCase(type)) return int.class;
354                    if("long".equalsIgnoreCase(type)) return long.class;
355                    if("float".equalsIgnoreCase(type)) return float.class;
356                    if("double".equalsIgnoreCase(type)) return double.class;
357                    
358                    throw new RuntimeException("invalid primitive type ["+type+"]");
359                    
360            }
361            /*private BytecodeContext toBytecodeContext(Object arg) {
362                    return ((DataBag)arg).bc;
363            }
364            private GeneratorAdapter toAdapter(Object arg) {
365                    return toBytecodeContext(arg).getAdapter();
366            }*/
367            
368    
369            
370            /*private Expression toExpression(Object o) {
371                    if(o instanceof Expression) return (Expression) o;
372                    else if(o instanceof String) return new LitString((String) o, -1);
373                    throw new RuntimeException("cannot cast objet from type ["+Caster.toClassName(o)+"] to a Expression");
374            }
375    
376            private String toString(Object o) {
377                    if(o instanceof String) 
378                            return (String) o;
379                    else if(o instanceof Expression){
380                            String res = ASMUtil.toString((Expression) o, null);
381                            return res;
382                    }
383                    throw new RuntimeException("cannot cast objet from type ["+Caster.toClassName(o)+"] to a String");
384            }*/
385    }