API tools faq
paste
Advertisement
Dimension

Import.java

Dimension
Dec 10th, 2011
46
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 28.05 KB | None | 0 0
raw download clone embed print report
  1. package emulator.editor;
  2.  
  3. import static emulator.memory.Memory.Access.StructureAccess.simpleStructureAccess;
  4.  
  5. import java.net.*;
  6. import java.util.*;
  7.  
  8. import javax.lang.model.element.TypeElement;
  9. import javax.tools.*;
  10.  
  11. import com.sun.source.tree.CompilationUnitTree;
  12. import com.sun.tools.javac.api.JavacTaskImpl;
  13. import com.sun.tools.javac.code.*;
  14. import com.sun.tools.javac.code.Symbol.ClassSymbol;
  15. import com.sun.tools.javac.comp.*;
  16. import com.sun.tools.javac.tree.*;
  17. import com.sun.tools.javac.tree.JCTree.JCClassDecl;
  18. import com.sun.tools.javac.tree.JCTree.JCExpression;
  19. import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
  20. import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
  21. import com.sun.tools.javac.util.Context;
  22.  
  23. import emulator.code.*;
  24. import emulator.code.Code.Decl;
  25. import emulator.code.Operation.OperationType;
  26. import emulator.editor.Context.*;
  27. import emulator.editor.Export.*;
  28. import emulator.memory.*;
  29. import emulator.memory.Memory.Access;
  30. import emulator.memory.Memory.Access.StackAccess;
  31.  
  32. public class Import {
  33.     // preliminary: java only
  34.  
  35.     public static final LinkedHashMap<Class, ImportDef> javaImportDef = new LinkedHashMap<Class, ImportDef>();
  36.  
  37.     public static void initJavaImport() {
  38.        
  39.         // Structure
  40.        
  41.         javaImportDef.put(JCTree.JCCompilationUnit.class, new ImportDef(
  42.             new ImportScript() {
  43.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  44.                     assert false;
  45.                 }
  46.             }
  47.         ));
  48.        
  49.         javaImportDef.put(JCTree.JCImport.class, new ImportDef(
  50.             new ImportScript() {
  51.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  52.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  53.                 }
  54.             }
  55.         ));
  56.        
  57.         javaImportDef.put(JCTree.JCMethodDecl.class, new ImportDef(
  58.             new ImportScript() {
  59.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  60.                     JCTree.JCMethodDecl jctree1 = (JCTree.JCMethodDecl) importContext.jctree;
  61.    
  62.                     {
  63.                         Code code1 = importContext.parent.return1 = new Code();
  64.                         code1.operationType = Operation.OperationType.Control.OP_SEQUENCE;
  65.                         code1.propertyList.put(new Identifier.Property("function"), null);
  66.                         //code1.paramList.put(key, value); // param decl
  67.                         //code1.linkedList.add(e)
  68.                         code1.title = jctree1.name.toString();
  69.                        
  70.                         importDecl(jctree1.body, context, javaImport, importContext, code1);
  71.                         assert importContext.return1 != null;
  72.  
  73.                         CodeOut.initList(context, code1.codeList, new Identifier.Property("code"));
  74.                         Structure.List.Vector access1 = (Structure.List.Vector) Memory.Process.resolveExecuteItem(context.process, code1.codeList.get(new Identifier.Property("code")))[0];
  75.                        
  76.                         int next = Memory.Process.appendData(context.process, new StackAccess(context.stackContext.stackId.control, 0), new Object[] { importContext.return1 });
  77.                         access1.set(new Identifier.Property("index", 0), new Object[] { simpleStructureAccess(context.stackContext.stackId.control, new Identifier.Property("index", next)) });
  78.                     }
  79.                 }
  80.             }
  81.         ));
  82.        
  83.         javaImportDef.put(JCTree.JCCatch.class, new ImportDef(
  84.             new ImportScript() {
  85.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  86.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  87.                 }
  88.             }
  89.         ));
  90.        
  91.         javaImportDef.put(JCTree.JCTypeParameter.class, new ImportDef(
  92.             new ImportScript() {
  93.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  94.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  95.                 }
  96.             }
  97.         ));
  98.        
  99.         javaImportDef.put(JCTree.TypeBoundKind.class, new ImportDef(
  100.             new ImportScript() {
  101.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  102.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  103.                 }
  104.             }
  105.         ));
  106.        
  107.         javaImportDef.put(JCTree.JCModifiers.class, new ImportDef(
  108.             new ImportScript() {
  109.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  110.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  111.                 }
  112.             }
  113.         ));
  114.  
  115.         // Statement
  116.        
  117.         javaImportDef.put(JCTree.JCClassDecl.class, new ImportDef(
  118.             new ImportScript() {
  119.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  120.                     JCTree.JCClassDecl jctree1 = (JCTree.JCClassDecl) importContext.jctree;
  121.    
  122.                     // create new type and add to type list
  123.                     // check nested class environment
  124.                    
  125.                     //System.out.println("JCClassDecl SYM " + jctree1.sym);
  126.                    
  127.                     {
  128.                         String[] package1 = jctree1.sym.fullname.toString().split("\\.");
  129.                        
  130.                         Structure.Type type = new Structure.Type();
  131.                         type.typeId = new Identifier.Type(context.process.processId.programId, package1);
  132.                         type.enclosingTypeId = importContext.type != null ? importContext.type.typeId : null;
  133.                        
  134.                         /*if(jctree1.extending != null) {
  135.                             jctree1.extending.type.tsym.
  136.                            
  137.                             String[] package1 = jctree1.extending.type.tsym.fullname.toString().split("\\.");
  138.                             type.extendsList.append(new Object[] { new Identifier.Type(context.process.processId.programId, package1) });
  139.                         }*/
  140.                        
  141.                         Memory.Process.setData(context.process, simpleStructureAccess(context.stackContext.stackId.type, new Identifier.Property(type.typeId)), new Object[] { type });
  142.                        
  143.                         for(JCTree jctree2 : jctree1.defs) {
  144.                             importTypeMember(jctree2, context, javaImport, importContext, type);
  145.                            
  146.                             if(jctree2 instanceof JCVariableDecl) {
  147.                             }
  148.                             else if(jctree2 instanceof JCMethodDecl) {
  149.                                 assert importContext.return1 != null;
  150.                                 JCTree.JCMethodDecl jctree3 = (JCTree.JCMethodDecl) jctree2;
  151.                                
  152.                                 assert !type.codeList.containsKey(new Identifier.Property(jctree3.name.toString()));
  153.                                 int next = Memory.Process.appendData(context.process, new StackAccess(context.stackContext.stackId.control, 0), new Object[] { importContext.return1 });
  154.                                 type.codeList.put(new Identifier.Property(jctree3.name.toString()), simpleStructureAccess(context.stackContext.stackId.control, new Identifier.Property("index", next)));
  155.                             }
  156.                             else if(jctree2 instanceof JCClassDecl) {
  157.                             }
  158.                             else {
  159.                                 assert false;
  160.                             }
  161.                         }
  162.                     }
  163.                 }
  164.             }
  165.         ));
  166.        
  167.         javaImportDef.put(JCTree.JCVariableDecl.class, new ImportDef(
  168.             new ImportScript() {
  169.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  170.                     JCTree.JCVariableDecl jctree1 = (JCTree.JCVariableDecl) importContext.jctree;
  171.                    
  172.                     assert importContext.type != null;
  173.                    
  174.                     Decl decl = new Decl();
  175.                     decl.typing = new Code.Typing();
  176.                    
  177.                     /*if(jctree1.vartype.tag == TypeTag.) {
  178.                         Access type = getType(jctree1.vartype);
  179.                         decl.typing.typingType = Code.Typing.TypingType.CONSTANT;
  180.                     }
  181.                     else {
  182.                        
  183.                     }*/
  184.                    
  185.                     decl.initType = Code.Decl.InitType.LITERAL;
  186.                    
  187.                     if(importContext.decl != null) { // local vars (thread local)
  188.                         //Identifier.Stack stackId = new Identifier.Stack(context.process.processId, context.thread.threadId, importContext.type.typeId, jctree1.name.toString());
  189.                         Identifier.Stack stackId = new Identifier.Stack(context.process.processId, context.thread.threadId, null, jctree1.name.toString());
  190.                         assert !importContext.decl.declList.containsKey(stackId);
  191.                         decl.stackId = stackId;
  192.                         importContext.decl.declList.put(decl.stackId, decl);
  193.                     }
  194.                     else { // type vars (thread global)
  195.                         Identifier.Property propertyId = new Identifier.Property(jctree1.name.toString());
  196.                         assert !importContext.type.declList.containsKey(propertyId);
  197.                         decl.propertyId = propertyId;
  198.                         importContext.type.declList.put(decl.propertyId, decl);
  199.                     }
  200.  
  201.                 }
  202.             }
  203.         ));
  204.        
  205.         javaImportDef.put(JCTree.JCSkip.class, new ImportDef(
  206.             new ImportScript() {
  207.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  208.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  209.                 }
  210.             }
  211.         ));
  212.        
  213.         javaImportDef.put(JCTree.JCBlock.class, new ImportDef(
  214.             new ImportScript() {
  215.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  216.                     JCTree.JCBlock jctree1 = (JCTree.JCBlock) importContext.jctree;
  217.                    
  218.                     {
  219.                         Code code1 = importContext.parent.return1 = new Code();
  220.                         code1.operationType = Operation.OperationType.Control.OP_SEQUENCE;
  221.                        
  222.                         CodeOut.initList(context, code1.codeList, new Identifier.Property("code"));
  223.                         Structure.List.Vector access1 = (Structure.List.Vector) Memory.Process.resolveExecuteItem(context.process, code1.codeList.get(new Identifier.Property("code")))[0];            
  224.                        
  225.                         int i = 0;
  226.                         int j = 0;
  227.                         for(JCTree jctree2 : jctree1.stats) {
  228.                             importNoDecl(jctree2, context, javaImport, importContext, code1);
  229.  
  230.                             if(importContext.return1 == null) {
  231.                                 System.out.println(jctree2.getClass().getSimpleName());
  232.                                 assert jctree2 instanceof JCVariableDecl;
  233.                             }
  234.                             else {
  235.                                 int next = Memory.Process.appendData(context.process, new StackAccess(context.stackContext.stackId.control, 0), new Object[] { importContext.return1 });
  236.                                 access1.set(new Identifier.Property("index", j++), new Object[] { simpleStructureAccess(context.stackContext.stackId.control, new Identifier.Property("index", next)) });
  237.                             }
  238.                            
  239.                             i++;
  240.                         }
  241.                     }
  242.                 }
  243.             }
  244.         ));
  245.        
  246.         javaImportDef.put(JCTree.JCDoWhileLoop.class, new ImportDef(
  247.             new ImportScript() {
  248.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  249.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  250.                 }
  251.             }
  252.         ));
  253.        
  254.         javaImportDef.put(JCTree.JCWhileLoop.class, new ImportDef(
  255.             new ImportScript() {
  256.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  257.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  258.                 }
  259.             }
  260.         ));
  261.        
  262.         javaImportDef.put(JCTree.JCForLoop.class, new ImportDef(
  263.             new ImportScript() {
  264.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  265.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  266.                 }
  267.             }
  268.         ));
  269.        
  270.         javaImportDef.put(JCTree.JCEnhancedForLoop.class, new ImportDef(
  271.             new ImportScript() {
  272.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  273.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  274.                 }
  275.             }
  276.         ));
  277.        
  278.         javaImportDef.put(JCTree.JCLabeledStatement.class, new ImportDef(
  279.             new ImportScript() {
  280.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  281.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  282.                 }
  283.             }
  284.         ));
  285.        
  286.         javaImportDef.put(JCTree.JCSwitch.class, new ImportDef(
  287.             new ImportScript() {
  288.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  289.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  290.                 }
  291.             }
  292.         ));
  293.        
  294.         javaImportDef.put(JCTree.JCCase.class, new ImportDef(
  295.             new ImportScript() {
  296.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  297.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  298.                 }
  299.             }
  300.         ));
  301.        
  302.         javaImportDef.put(JCTree.JCSynchronized.class, new ImportDef(
  303.             new ImportScript() {
  304.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  305.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  306.                 }
  307.             }
  308.         ));
  309.        
  310.         javaImportDef.put(JCTree.JCTry.class, new ImportDef(
  311.             new ImportScript() {
  312.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  313.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  314.                 }
  315.             }
  316.         ));
  317.        
  318.         javaImportDef.put(JCTree.JCIf.class, new ImportDef(
  319.             new ImportScript() {
  320.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  321.                     JCTree.JCIf jctree1 = (JCTree.JCIf) importContext.jctree;
  322.                    
  323.                     {
  324.                         Code code1 = importContext.parent.return1 = new Code();
  325.                         code1.operationType = Operation.OperationType.Control.OP_IF;
  326.                         CodeOut.initList(context, code1.dataList, new Identifier.Property("cond"));
  327.                         CodeOut.initList(context, code1.codeList, new Identifier.Property("code"));
  328.                         Structure.List.Vector access1 = (Structure.List.Vector) Memory.Process.resolveExecuteItem(context.process, code1.dataList.get(new Identifier.Property("cond")))[0];
  329.                         Structure.List.Vector access2 = (Structure.List.Vector) Memory.Process.resolveExecuteItem(context.process, code1.codeList.get(new Identifier.Property("code")))[0];            
  330.  
  331.                         Code code2 = new Code();
  332.                         code2.operationType = Operation.OperationType.Control.OP_SEQUENCE;
  333.                        
  334.                        
  335.                         while(jctree1.elsepart instanceof JCTree.JCIf) {
  336.                             //access1.append(value);
  337.                             //access2.append(value);
  338.                         }
  339.                     }
  340.                 }
  341.             }
  342.         ));
  343.        
  344.         javaImportDef.put(JCTree.JCExpressionStatement.class, new ImportDef(
  345.             new ImportScript() {
  346.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  347.                     JCTree.JCExpressionStatement jctree1 = (JCTree.JCExpressionStatement) importContext.jctree;
  348.    
  349.                     importPassthrough(jctree1.expr, context, javaImport, importContext);
  350.                     assert importContext.return1 != null;
  351.                     importContext.parent.return1 = importContext.return1;
  352.                 }
  353.             }
  354.         ));
  355.        
  356.         javaImportDef.put(JCTree.JCBreak.class, new ImportDef(
  357.             new ImportScript() {
  358.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  359.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  360.                 }
  361.             }
  362.         ));
  363.        
  364.         javaImportDef.put(JCTree.JCContinue.class, new ImportDef(
  365.             new ImportScript() {
  366.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  367.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  368.                 }
  369.             }
  370.         ));
  371.        
  372.         javaImportDef.put(JCTree.JCReturn.class, new ImportDef(
  373.             new ImportScript() {
  374.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  375.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  376.                 }
  377.             }
  378.         ));
  379.        
  380.         javaImportDef.put(JCTree.JCThrow.class, new ImportDef(
  381.             new ImportScript() {
  382.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  383.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  384.                 }
  385.             }
  386.         ));
  387.        
  388.         javaImportDef.put(JCTree.JCAssert.class, new ImportDef(
  389.             new ImportScript() {
  390.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  391.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  392.                 }
  393.             }
  394.         ));
  395.  
  396.         // Expression
  397.  
  398.  
  399.         javaImportDef.put(JCTree.JCConditional.class, new ImportDef(
  400.             new ImportScript() {
  401.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  402.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  403.                 }
  404.             }
  405.         ));
  406.        
  407.         javaImportDef.put(JCTree.JCMethodInvocation.class, new ImportDef(
  408.             new ImportScript() {
  409.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  410.                     JCTree.JCMethodInvocation jctree1 = (JCTree.JCMethodInvocation) importContext.jctree;
  411.    
  412.                     {
  413.                         Code code1 = importContext.parent.return1 = new Code();
  414.                         code1.operationType = Operation.OperationType.Control.OP_ENVIRONMENT;
  415.                        
  416.                         //code1.declList
  417.                        
  418.                         code1.codeList.put(new Identifier.Property("code"), getAccess(jctree1.meth));
  419.                        
  420.                         for(JCTree jctree2 : jctree1.args) {
  421.                             importExpression(jctree2, context, javaImport, importContext, code1);
  422.                             assert importContext.return1 != null;
  423.                            
  424.                            
  425.                         }
  426.                     }
  427.                 }
  428.             }
  429.         ));
  430.        
  431.         javaImportDef.put(JCTree.JCNewClass.class, new ImportDef(
  432.             new ImportScript() {
  433.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  434.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  435.                 }
  436.             }
  437.         ));
  438.        
  439.         javaImportDef.put(JCTree.JCNewArray.class, new ImportDef(
  440.             new ImportScript() {
  441.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  442.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  443.                 }
  444.             }
  445.         ));
  446.        
  447.         javaImportDef.put(JCTree.JCParens.class, new ImportDef(
  448.             new ImportScript() {
  449.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  450.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  451.                 }
  452.             }
  453.         ));
  454.        
  455.         javaImportDef.put(JCTree.JCAssign.class, new ImportDef(
  456.             new ImportScript() {
  457.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  458.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  459.                 }
  460.             }
  461.         ));
  462.        
  463.         javaImportDef.put(JCTree.JCAssignOp.class, new ImportDef(
  464.             new ImportScript() {
  465.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  466.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  467.                 }
  468.             }
  469.         ));
  470.        
  471.         javaImportDef.put(JCTree.JCUnary.class, new ImportDef(
  472.             new ImportScript() {
  473.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  474.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  475.                 }
  476.             }
  477.         ));
  478.        
  479.         javaImportDef.put(JCTree.JCBinary.class, new ImportDef(
  480.             new ImportScript() {
  481.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  482.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  483.                 }
  484.             }
  485.         ));
  486.        
  487.         javaImportDef.put(JCTree.JCTypeCast.class, new ImportDef(
  488.             new ImportScript() {
  489.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  490.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  491.                 }
  492.             }
  493.         ));
  494.        
  495.         javaImportDef.put(JCTree.JCInstanceOf.class, new ImportDef(
  496.             new ImportScript() {
  497.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  498.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  499.                 }
  500.             }
  501.         ));
  502.        
  503.         javaImportDef.put(JCTree.JCArrayAccess.class, new ImportDef(
  504.             new ImportScript() {
  505.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  506.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  507.                 }
  508.             }
  509.         ));
  510.        
  511.         javaImportDef.put(JCTree.JCFieldAccess.class, new ImportDef(
  512.             new ImportScript() {
  513.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  514.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  515.                 }
  516.             }
  517.         ));
  518.        
  519.         javaImportDef.put(JCTree.JCIdent.class, new ImportDef(
  520.             new ImportScript() {
  521.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  522.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  523.                 }
  524.             }
  525.         ));
  526.        
  527.         javaImportDef.put(JCTree.JCLiteral.class, new ImportDef(
  528.             new ImportScript() {
  529.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  530.                     JCTree.JCLiteral jctree1 = (JCTree.JCLiteral) importContext.jctree;
  531.                    
  532.                     if(!javaImport.literalTable.containsKey(jctree1.value)) {
  533.                         int next = Memory.Process.appendData(context.process, new StackAccess(context.stackContext.stackId.constant, 0), new Object[] { jctree1.value });
  534.                         javaImport.literalTable.put(jctree1.value, simpleStructureAccess(context.stackContext.stackId.constant, new Identifier.Property("index", next)));
  535.                     }
  536.    
  537.                     Code code1 = importContext.parent.return1 = new Code();
  538.                     code1.operationType = Operation.OperationType.Expression.OP_ACCESS;
  539.                     code1.dataList.put(new Identifier.Property("source"), javaImport.literalTable.get(jctree1.value)); // constant
  540.                     code1.propertyList.put(new Identifier.Property("constant"), null);
  541.                 }
  542.             }
  543.         ));
  544.        
  545.         javaImportDef.put(JCTree.JCPrimitiveTypeTree.class, new ImportDef(
  546.             new ImportScript() {
  547.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  548.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  549.                 }
  550.             }
  551.         ));
  552.        
  553.         javaImportDef.put(JCTree.JCArrayTypeTree.class, new ImportDef(
  554.             new ImportScript() {
  555.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  556.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  557.                 }
  558.             }
  559.         ));
  560.        
  561.         javaImportDef.put(JCTree.JCTypeApply.class, new ImportDef(
  562.             new ImportScript() {
  563.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  564.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  565.                 }
  566.             }
  567.         ));
  568.        
  569.         javaImportDef.put(JCTree.JCWildcard.class, new ImportDef(
  570.             new ImportScript() {
  571.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  572.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  573.                 }
  574.             }
  575.         ));
  576.        
  577.         javaImportDef.put(JCTree.JCAnnotation.class, new ImportDef(
  578.             new ImportScript() {
  579.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  580.                     System.out.println("UNIMPLEMENTED: " + importContext.jctree.getClass().getSimpleName());
  581.                 }
  582.             }
  583.         ));
  584.        
  585.         javaImportDef.put(JCTree.JCErroneous.class, new ImportDef(
  586.             new ImportScript() {
  587.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  588.                     assert false;
  589.                 }
  590.             }
  591.         ));
  592.        
  593.         javaImportDef.put(JCTree.LetExpr.class, new ImportDef(
  594.             new ImportScript() {
  595.                 public void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  596.                     assert false;
  597.                 }
  598.             }
  599.         ));
  600.     }
  601.    
  602.     public static Access getAccess(JCExpression expression) {
  603.         return null;
  604.     }
  605.    
  606.     public static Access getType(JCExpression expression) {
  607.         return null;
  608.     }
  609.    
  610.     public static Type getPrimitive(JCExpression expression) {
  611.         return null;
  612.     }
  613.  
  614.     public static int logIndent = 0;///
  615.     public static void import1(CodeContext context, JavaImport javaImport, JavaImportContext.JavaImportContextNew importContext) {
  616.         //*
  617.         //System.out.println("import " + jctree.getClass().getSimpleName());
  618.         System.out.print("import ");
  619.         for(int i = logIndent; i > 0; i--)
  620.             System.out.print("+ ");
  621.         System.out.print(importContext.jctree.getClass().getSimpleName());
  622.         System.out.println();
  623.         logIndent++;
  624.         //*/
  625.        
  626.         if(importContext.parent != null) {
  627.             importContext.parent.return1 = null;
  628.         }
  629.        
  630.         // TODO general: annotation, comment, ...
  631.         javaImportDef.get(importContext.jctree.getClass()).importScript.exec(context, javaImport, importContext);
  632.        
  633.        
  634.         logIndent--;///
  635.     }
  636.    
  637.     public static void importTypeMember(JCTree jctree, CodeContext context, JavaImport javaImport, JavaImportContext importContext, Structure.Type type) {
  638.         import1(context, javaImport, new JavaImportContext.JavaImportContextNew(importContext, jctree, null, null, type));
  639.     }
  640.    
  641.     public static void importDecl(JCTree jctree, CodeContext context, JavaImport javaImport, JavaImportContext importContext, Code code) {
  642.         import1(context, javaImport, new JavaImportContext.JavaImportContextNew(importContext, jctree, code, importContext.decl, importContext.type));
  643.     }
  644.    
  645.     public static void importNoDecl(JCTree jctree, CodeContext context, JavaImport javaImport, JavaImportContext importContext, Code code) {
  646.         import1(context, javaImport, new JavaImportContext.JavaImportContextNew(importContext, jctree, code, code, importContext.type));
  647.     }
  648.    
  649.     public static void importExpression(JCTree jctree, CodeContext context, JavaImport javaImport, JavaImportContext importContext, Code code) {
  650.         import1(context, javaImport, new JavaImportContext.JavaImportContextNew(importContext, jctree, code, null, importContext.type));
  651.     }
  652.    
  653.     public static void importPassthrough(JCTree jctree, CodeContext context, JavaImport javaImport, JavaImportContext importContext) {
  654.         import1(context, javaImport, new JavaImportContext.JavaImportContextNew(importContext, jctree, importContext.code, importContext.decl, importContext.type));
  655.     }
  656.    
  657.     public static class JavaSourceString extends SimpleJavaFileObject {
  658.         public String contents;
  659.        
  660.         protected JavaSourceString(String classname, String contents) throws URISyntaxException {
  661.             super(new URI(classname), Kind.SOURCE);
  662.            
  663.             this.contents = contents;
  664.         }
  665.        
  666.         @Override
  667.         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
  668.             return contents;
  669.         }
  670.     }
  671.    
  672.     public static void importSource(String name, String source, CodeContext context, StackContext stackContext) {
  673.         // TODO set compiler classpath and options
  674.         // TODO handle diagnostic messages
  675.        
  676.         JavaImport.JavaImportNew javaImport;
  677.         //JavaImportContext.JavaImportContextNew importContext;
  678.        
  679.         try {
  680.             JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  681.             DiagnosticCollector<JavaFileObject> diagnosticCollector = new DiagnosticCollector<JavaFileObject>();
  682.             StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnosticCollector, null, null);
  683.             Iterable<? extends JavaFileObject> fileObjectList = Arrays.asList(new JavaSourceString(name, source));
  684.             JavacTaskImpl task = (JavacTaskImpl) compiler.getTask(null, fileManager, diagnosticCollector, null, null, fileObjectList);
  685.    
  686.             com.sun.tools.javac.util.Context javacContext = task.getContext();
  687.             javaImport = new JavaImport.JavaImportNew(javacContext);
  688.        
  689.             Iterable<? extends CompilationUnitTree> compilationList = task.parse();
  690.             Iterable<? extends TypeElement> typeElementList = task.enter(compilationList);
  691.            
  692.             List<Diagnostic<? extends JavaFileObject>> diagnosticList = diagnosticCollector.getDiagnostics();
  693.             boolean success = diagnosticList.isEmpty();
  694.             for(Diagnostic<? extends JavaFileObject> diagnostic : diagnosticList) {
  695.                 System.out.println(diagnostic);
  696.                 //diagnosticCollector.report(diagnostic);
  697.             }
  698.            
  699.             if(success) {
  700.                 for (TypeElement typeElement : typeElementList) {
  701.                     //System.out.println("### " + (ClassSymbol) typeElement);
  702.                    
  703.                     Env<AttrContext> env = javaImport.enter.getEnv((ClassSymbol) typeElement);
  704.                     assert env.tree instanceof JCClassDecl;
  705.                     importTypeMember(env.tree, context, javaImport, null, null);
  706.                 }
  707.             }
  708.         }
  709.         catch(Exception e) {
  710.             e.printStackTrace();
  711.         }
  712.     }
  713.    
  714.     public static class ImportDef {
  715.         public ImportScript importScript;
  716.  
  717.         public ImportDef(ImportScript importScript) {
  718.             this.importScript = importScript;
  719.         };
  720.     }
  721.    
  722.     public static abstract class ImportScript {
  723.         public abstract void exec(CodeContext context, JavaImport javaImport, JavaImportContext importContext);
  724.     }
  725. }
  726.  
  727.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!