Examples of wyvern.tools.typedAST.core.binding.NameBindingImpl

Package wyvern.tools.typedAST.core.binding

Examples of wyvern.tools.typedAST.core.binding.NameBindingImpl

wyvern.tools.typedAST.core.binding.NameBindingImpl

  private Environment getEnvForDict(Map<String, Type> newChildren, Environment ndEnv, ArrayList<String> list) {
    for (String key : list) {
      String[] kSplit = key.split(":");
      Type nt = newChildren.get(key);
      if(kSplit[2].equals("ni")) {
        ndEnv = ndEnv.extend(new NameBindingImpl(kSplit[3], nt));
      } else if (kSplit[2].equals("tb")) {
        ndEnv = ndEnv.extend(new TypeBinding(kSplit[3], nt));
      } else {
        throw new RuntimeException("Unexpected binding");
      }

View Full Code Here

  @Override
  protected Environment doExtend(Environment old, Environment against) {
    if (!extGuard) {
      dclEnv.set(inner.extend(dclEnv.get(), old.extend(dclEnv.get())));
    }
    return old.extend(new NameBindingImpl(name, selfType)).extend(new TypeBinding(name, subTypeType));
  }

View Full Code Here

              Globals.getStandardEnv().extend(importEnv.get()).extend(dclEnv.get())));
        }
      }
      nameGuard = true;
    }
    return env.extend(new NameBindingImpl(name, selfType)).extend(new TypeBinding(name, subTypeType));
  }

