| import java.nio.charset.Charset |
| import java.util.function.Function |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // This adds javacc generation support. |
| |
| configure(rootProject) { |
| configurations { |
| javacc |
| } |
| |
| dependencies { |
| javacc "net.java.dev.javacc:javacc:${scriptDepVersions['javacc']}" |
| } |
| |
| task javacc() { |
| description "Regenerate sources for corresponding javacc grammar files." |
| group "generation" |
| |
| dependsOn allprojects.collect { prj -> prj.tasks.withType(JavaCCTask) } |
| } |
| } |
| |
| /** |
| * Utility function to read a file, apply changes to its content and write it back. |
| */ |
| def modifyFile = { File path, Function<String, String> modify -> |
| Function<String, String> normalizeEols = { text -> text.replace("\r\n", "\n") } |
| modify = normalizeEols.andThen(modify).andThen(normalizeEols) |
| |
| String original = path.getText("UTF-8") |
| String modified = modify.apply(original) |
| if (!original.equals(modified)) { |
| path.write(modified, "UTF-8") |
| } |
| } |
| |
| def commonCleanups = { FileTree generatedFiles -> |
| // This is a minor typo in a comment that nonetheless people have hand-corrected in the past. |
| generatedFiles.matching({ include "CharStream.java" }).each {file -> |
| modifyFile(file, { text -> |
| return text.replace( |
| "implemetation", |
| "implementation"); |
| }) |
| } |
| |
| generatedFiles.each {file -> |
| modifyFile(file, { text -> |
| // Normalize EOLs and tabs (EOLs are a side-effect of modifyFile). |
| text = text.replace("\t", " "); |
| text = text.replaceAll("JavaCC - OriginalChecksum=[^*]+", "(filtered)") |
| text = text.replace("StringBuffer", "StringBuilder") |
| return text |
| }) |
| } |
| |
| generatedFiles.matching({ include "*TokenManager.java" }).each { file -> |
| modifyFile(file, { text -> |
| // Remove redundant imports. |
| text = text.replaceAll( |
| /(?m)^import .+/, |
| "") |
| // Add CharStream imports. |
| text = text.replaceAll( |
| /package (.+)/, |
| ''' |
| package $1 |
| import org.apache.lucene.queryparser.charstream.CharStream; |
| '''.trim()) |
| // Eliminates redundant cast message. |
| text = text.replace( |
| "int hiByte = (int)(curChar >> 8);", |
| "int hiByte = curChar >> 8;") |
| // Access to forbidden APIs. |
| text = text.replace( |
| "public java.io.PrintStream debugStream = System.out;", |
| "// (debugStream omitted).") |
| text = text.replace( |
| "public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }", |
| "// (setDebugStream omitted).") |
| return text |
| }) |
| } |
| } |
| |
| configure(project(":lucene:queryparser")) { |
| task javaccParserClassic(type: JavaCCTask) { |
| description "Regenerate classic query parser from lucene/queryparser/classic/QueryParser.jj" |
| group "generation" |
| |
| javaccFile = file('src/java/org/apache/lucene/queryparser/classic/QueryParser.jj') |
| |
| afterGenerate << commonCleanups |
| afterGenerate << { FileTree generatedFiles -> |
| generatedFiles.matching { include "QueryParser.java" }.each { file -> |
| modifyFile(file, { text -> |
| text = text.replace( |
| "public QueryParser(CharStream ", |
| "protected QueryParser(CharStream ") |
| text = text.replace( |
| "public QueryParser(QueryParserTokenManager ", |
| "protected QueryParser(QueryParserTokenManager ") |
| text = text.replace( |
| "new java.util.ArrayList<int[]>", |
| "new java.util.ArrayList<>") |
| return text |
| }) |
| } |
| } |
| } |
| |
| task javaccParserSurround(type: JavaCCTask) { |
| description "Regenerate surround query parser from lucene/queryparser/surround/parser/QueryParser.jj" |
| group "generation" |
| |
| javaccFile = file('src/java/org/apache/lucene/queryparser/surround/parser/QueryParser.jj') |
| |
| afterGenerate << commonCleanups |
| afterGenerate << { FileTree generatedFiles -> |
| generatedFiles.matching { include "QueryParser.java" }.each { file -> |
| modifyFile(file, { text -> |
| text = text.replace( |
| "import org.apache.lucene.analysis.TokenStream;", |
| "") |
| text = text.replace( |
| "new java.util.ArrayList<int[]>", |
| "new java.util.ArrayList<>") |
| return text |
| }) |
| } |
| } |
| } |
| |
| task javaccParserFlexible(type: JavaCCTask) { |
| description "Regenerate Flexible query parser from queryparser/flexible/standard/parser/StandardSyntaxParser.jj" |
| group "generation" |
| |
| javaccFile = file('src/java/org/apache/lucene/queryparser/flexible/standard/parser/StandardSyntaxParser.jj') |
| |
| afterGenerate << commonCleanups |
| afterGenerate << { FileTree generatedFiles -> |
| generatedFiles.matching { include "ParseException.java" }.each { file -> |
| modifyFile(file, { text -> |
| // Modify constructor. |
| text = text.replace( |
| "class ParseException extends Exception", |
| "class ParseException extends QueryNodeParseException") |
| |
| // Modify imports. |
| text = text.replace( |
| "package org.apache.lucene.queryparser.flexible.standard.parser;", '''\ |
| package org.apache.lucene.queryparser.flexible.standard.parser; |
| |
| import org.apache.lucene.queryparser.flexible.messages.*; |
| import org.apache.lucene.queryparser.flexible.core.*; |
| import org.apache.lucene.queryparser.flexible.core.messages.*; |
| ''') |
| |
| // Modify constructors and code bits |
| text = text.replaceAll( |
| /(?s)[ ]*public ParseException\(Token currentTokenVal[^}]+[}]/, '''\ |
| public ParseException(Token currentTokenVal, |
| int[][] expectedTokenSequencesVal, String[] tokenImageVal) |
| { |
| super(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, initialise( |
| currentTokenVal, expectedTokenSequencesVal, tokenImageVal))); |
| this.currentToken = currentTokenVal; |
| this.expectedTokenSequences = expectedTokenSequencesVal; |
| this.tokenImage = tokenImageVal; |
| } |
| ''') |
| |
| text = text.replaceAll( |
| /(?s)[ ]*public ParseException\(String message\)[^}]+[}]/, '''\ |
| public ParseException(Message message) |
| { |
| super(message); |
| } |
| ''') |
| |
| text = text.replaceAll( |
| /(?s)[ ]*public ParseException\(\)[^}]+[}]/, '''\ |
| public ParseException() |
| { |
| super(new MessageImpl(QueryParserMessages.INVALID_SYNTAX, "Error")); |
| } |
| ''') |
| return text |
| }) |
| } |
| |
| generatedFiles.matching { include "StandardSyntaxParser.java" }.each { file -> |
| modifyFile(file, { text -> |
| // Remove redundant cast |
| text = text.replace( |
| "new java.util.ArrayList<int[]>", |
| "new java.util.ArrayList<>") |
| text = text.replace( |
| "new ArrayList<QueryNode>()", |
| "new ArrayList<>()") |
| text = text.replace( |
| "Collections.<QueryNode> singletonList", |
| "Collections.singletonList") |
| return text |
| }) |
| } |
| } |
| } |
| |
| task javacc() { |
| description "Regenerate query parsers (javacc syntax definitions)." |
| group "generation" |
| |
| dependsOn javaccParserClassic |
| dependsOn javaccParserSurround |
| dependsOn javaccParserFlexible |
| } |
| } |
| |
| configure(project(":solr:core")) { |
| task javacc(type: JavaCCTask) { |
| description "Regenerate Solr query parser" |
| group "generation" |
| |
| javaccFile = file('src/java/org/apache/solr/parser/QueryParser.jj') |
| |
| |
| afterGenerate << commonCleanups |
| afterGenerate << { FileTree generatedFiles -> |
| generatedFiles.matching { include "QueryParser.java" }.each { file -> |
| modifyFile(file, { text -> |
| text = text.replace( |
| "public QueryParser(CharStream ", |
| "protected QueryParser(CharStream ") |
| text = text.replace( |
| "public QueryParser(QueryParserTokenManager ", |
| "protected QueryParser(QueryParserTokenManager ") |
| text = text.replace( |
| "final private LookaheadSuccess jj_ls =", |
| "static final private LookaheadSuccess jj_ls =") |
| return text |
| }) |
| } |
| } |
| } |
| } |
| |
| |
| |
| // We always regenerate, no need to declare outputs. |
| class JavaCCTask extends DefaultTask { |
| @Input |
| File javaccFile |
| |
| /** |
| * Apply closures to all generated files before they're copied back |
| * to mainline code. |
| */ |
| @Optional |
| @Input |
| List<Closure<FileTree>> afterGenerate = new ArrayList<>() |
| |
| JavaCCTask() { |
| dependsOn(project.rootProject.configurations.javacc) |
| } |
| |
| @TaskAction |
| def generate() { |
| if (!javaccFile || !javaccFile.exists()) { |
| throw new GradleException("Input file does not exist: ${javaccFile}") |
| } |
| |
| // Run javacc generation into temporary folder so that we know all the generated files |
| // and can post-process them easily. |
| def tempDir = this.getTemporaryDir() |
| tempDir.mkdirs() |
| project.delete project.fileTree(tempDir, { include: "**/*.java" }) |
| |
| def targetDir = javaccFile.parentFile |
| logger.lifecycle("Regenerating JavaCC:\n from: ${javaccFile}\n to: ${targetDir}") |
| |
| def output = new ByteArrayOutputStream() |
| def result = project.javaexec { |
| classpath { |
| project.rootProject.configurations.javacc |
| } |
| |
| ignoreExitValue = true |
| standardOutput = output |
| errorOutput = output |
| |
| main = "org.javacc.parser.Main" |
| args += [ |
| "-OUTPUT_DIRECTORY=${tempDir}", |
| javaccFile |
| ] |
| } |
| |
| // Unless we request verbose logging, don't emit javacc output. |
| if (result.exitValue != 0) { |
| throw new GradleException("JavaCC failed to compile ${javaccFile}, here is the compilation output:\n${output}") |
| } |
| |
| // Make sure we don't have warnings. |
| if (output.toString(Charset.defaultCharset()).contains("Warning:")) { |
| throw new GradleException("JavaCC emitted warnings for ${javaccFile}, here is the compilation output:\n${output}") |
| } |
| |
| // Apply any custom modifications. |
| def generatedFiles = project.fileTree(tempDir) |
| |
| afterGenerate.each {closure -> |
| closure.call(generatedFiles) |
| } |
| |
| // Copy back to mainline sources. |
| project.copy { |
| from tempDir |
| into targetDir |
| |
| // We don't need CharStream interface as we redirect to our own. |
| exclude "CharStream.java" |
| } |
| } |
| } |
