import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
public static ActionParser<Tree> createParser(Charset charset) {
    return new OneCParser(
            charset,
            OneCLexer.createGrammarBuilder(),
            OneCGrammar.class,
            new TreeFactory(),
            new OneCNodeBuilder(),
            OneCLexer.COMPILATION_UNIT);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
public static ParserAssert assertThat(LexerlessGrammarBuilder b, GrammarRuleKey rule) {
    return new ParserAssert(new ActionParser<Tree>(
            Charsets.UTF_8,
            b,
            OneCGrammar.class,
            new TreeFactory(),
            new OneCNodeBuilder(),
            rule));
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
@Override
protected Model<Location> buildModel(final SensorContext context) {
	// Result
	final Model<Location> model = new Model<>();
	final ModelCreatingTreeVisitor visitor = new ModelCreatingTreeVisitor(model);

	// Read all source files
	final ActionParser<Tree> parser = JavaParser.createParser();
	final JavaClasspath javaClassPath = new JavaClasspath(settings, context.fileSystem());
	final FileSystem fs = context.fileSystem();

	// Scan only main files for the 'current' language.
	final FilePredicate filesToScan = fs.predicates().and(fs.predicates().hasType(Type.MAIN),
			fs.predicates().hasLanguage(LANGUAGE));

	for (final InputFile file : fs.inputFiles(filesToScan)) {
		// Parse source
		LOGGER.debug("Analyzing source file: {}", file.relativePath());
		try {
			visitor.on(file);
			final Tree tree = parser.parse(file.contents());

			// Create semantic model
			LOGGER.debug("Creating semantic model ...");
			SemanticModel.createFor((CompilationUnitTree) tree, javaClassPath.getElements());

			// Read into model
			LOGGER.debug("Reading model ...");
			tree.accept(visitor);

		} catch (final IOException e) {
			LOGGER.warn("Could not read contents for {}", file.relativePath(), e);
		}
	}
	return model;
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new CssParser(
    charset,
    LexicalGrammar.createCssGrammar(),
    CssGrammar.class,
    new TreeFactory(),
    new CssNodeBuilder(),
    rootRule);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new EmbeddedCssParser(
    charset,
    LexicalGrammar.createEmbeddedCssGrammar(),
    EmbeddedCssGrammar.class,
    new TreeFactory(),
    new EmbeddedCssNodeBuilder(),
    rootRule);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new LessParser(
    charset,
    LexicalGrammar.createLessGrammar(),
    LessGrammar.class,
    new TreeFactory(),
    new LessNodeBuilder(),
    rootRule);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new ScssParser(
    charset,
    LexicalGrammar.createScssGrammar(),
    ScssGrammar.class,
    new TreeFactory(),
    new ScssNodeBuilder(),
    rootRule);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
private static void verify(CssCheck check, File file, Charset charset, ActionParser<Tree> parser, String language) {

    TreeImpl tree = (TreeImpl) parser.parse(file);
    CssTreeVisitorContext context = new CssTreeVisitorContext(tree, file, language);

    CssCheckVerifier checkVerifier = new CssCheckVerifier();
    checkVerifier.scanFile(context);

    List<TestIssue> expectedIssues = checkVerifier.expectedIssues
      .stream()
      .sorted((i1, i2) -> Integer.compare(i1.line(), i2.line()))
      .collect(Collectors.toList());

    if (check instanceof CharsetAwareVisitor) {
      ((CharsetAwareVisitor) check).setCharset(charset);
    }
    Iterator<Issue> actualIssues = getActualIssues(check, context);

    for (TestIssue expected : expectedIssues) {
      if (actualIssues.hasNext()) {
        verifyIssue(expected, actualIssues.next(), file);
      } else {
        throw new AssertionError("Missing issue at line " + expected.line() + " in file " + file.getAbsolutePath());
      }
    }

    if (actualIssues.hasNext()) {
      Issue issue = actualIssues.next();
      throw new AssertionError("Unexpected issue at line " + line(issue) + ": \"" + message(issue) + "\"" + " in file " + file.getAbsolutePath());
    }
  }
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
public static Collection<CheckMessage> getIssues(String relativePath, CssCheck check, ActionParser<Tree> parser) {
  File file = new File(relativePath);

  TreeImpl tree = (TreeImpl) parser.parse(file);
  CssTreeVisitorContext context = new CssTreeVisitorContext(tree, file, "css");
  List<Issue> issues = check.scanFile(context);

  return getCheckMessages(issues);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new ActionParser<>(
    charset,
    JavaPropertiesLexicalGrammar.createGrammar(),
    JavaPropertiesGrammar.class,
    new TreeFactory(),
    new JavaPropertiesNodeBuilder(),
    rootRule);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
private static ActionParser<Tree> createParser(Charset charset, GrammarRuleKey rootRule) {
  return new ActionParser<>(
    charset,
    JSONLexicalGrammar.createGrammar(),
    JSONGrammar.class,
    new TreeFactory(),
    new JSONNodeBuilder(),
    rootRule);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
public ParserAssert(ActionParser<Tree> actual) {
    super(ParserAssert.class, actual);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
@VisibleForTesting
public static ActionParser<Tree> createTestParser(Charset charset, GrammarRuleKey rootRule) {
  return createParser(charset, rootRule);
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
public ActionParser<Tree> parser() {
  return parser;
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return CssParser.createParser(fileSystem.encoding());
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return EmbeddedCssParser.createParser(fileSystem.encoding());
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return LessParser.createParser(fileSystem.encoding());
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
@Override
public ActionParser<Tree> parser(FileSystem fileSystem) {
  return ScssParser.createParser(fileSystem.encoding());
}
 

import com.sonar.sslr.api.typed.ActionParser; //导入依赖的package包/类
public abstract ActionParser<Tree> parser(FileSystem fileSystem);