View Full Code Here


    Environment ntEnv = res.getGrammars().stream().map(res::getGrammar)
        .flatMap(grm -> grm.getElementsOfType(CopperElementType.NON_TERMINAL).stream().map(grm::getGrammarElement))
        .map(this::parseType).map(pair->(Pair<String, Type>)pair)
        .collect(() -> new Reference<Environment>(Environment.getEmptyEnvironment()),
            (env, elem) -> env.set(env.get().extend(new NameBindingImpl(elem.first(), elem.second()))),
            (a, b) -> a.set(a.get().extend(b.get()))).get();
    
    final Environment savedNtEnv = ntEnv;
    ntEnv = res.getGrammars().stream().map(res::getGrammar)
        .flatMap(grm -> grm.getElementsOfType(CopperElementType.TERMINAL).stream().map(grm::getGrammarElement))
        .map(this::parseType).map(pair -> (Pair<String, Type>) pair)
        .collect(() -> new Reference<Environment>(savedNtEnv),
            (env, elem) -> env.set(env.get().extend(new NameBindingImpl(elem.first(), elem.second()))),
            (a, b) -> a.set(a.get().extend(b.get()))).get();




    HashMap<String, Pair<Type,SpliceBindExn>> toGen = new HashMap<>();
    HashMap<String, TypedAST> toGenDefs = new HashMap<>();
    Reference<Integer> methNum = new Reference<>(0);


    String wyvClassName = res.getClassName();
    String javaClassName = wyvClassName + "$java";


    final Environment savedNtEnv2 = ntEnv;
    res.getGrammars().stream().map(res::getGrammar)
        .flatMap(grm->grm.getElementsOfType(CopperElementType.PRODUCTION).stream().map(grm::getGrammarElement).<Production>map(el->(Production)el))
        .<Pair<Production, List<NameBinding>>>map(prod->new Pair<Production, List<NameBinding>>(prod, CopperTSL.<Type,String,Optional<NameBinding>>
            zip(prod.getRhs().stream().map(cer->savedNtEnv2.lookup(cer.getName().toString()).getType()), prod.getRhsVarNames().stream(),
            (type, name) -> (name == null)?Optional.empty():Optional.of(new NameBindingImpl(name, type)))
            .<NameBinding>flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty())
            .collect(Collectors.<NameBinding>toList()))
        ).forEach(updateCode(toGen,ntEnv,methNum, res.getClassName()));


    LinkedList<BiConsumer<Type,Type>> splicers = new LinkedList<>();


    res.getGrammars().stream().map(res::getGrammar)
        .flatMap(grm->grm.getElementsOfType(CopperElementType.TERMINAL).stream().map(grm::getGrammarElement)
            .<Terminal>map(el->(Terminal)el)).forEach(this.updateTerminalCode(toGen,ntEnv,methNum, res.getClassName(), splicers));


    res.getGrammars().stream().map(res::getGrammar).flatMap(grm->grm.getElementsOfType(CopperElementType.DISAMBIGUATION_FUNCTION)
        .stream().map(grm::getGrammarElement).<DisambiguationFunction>map(el->(DisambiguationFunction)el))
        .forEach(this.updateDisambiguationCode(toGen,ntEnv,methNum));


    res.setClassName(javaClassName);


    String pic = res.getParserInitCode();
    TypedAST parserInitAST;
    if (pic == null)
      parserInitAST = new Sequence();
    else
      parserInitAST = LangUtil.splice(new IParseBuffer(pic), "parser init");
    String defNamePIA = "initGEN" + methNum.get();
    toGenDefs.put(defNamePIA, parserInitAST);
    methNum.set(methNum.get()+1);
    res.setParserInitCode(String.format("Util.invokeValueVarargs(%s, \"%s\");\n", PAIRED_OBJECT_NAME, defNamePIA));


    String ppc = res.getPostParseCode();
    TypedAST postParseAST;
    if (ppc == null)
      postParseAST = new Sequence();
    else
      postParseAST = LangUtil.splice(new IParseBuffer(ppc), "post parse");
    String defNameP = "postGEN" + methNum.get();
    toGenDefs.put(defNameP, postParseAST);
    methNum.set(methNum.get() + 1);
    res.setPostParseCode(String.format("Util.invokeValueVarargs(%s, \"%s\");\n", PAIRED_OBJECT_NAME, defNameP));


    res.setPreambleCode("import wyvern.tools.typedAST.interfaces.Value;\n" +
        "import wyvern.tools.typedAST.core.values.StringConstant;\n" +
        "import wyvern.tools.typedAST.extensions.interop.java.Util;\n" +
        "import wyvern.tools.errors.FileLocation;\n" +
        "import wyvern.tools.typedAST.core.values.IntegerConstant;\n" +
        "import wyvern.tools.typedAST.core.values.TupleValue;\n" +
        "import wyvern.tools.typedAST.core.values.UnitVal;\n" +
        "import wyvern.tools.typedAST.extensions.interop.java.objects.JavaObj;\n" +
        "import wyvern.tools.typedAST.extensions.ExternalFunction;\n" +
        "import wyvern.tools.types.extensions.*;" +
        "");


    res.setParserClassAuxCode(
        "Value "+PAIRED_OBJECT_NAME+" = null;\n" +
        "ExternalFunction pushTokenV = new ExternalFunction(new Arrow(new Tuple(Util.javaToWyvType(Terminals.class),Str.getInstance()), Unit.getInstance()), (ee,v)->{\n" +
            "\tpushToken((Terminals)(((JavaObj)((TupleValue)v).getValue(0)).getObj()), ((StringConstant)((TupleValue)v).getValue(1)).getValue());\n" +
            "\treturn UnitVal.getInstance(FileLocation.UNKNOWN);\n" +
            "});\n" +
        "Value terminals;");


    res.setParserInitCode("pushTokenV = new ExternalFunction(new Arrow(new Tuple(Util.javaToWyvType(Terminals.class),Str.getInstance()), Unit.getInstance()), (ee,v)->{\n" +
        "\tpushToken((Terminals)(((JavaObj)((TupleValue)v).getValue(0)).getObj()), ((StringConstant)((TupleValue)v).getValue(1)).getValue());\n" +
        "\treturn UnitVal.getInstance(FileLocation.UNKNOWN);\n" +
        "});\n" +
        "terminals = Util.javaToWyvDecl("+javaClassName+".Terminals.class).getClassObj();");


    FileLocation unkLoc = FileLocation.UNKNOWN;




    ParserCompilerParameters pcp = new ParserCompilerParameters();


    ByteArrayOutputStream target = new ByteArrayOutputStream();
    pcp.setOutputStream(new PrintStream(target));
    pcp.setOutputType(CopperIOType.STREAM);


    ByteArrayOutputStream dump = new ByteArrayOutputStream();
    pcp.setDumpOutputType(CopperIOType.STREAM);
    pcp.setDumpFormat(CopperDumpType.PLAIN);
    pcp.setDump(CopperDumpControl.ON);
    pcp.setDumpStream(new PrintStream(dump));




    try {
      ParserCompiler.compile(res, pcp);
    } catch (CopperException e) {
      throw new RuntimeException(e);
    }


    if (target.toString().isEmpty() ) {
      System.out.println("Parser error! Parser debug dump");
      System.out.println(dump.toString());
      throw new RuntimeException();
    }
    System.out.println(dump.toString());


    JavaCompiler jc = javax.tools.ToolProvider.getSystemJavaCompiler();


    List<StringFileObject> compilationUnits = Arrays.asList(new StringFileObject(javaClassName, target.toString()));
    StoringClassLoader loader = new StoringClassLoader(this.getClass().getClassLoader());
    StoringFileManager sfm = new StoringFileManager(jc.getStandardFileManager(null, null, null),
        loader);


    StringFileObject sfo = new StringFileObject(javaClassName, target.toString());
    sfm.putFileForInput(StandardLocation.SOURCE_PATH, "", javaClassName, sfo);
    JavaCompiler.CompilationTask ct = jc.getTask(null, sfm, null, null, null, Arrays.asList(sfo));


    if (!ct.call())
      throw new RuntimeException();


    loader.applyTransformer(name->name.equals(javaClassName), cw -> new ClassVisitor(Opcodes.ASM5, new CheckClassAdapter(cw)) {
      @Override
      public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        if (!name.equals("<init>"))
          return super.visitMethod(access, name, desc, signature, exceptions);




        String ndesc = org.objectweb.asm.Type.getMethodDescriptor(org.objectweb.asm.Type.VOID_TYPE,
            org.objectweb.asm.Type.getType(Value.class));
        org.objectweb.asm.Type thisType = org.objectweb.asm.Type.getType("L" + javaClassName + ";");


        MethodVisitor res = new CheckMethodAdapter(super.visitMethod(access, name, ndesc, null, exceptions));
        GeneratorAdapter generator = new GeneratorAdapter(
            res,
            Opcodes.ASM5,
            "<init>",
            ndesc);
        generator.visitCode();
        generator.loadThis();
        generator.invokeConstructor(org.objectweb.asm.Type.getType(SingleDFAEngine.class), Method.getMethod("void <init>()"));
        generator.loadThis();
        generator.loadArg(0);
        generator.putField(thisType, PAIRED_OBJECT_NAME,
            org.objectweb.asm.Type.getType(Value.class));
        generator.returnValue();
        generator.visitMaxs(2, 2);
        generator.visitEnd();


        return new MethodVisitor(Opcodes.ASM5) {};
      }
    });


    Class javaClass = sfm.getClassLoader().loadClass(javaClassName);


    JavaClassDecl jcd = Util.javaToWyvDecl(javaClass);




    JavaClassDecl terminalsDecl = StreamSupport.stream(jcd.getDecls().getDeclIterator().spliterator(), false)
        .filter(decl -> decl instanceof JavaClassDecl)
        .<JavaClassDecl>map(decl -> (JavaClassDecl) decl)
        .filter(decl -> decl.getName().equals("Terminals"))
        .findFirst().orElseThrow(() -> new RuntimeException("Cannot find terminals class"));
    Type terminalClassType = terminalsDecl
        .extend(Environment.getEmptyEnvironment(), Environment.getEmptyEnvironment())
        .lookup("Terminals").getType();
    Type terminalObjType = terminalsDecl
        .extend(Environment.getEmptyEnvironment(), Environment.getEmptyEnvironment())
        .lookupType("Terminals").getType();


    splicers.forEach(splicer -> splicer.accept(terminalClassType,terminalObjType));




    AtomicInteger cdIdx = new AtomicInteger();
    TypedAST[] classDecls = new TypedAST[toGen.size() + toGenDefs.size() + 1];
    toGen.entrySet().stream().forEach(entry->classDecls[cdIdx.getAndIncrement()]
        = new ValDeclaration(entry.getKey(), DefDeclaration.getMethodType(entry.getValue().second().getArgBindings(), entry.getValue().first()), entry.getValue().second(), unkLoc));


    toGenDefs.entrySet().stream().forEach(entry->classDecls[cdIdx.getAndIncrement()]
        = new DefDeclaration(entry.getKey(), new Arrow(Unit.getInstance(), Unit.getInstance()), new LinkedList<>(), entry.getValue(), false));


    classDecls[cdIdx.getAndIncrement()] = new DefDeclaration("create", new Arrow(Unit.getInstance(),
        new UnresolvedType(wyvClassName)),
        Arrays.asList(),
        new New(new DeclSequence(), unkLoc), true);




    ArrayList<TypedAST> pairedObjDecls = new ArrayList<>();
    pairedObjDecls.addAll(Arrays.asList(classDecls));
    TypedAST pairedObj = new ClassDeclaration(wyvClassName, "", "", new DeclSequence(pairedObjDecls), unkLoc);


    Type parseBufferType = Util.javaToWyvType(ParseBuffer.class);




    Type javaClassType = Util.javaToWyvType(javaClass);
    TypedAST bufGet = new Application(
        new Invocation(new Variable(new NameBindingImpl("buf", null), unkLoc), "getSrcString", null, unkLoc),
        UnitVal.getInstance(unkLoc),
        unkLoc);
    ClassType emptyType =
        new ClassType(new Reference<>(Environment.getEmptyEnvironment()), new Reference<>(Environment.getEmptyEnvironment()), new LinkedList<>(), "empty");
    TypedAST javaObjInit = new Application(new ExternalFunction(new Arrow(emptyType, Util.javaToWyvType(Value.class)), (env,arg)->{
      return Util.toWyvObj(arg);
    }),
        new Application(
            new Invocation(new Variable(new NameBindingImpl(wyvClassName, null), unkLoc), "create", null, unkLoc),
            UnitVal.getInstance(unkLoc), unkLoc), unkLoc);
    TypedAST body = new Application(new ExternalFunction(new Arrow(Util.javaToWyvType(Object.class), Util.javaToWyvType(TypedAST.class)),
          (env,arg)-> (Value)Util.toJavaObject(arg,Value.class)),
        new Application(new Invocation(new Application(
          new Invocation(new Variable(new NameBindingImpl(javaClassName, null), unkLoc), "create", null, unkLoc),
          javaObjInit, unkLoc), "parse", null, unkLoc),
          new TupleObject(new TypedAST[] {bufGet, new StringConstant("TSL code")}), unkLoc), unkLoc);


    DefDeclaration parseDef =
        new DefDeclaration("parse",
            new Arrow(parseBufferType, Util.javaToWyvType(TypedAST.class)),
            Arrays.asList(new NameBindingImpl("buf", parseBufferType)),
            body,
            false);


    return new New(new DeclSequence(Arrays.asList(pairedObj, jcd, parseDef)), unkLoc);
  }

