import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
public static HBSourceRootNode parse(HBLanguage language, Source source) throws Exception {
  Parser parser = new Parser(language, source);
  HBSourceRootNode program = parser.Parse();

  // if (parser.errors.size() > 0) {
  //   StringBuilder message = new StringBuilder("Error(s) parsing script:\n");
  //   for (String error : parser.errors) {
  //     message.append(error).append("\n");
  //   }
  //   throw new Exception(message.toString());
  // } else {
  //
  // }

  if (parser.errors.count > 0) {
    throw new Exception("Error parsing program");
  }

  return program;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
  Source source = request.getSource();
  HBSourceRootNode program = ParserWrapper.parse(this, source);

  System.out.println(program.toString());

  // Bootstrap the builtin node targets and the builtin types in the
  // type-system.
  BuiltinNodes builtinNodes = BuiltinNodes.bootstrap(this);
  Index index = Index.bootstrap(builtinNodes);

  InferenceVisitor visitor = new InferenceVisitor(index);
  program.accept(visitor);

  return Truffle.getRuntime().createCallTarget(program);
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
private void processCoverage(final long counterVal,
    final SourceSection sourceSection, final Map<String, Long[]> coverageMap) {
  Long[] array;
  Source s = sourceSection.getSource();
  String path = s.getPath() != null ? s.getPath() : s.getName();

  if (coverageMap.containsKey(path)) {
    array = coverageMap.get(path);
  } else if (s.getLineCount() == 0) {
    return;
  } else {
    array = new Long[s.getLineCount()];
    coverageMap.put(path, array);
  }

  int line = sourceSection.getStartLine() - 1;
  updateLine(array, line, counterVal);
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
@Test
public void checkCoverageMapForTestSLFile() throws IOException {
  InputStream testSlFile = getClass().getResourceAsStream("test.sl");
  Source testSl = Source.newBuilder(new InputStreamReader(testSlFile)).
      name(TEST_FILE).mimeType("application/x-sl").
      build();

  engine.eval(testSl);

  Map<String, Long[]> result = covInst.getCoverageMap(new HashMap<>());

  assertTrue(result.containsKey(TEST_FILE));
  Long[] lines = result.get(TEST_FILE);

  assertArrayEquals(new Long[] {
      null, 0L, 0L, 0L, null, null,
      null, null, 20L, null, 120L, 100L, null, null, 20L, null, null,
      null, 1L, null, 21L, 20L, 20L, 20L, 0L, null, null, null}, lines);
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
public MixinDefinition loadModule(final Source source) throws IOException {
  URI uri = source.getURI();
  if (loadedModules.containsKey(uri)) {
    return loadedModules.get(uri);
  }

  MixinDefinition module;
  try {
    module = compiler.compileModule(source, structuralProbe);
    loadedModules.put(uri, module);
    return module;
  } catch (ProgramDefinitionError e) {
    vm.errorExit(e.toString());
    throw new IOException(e);
  }
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
public void addSyntheticInitializerWithoutSuperSendOnlyForThingClass() {
  SSymbol init = MixinBuilder.getInitializerName(Symbols.NEW);
  MethodBuilder builder = new MethodBuilder(true, initializerBuilder.getLanguage());
  builder.setSignature(init);
  builder.addArgument("self",
      SomLanguage.getSyntheticSource("self read", "super-class-resolution")
                 .createSection(1));

  Source source = SomLanguage.getSyntheticSource("self", "Thing>>" + init.getString());
  SourceSection ss = source.createSection(0, 4);
  builder.setVarsOnMethodScope();
  builder.finalizeMethodScope();
  SInvokable thingInitNew = builder.assembleInitializer(
      builder.getSelfRead(ss), AccessModifier.PROTECTED, ss);
  instanceDispatchables.put(init, thingInitNew);
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
public Parser(final String content, final long fileSize, final Source source,
    final StructuralProbe structuralProbe, final SomLanguage language) throws ParseError {
  this.source = source;
  this.language = language;

  sym = NONE;
  nextSym = NONE;

  if (fileSize == 0) {
    throw new ParseError("Provided file is empty.", NONE, this);
  }

  lexer = new Lexer(content);

  getSymbolFromLexer();

  this.syntaxAnnotations = new HashSet<>();
  this.structuralProbe = structuralProbe;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
private static void processCoverage(final long counterVal,
    final SourceSection sourceSection, final Map<Source, Long[]> coverageMap) {
  Long[] array;
  Source src = sourceSection.getSource();
  if (coverageMap.containsKey(src)) {
    array = coverageMap.get(src);
  } else if (src.getLineCount() == 0) {
    return;
  } else {
    array = new Long[src.getLineCount()];
    coverageMap.put(src, array);
  }

  int line = sourceSection.getStartLine() - 1;
  if (array[line] == null) {
    array[line] = counterVal;
  } else {
    array[line] = Math.max(counterVal, array[line]);
  }
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
private CovStats getCoverageStats(final Map<Source, Long[]> coverageMap) {
  int linesLoaded = 0;
  int linesExecuted = 0;
  int linesWithStatements = 0;

  for (Entry<Source, Long[]> e : coverageMap.entrySet()) {
    Long[] lines = e.getValue();
    linesLoaded += lines.length;

    for (Long l : lines) {
      if (l != null) {
        linesWithStatements += 1;

        long val = l;
        if (val > 0) {
          linesExecuted += 1;
        }
      }
    }
  }

  return new CovStats(linesLoaded, linesExecuted, linesWithStatements);
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
private JSONObjectBuilder sectionToJson(final SourceSection ss, final String id,
    final Map<Source, String> sourceToId) {
  JSONObjectBuilder builder = JSONHelper.object();

  builder.add("id", id);
  builder.add("firstIndex", ss.getCharIndex());
  builder.add("length", ss.getCharLength());
  builder.add("sourceId", sourceToId.get(ss.getSource()));

  // TODO: add tags to section, need to get it from some tag map, I think
  // if (ss.getTags() != null && ss.getTags().length > 0) {
  // JSONArrayBuilder arr = JSONHelper.array();
  // for (String tag : ss.getTags()) {
  // arr.add(tag);
  // }
  // builder.add("tags", arr);
  // }

  builder.add("data", collectDataForSection(ss));

  return builder;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
@Override
protected PolyglotEngine prepareVM(final PolyglotEngine.Builder preparedBuilder)
    throws IOException {

  VM vm = new VM(new VmOptions(new String[] {
      "--kernel", VmOptions.STANDARD_KERNEL_FILE,
      "--platform", VmOptions.STANDARD_PLATFORM_FILE}), true);
  preparedBuilder.config(SomLanguage.MIME_TYPE, SomLanguage.VM_OBJECT, vm);

  InputStream in = getClass().getResourceAsStream("TruffleSomTCK.ns");
  Source source = Source.newBuilder(new InputStreamReader(in)).mimeType(
      mimeType()).name("TruffleSomTCK.ns").build();
  PolyglotEngine engine = preparedBuilder.build();

  Value tckModule = engine.eval(source);
  SClass tck = tckModule.as(SClass.class);

  ObjectTransitionSafepoint.INSTANCE.register();
  tck.getMixinDefinition().instantiateObject(tck, vm.getVmMirror());
  ObjectTransitionSafepoint.INSTANCE.unregister();
  return engine;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
@Override
public Throwable fillInStackTrace() {
    SourceSection sourceSection = this.getSourceSection();
    Source source = sourceSection != null ? sourceSection.getSource() : null;
    String sourceName = source != null ? source.getName() : null;
    int lineNumber;
    try {
        lineNumber = sourceSection != null ? sourceSection.getLineLocation().getLineNumber() : -1;
    } catch (UnsupportedOperationException e) {
        /*
         * SourceSection#getLineLocation() may throw an UnsupportedOperationException.
         */
        lineNumber = -1;
    }
    StackTraceElement[] traces = new StackTraceElement[] {
            new StackTraceElement(filename(sourceName),
                    this.getMethodName(),
                    sourceName,
                    lineNumber)
    };
    this.setStackTrace(traces);
    return this;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
private static void startREPL() throws IOException {
    Console console = System.console();
    while (true) {
        // READ
        String data = console.readLine(PROMPT);
        if (data == null) {
            // EOF sent
            break;
        }
        MumblerContext context = new MumblerContext();
        Source source = Source.fromText(data, "<console>");
        ListSyntax sexp = Reader.read(source);
        // TODO : replace with MumblerLanguage#parse
        Converter converter = new Converter(flags.tailCallOptimizationEnabled);
        MumblerNode[] nodes = converter.convertSexp(context, sexp);

        // EVAL
        Object result = execute(nodes, context.getGlobalFrame());

        // PRINT
        if (result != MumblerList.EMPTY) {
            System.out.println(result);
        }
    }
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
@Override
public IStrategoTerm parse(Source src, @Nullable String overridingStartSymbol) {
	if (parser == null) {
		createParser();
	}
	String startSymbol = this.startSymbol;
	if (overridingStartSymbol != null) {
		startSymbol = overridingStartSymbol;
	}

	try {
		final Disambiguator disambiguator = parser.getDisambiguator();
		disambiguator.setFilterPriorities(false);
		SGLRParseResult parseResult = parser.parse(IOUtils.toString(src.getInputStream(), Charset.defaultCharset()),
				src.getPath(), startSymbol);
		IStrategoTerm term = (IStrategoTerm) parseResult.output;
		return term;
	} catch (SGLRException | InterruptedException | IOException e) {
		throw new IllegalStateException("File failed to parse", e);
	}

}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
@TruffleBoundary
public static SClass compileClass(final String path, final String file,
    final SClass systemClass, final Universe universe)
    throws IOException {
  String fname = path + File.separator + file + ".som";
  FileReader stream = new FileReader(fname);

  File f = new File(fname);
  Source source = Source.newBuilder(f).build();
  Parser parser = new Parser(stream, f.length(), source, universe);

  SClass result = compile(parser, systemClass, universe);

  SSymbol cname = result.getName();
  String cnameC = cname.getString();

  if (file != cnameC) {
    throw new IllegalStateException("File name " + file
        + " does not match class name " + cnameC);
  }

  return result;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
    Source source = request.getSource();

    try(IndexedPushbackReader r = new IndexedPushbackReader(source.getReader())) {
        List<CallTarget> callTargets = new ArrayList<>();

        while(true) {
            int startIndex = r.getPosition();

            Object form = Reader.read(r);

            if (form == null) {
                break;
            }

            RootNode expr = Analyzer.analyzeRoot(this, form, source.createSection(startIndex, r.getPosition()-startIndex-1));
            callTargets.add(Truffle.getRuntime().createCallTarget(expr));
        }

        SequenceNode node = new SequenceNode(callTargets.toArray(new CallTarget[0]));
        RootNode root = new RootNode(this, null, node);
        //NodeUtil.printCompactTree(System.out, root);

        return Truffle.getRuntime().createCallTarget(root);
        //return Truffle.getRuntime().createCallTarget(new RootNode(null, null, doNode));
    }
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
public Object eval(String s) {
    Source code = Source.newBuilder(s)
            .name("<eval>")
            .interactive()
            .mimeType(Language.MIME_TYPE)
            .build();

    return eval(code);
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
HBSourceRootNode  Source() {
	HBSourceRootNode  result;
	HBStatementNode[] statements = SourceStatements();
	result = HBSourceRootNodeFactory.create(
	 this.language,
	 source.createUnavailableSection(),
	 statements);
	return result;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
private static Source getSource(SLFunction function) {
    SourceSection section = function.getCallTarget().getRootNode().getSourceSection();
    if (section != null) {
        return section.getSource();
    }
    return null;
}
 

import com.oracle.truffle.api.source.Source; //导入依赖的package包/类
public SomParser(final String content, final long fileSize, final Source source,
    final SomStructures structuralProbe, final SomLanguage lang) throws ParseError {
  super(content, fileSize, source, structuralProbe, lang);
  // assert structuralProbe != null : "Needed for this extended parser.";
  this.struturalProbe = structuralProbe;
  sourceSections = new ArrayDeque<>();
}