private static void initializeLanguages() { for (Language language : LanguageRegistry.getLanguages()) { for (LanguageVersion languageVersion : language.getVersions()) { LanguageVersionHandler languageVersionHandler = languageVersion.getLanguageVersionHandler(); if (languageVersionHandler != null) { languageVersionHandler.getXPathHandler().initialize(); } } } } }
@Override public TokenManager getTokenManager(String fileName, Reader source) { TokenManager tokenManager = createTokenManager(source); tokenManager.setFileName(fileName); return tokenManager; }
/** * Get the Languages of a given source file. * * @param fileName * The file name. * @return The Languages for the source file, may be empty. */ public List<Language> getLanguagesForFile(String fileName) { String extension = getExtension(fileName); return LanguageRegistry.findByExtension(extension); }
private JavaTokenFilter createTokenFilter(final SourceCode sourceCode) { final StringBuilder stringBuilder = sourceCode.getCodeBuffer(); // Note that Java version is irrelevant for tokenizing final LanguageVersionHandler languageVersionHandler = LanguageRegistry.getLanguage(JavaLanguageModule.NAME) .getVersion("1.4").getLanguageVersionHandler(); final TokenManager tokenMgr = languageVersionHandler.getParser(languageVersionHandler.getDefaultParserOptions()) .getTokenManager(sourceCode.getFileName(), new StringReader(stringBuilder.toString())); return new JavaTokenFilter(tokenMgr, ignoreAnnotations); }
private static LanguageVersion[] getSupportedLanguageVersions() { List<LanguageVersion> languageVersions = new ArrayList<>(); for (LanguageVersion languageVersion : LanguageRegistry.findAllVersions()) { LanguageVersionHandler languageVersionHandler = languageVersion.getLanguageVersionHandler(); if (languageVersionHandler != null) { Parser parser = languageVersionHandler.getParser(languageVersionHandler.getDefaultParserOptions()); if (parser != null && parser.canParse()) { languageVersions.add(languageVersion); } } } return languageVersions.toArray(new LanguageVersion[0]); }
static Node getCompilationUnit(LanguageVersionHandler languageVersionHandler, String code) { Parser parser = languageVersionHandler.getParser(languageVersionHandler.getDefaultParserOptions()); Node node = parser.parse(null, new StringReader(code)); languageVersionHandler.getSymbolFacade().start(node); languageVersionHandler.getTypeResolutionFacade(Designer.class.getClassLoader()).start(node); return node; }
public String getVersion() { if (version != null) { return version; } return LanguageRegistry.findLanguageByTerseName(getLanguage()).getDefaultVersion().getVersion(); }
public static LanguageVersion defaultLanguageVersion() { return LanguageRegistry.getDefaultLanguage().getDefaultVersion(); }
private void usesDFA(LanguageVersion languageVersion, Node rootNode, RuleSets ruleSets, Language language) { if (ruleSets.usesDFA(language)) { try (TimedOperation to = TimeTracker.startOperation(TimedOperationCategory.DFA)) { VisitorStarter dataFlowFacade = languageVersion.getLanguageVersionHandler().getDataFlowFacade(); dataFlowFacade.start(rootNode); } } }
public String getLanguage() { return language != null ? language : LanguageRegistry.getDefaultLanguage().getTerseName(); }
private void throwUnknownLanguageVersionException(String minOrMax, String unknownVersion) { throw new IllegalArgumentException("Unknown " + minOrMax + " Language Version '" + unknownVersion + "' for Language '" + language.getTerseName() + "' for Rule " + name + "; supported Language Versions are: " + LanguageRegistry.commaSeparatedTerseNamesForLanguageVersion(language.getVersions())); }
public String label() { LanguageVersionHandler languageVersionHandler = getLanguageVersionHandler(); StringWriter writer = new StringWriter(); languageVersionHandler.getDumpFacade(writer, "", false).start(node); return writer.toString(); }
/** * This implementation returns a new instance of {@link ParserOptions} using * default settings. * * @see Rule#setPriority(RulePriority) */ @Override public ParserOptions getParserOptions() { return new ParserOptions(); }
private static String supportedVersions() { return "Languages and version suported:" + PMD.EOL + LanguageRegistry.commaSeparatedTerseNamesForLanguage(LanguageRegistry.findWithRuleSupport()) + PMD.EOL; }
@Override public Language fromString(String string) { return LanguageRegistry.findLanguageByTerseName(string); } });
/** * Set the given LanguageVersions as the current default for their * Languages. * * @param languageVersions * The LanguageVersions. */ public void setDefaultLanguageVersions(List<LanguageVersion> languageVersions) { for (LanguageVersion languageVersion : languageVersions) { languageVersionDiscoverer.setDefaultLanguageVersion(languageVersion); } }
/** * This class encapsulates the access to the DataFlowNode class. Is this * worthwhile? TODO I think it's too confusing to have the DataFlowNode * constructor add the created instance to the List. I think it'd be clearer * if we did that more "procedurally", i.e., create the object, then add it * to the list. */ public DataFlowNode createNewNode(Node node) { return dataFlowHandler.createDataFlowNode(dataFlow, node); }
/** * Perform all initialization. */ public static void initialize(IndependentContext context) { context.declareNamespace("pmd", "java:" + PMDFunctions.class.getName()); for (Language language : LanguageRegistry.getLanguages()) { for (LanguageVersion languageVersion : language.getVersions()) { LanguageVersionHandler languageVersionHandler = languageVersion.getLanguageVersionHandler(); if (languageVersionHandler != null) { languageVersionHandler.getXPathHandler().initialize(context); } } } }
@Override public ParserOptions getDefaultParserOptions() { return new ParserOptions(); }