View Full Code Here

                                        Environment ntEnv, Reference<Integer> methNum) {
    return (dis) -> {
      String disambiguationCode = dis.getCode();


      List<NameBinding> argNames = dis.getMembers().stream().map(cer->cer.getName().toString())
          .map(name -> new NameBindingImpl(name, Int.getInstance())).collect(Collectors.toList());


      argNames.add(new NameBindingImpl("lexeme", Str.getInstance()));


      SpliceBindExn spliced = LangUtil.spliceBinding(new IParseBuffer(disambiguationCode), argNames, dis.getDisplayName());


      CopperElementName newName = dis.getName();
      String nextName = getNextName(methNum, newName);

View Full Code Here


      Type resType = lhsEnv.lookup(term.getName().toString()).getType();


      splicers.add((termClassType,termObjType) -> {
            SpliceBindExn spliced = LangUtil.spliceBinding(new IParseBuffer(oCode), Arrays.asList(new NameBinding[]{
                new NameBindingImpl("lexeme", Str.getInstance()),
                new NameBindingImpl("pushToken", new Arrow(new Tuple(termObjType, Str.getInstance()), Unit.getInstance())),
                new NameBindingImpl("Terminals", termClassType)}), term.getDisplayName());


            toGen.put(newName, new Pair<>(resType, spliced));
          });


      String newCode = String.format("RESULT = Util.invokeValueVarargs(%s, \"%s\", %s);", PAIRED_OBJECT_NAME, newName, "new StringConstant(lexeme), pushTokenV, terminals");

View Full Code Here

        return parseri;
      }
    };


    TypeDeclaration.attrEvalEnv = Environment.getEmptyEnvironment().extend(new ValueBinding("myNumMetadata", Util.toWyvObj(inner)));
    Assert.assertEquals(res.typecheck(Globals.getStandardEnv().extend(new NameBindingImpl("myNumMetadata", metaType)), Optional.empty()), Int.getInstance());
    res = new DSLTransformer().transform(res);
    Assert.assertEquals(res.evaluate(Globals.getStandardEnv().extend(new ValueBinding("myNumMetadata", Util.toWyvObj(inner)))).toString(), "IntegerConstant(5)");
  }

View Full Code Here

        return parseri;
      }
    };


    TypeDeclaration.attrEvalEnv = Environment.getEmptyEnvironment().extend(new ValueBinding("myNumMetadata", Util.toWyvObj(inner))).extend(new TypeBinding("HasParser", metaType));
    Assert.assertEquals(res.typecheck(Globals.getStandardEnv().extend(new NameBindingImpl("myNumMetadata", metaType)), Optional.empty()), Int.getInstance());
    res = new DSLTransformer().transform(res);
    Assert.assertEquals(res.evaluate(Globals.getStandardEnv().extend(new ValueBinding("myNumMetadata", Util.toWyvObj(inner)))).toString(), "IntegerConstant(5)");
  }

View Full Code Here


  @Test
  public void testSplice1() throws IOException, CopperParserException {
    TypedAST testAST = new Sequence(
        new ValDeclaration("x", new IntegerConstant(4), null),
        new Application(new TSLBlock(new Fn(Arrays.asList(new NameBindingImpl("x", Int.getInstance())),
            new SpliceExn(new Variable(new NameBindingImpl("x", Int.getInstance()), null)))), new IntegerConstant(9), null) );
    Type result = testAST.typecheck(Globals.getStandardEnv(), Optional.<Type>empty());
    Value out = testAST.evaluate(Globals.getStandardEnv());
    int finalRes = ((IntegerConstant)out).getValue();
    Assert.assertEquals(4, finalRes);
  }

View Full Code Here

    int i = 0;
    for (Binding b : bindings) {
      if (b == null)
        continue;
      if (b instanceof NameBindingImpl) {
        NameBindingImpl ni = (NameBindingImpl)b;
        map.put(prefix+":"+i++ +":ni:"+ni.getName(), ni.getType());
      } else if (b instanceof TypeBinding) {
        TypeBinding tb = (TypeBinding)b;
        map.put(prefix+":"+i++ +":tb:"+tb.getName(), tb.getType());
      } else {
        throw new RuntimeException("Unexpected binding");

View Full Code Here

0 1 2

TOP

Related Classes of wyvern.tools.typedAST.core.binding.NameBindingImpl

wyvern.tools.parsing.parselang.CopperTSL

wyvern.tools.tests.CopperTests

wyvern.tools.typedAST.core.declarations.DefDeclaration

wyvern.tools.typedAST.core.declarations.ModuleDeclaration

wyvern.tools.typedAST.core.declarations.ValDeclaration

wyvern.tools.typedAST.core.expressions.Fn

wyvern.tools.typedAST.core.expressions.New

wyvern.tools.typedAST.core.expressions.Variable

wyvern.tools.typedAST.extensions.interop.java.typedAST.JavaMeth

wyvern.tools.typedAST.extensions.interop.java.typedAST.JavaType

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.