Morning,

While working toward openjfx I encountered a problem with the java-icu4j package required for antlr4 which openjfx requires.  Firstly it's building the wrong source - it's trying to build ic4j-*-src.jar which only contains the java source suitable for browsing in an ide and is thus missing the resource and build files.  So while it creates a package that allows compilation to pass it doesn't actually work.

So I tried creating one from the correct source, and for the sake of it, using the same version as the existing icu4c package - 66.1[1].  The correct java source archive is
icu4j-66_1.tgz I couldn't use git here because the icu git repository requires git lfs.  My system git doesn't have it so i didn't even try to see if git-fetch supports it.

For some reason (unlike icu4c) thi
s is not archived within a single subdirectory which causes at least two problems.  First the gnu-build-system unpack function changes to the first subdirectory it finds after unpacking any archive, which in this case is nothing useful.  This can be hacked around by replacing the unpack function or adding a post-pack modification to run "cd ..". The second is that you cannot apply any patches as the (source (patches --)) function uses an entirely different  mechanism to change to the source root subdirectory where it simply chooses the first directory entry it finds - which at least in this case is a file!  So it fails and aborts.  Of course the patches could just be applied as a post-unpack function in the same manner as substitute* is often used.

I found this second issue by accident, icu4j doesn't need a patch.

For what it's worth by mid last week I went through this and managed to get antlr4 to build (what an awful mess[2]) and have worked out the steps for openjfx but it was such a miserable few days of work that I went and did other things for a while.  So sorry to say that at this point I'm not sure if i'll ever get around to submitting patches for any of this.

Regards,
 Z

[1] https://github.com/unicode-org/icu/releases/tag/release-66-1
[2] antlr.scm work in progress

(define-module (antlr)
 #:use-module (guix packages)
 #:use-module (guix download)
 #:use-module (guix git-download)
 #:use-module (guix build-system ant)
 #:use-module ((guix licenses) #:prefix license:)
 #:use-module (gnu packages)
 #:use-module (gnu packages java))

                                        ; really out of date but this is the version used by antlr4
                                        ; this might want to have javafx.json (the api) as a separate output?
(define-public jsonp
  (package
    (name "jsonp")
    (version "jsonp-1.0.4")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/javaee/jsonp.git")
                    (commit version)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "01r4syivcywpvxkr1hn0az9316pr7qpnx154zzzw0nijfmdlbw7n"))))
    (build-system ant-build-system)
    (arguments
     `(#:jar-name (string-append ,name "-" ,version ".jar")
                  #:tests? #f
                  #:source-dir "impl/src/main/java:api/src/main/java"
                  #:phases
                  (modify-phases %standard-phases
                    (add-before 'build 'fix-build-xml
                      (lambda _
                        (substitute* "build.xml"
                          (("target name=\"compile\">")
                           "target name=\"compile\">
<copy todir=\"${classes.dir}\">
<fileset dir=\"impl/src/main/resources\">
<include name=\"**/*.properties\"/>
</fileset>
</copy>")))))))
    (home-page "https://javaee.github.io/jsonp/")
    (synopsis "JSON Processing api")
    (description "JSON Processing (JSON-P) is a Java API to process
 (for e.g. parse, generate, transform and query) JSON messages. It
 produces and consumes JSON text in a streaming fashion (similar to
 StAX API for XML) and allows to build a Java object model for JSON
 text using API classes (similar to DOM API for XML). ")
    (license license:gpl2))) ; with classpath exception

                                        ; java-icu4j is broken
(define-public java-icu4j-66
  (package
    (name "icu4j")
    (version "66.1")
    (source (origin
              (method url-fetch)
              (uri (string-append
                    "https://github.com/unicode-org/icu/releases/download/release-"
                    (string-map (lambda (x) (if (char=? x #\.) #\- x)) version)
                    "/icu4j-"
                    (string-map (lambda (x) (if (char=? x #\.) #\_ x)) version)
                    ".tgz"))
              (sha256
               (base32
                "1ahdyz9209lwl7knb2l3gmnkkby221p0vpgx70fj4j02rdzgvw0d"))
              ))
    (build-system ant-build-system)
    (arguments
     `(#:tests? #f                      ; no tests included
                #:phases
                (modify-phases %standard-phases
                  (replace 'unpack
                    (lambda* (#:key source #:allow-other-keys)
                      (mkdir "source")
                      (chdir "source")
                      (invoke "tar" "xvf" source)))

                  (replace 'install
                    (lambda* (#:key outputs #:allow-other-keys)
                      (let ((out (assoc-ref outputs "out")))
                        (mkdir-p (string-append out "/share/java"))
                        (copy-file "icu4j.jar" (string-append out "/share/java/icu4j-" ,version ".jar"))
                        #t)))
                  )
                )
     )
    (home-page "http://site.icu-project.org/")
    (synopsis "International Components for Unicode")
    (description
     "ICU is a set of C/C++ and Java libraries providing Unicode and
globalisation support for software applications.  This package contains the
Java part.")
    (license license:x11)))

(define-public antlr4
  (package
    (name "antlr4")
    (version "4.7.2")
    (source (origin
              (method git-fetch)
              (uri (git-reference
                    (url "https://github.com/antlr/antlr4")
                    (commit version)))
              (file-name (git-file-name name version))
              (sha256
               (base32
                "1pl0zs6c6wx9nmq30s7ccpc3dl72az55i8vfp574fw9sywmvxmlj"))
              (patches
               (search-patches "antlr-template.patch"))
              ))


    (build-system ant-build-system)
    (arguments
     `(#:jar-name (string-append ,name "-" ,version ".jar")
                  #:source-dir "tool/src:runtime/Java/src:build/gensrc/tool"
                  #:tests? #f
                  #:phases
                  (modify-phases %standard-phases
                    (add-after 'install 'bin-install
                      (lambda* (#:key inputs outputs #:allow-other-keys)
                        (let ((jar (string-append (assoc-ref outputs "out") "/share/java"))
                              (bin (string-append (assoc-ref outputs "out") "/bin")))
                          (mkdir-p bin)
                          (with-output-to-file (string-append bin "/antlr4")
                            (lambda _
                              (display
                               (string-append "#!" (which "sh") "\n"
                                              "java -cp " jar "/" ,name "-" ,version ".jar:"
                                              (string-concatenate
                                               (find-files (assoc-ref inputs "stringtemplate")
                                                           ".*\\.jar"))
                                              ":"
                                              (string-concatenate
                                               (find-files (assoc-ref inputs "stringtemplate4")
                                                           ".*\\.jar"))
                                              ":"
                                              (string-concatenate
                                               (find-files (string-append
                                                            (assoc-ref inputs "antlr")
                                                            "/lib")
                                                           ".*\\.jar"))
                                              " org.antlr.Tool $*"))))
                          (chmod (string-append bin "/antlr4") #o755))
                        #t))
                    (add-after 'configure 'generate-grammar
                      (lambda _
                        (invoke "antlr3"
                                "-o", "build/gensrc",
                                "tool/src/org/antlr/v4/codegen/SourceGenTriggers.g"
                                "tool/src/org/antlr/v4/parse/ANTLRLexer.g"
                                "tool/src/org/antlr/v4/parse/ANTLRParser.g"
                                "tool/src/org/antlr/v4/parse/ATNBuilder.g"
                                "tool/src/org/antlr/v4/parse/ActionSplitter.g"
                                "tool/src/org/antlr/v4/parse/BlockSetTransformer.g"
                                "tool/src/org/antlr/v4/parse/GrammarTreeVisitor.g"
                                "tool/src/org/antlr/v4/parse/LeftRecursiveRuleWalker.g")
                        #t))
                    (add-after 'generate-grammar 'build-runtime
                      (lambda _
                        (mkdir-p "build/classes")
                        (apply invoke "javac"
                               "-source" "1.7"
                               "-target" "1.7"
                               "-d" "build/classes"
                               (find-files "runtime/Java/src" "\\.java$"))))
                    (add-after 'build-runtime 'build-controller
                                        ; replicate functionality of maven-stringtemplate-plugin as there is no tool for it(?)
                      (lambda* (#:key inputs #:allow-other-keys)
                        (with-output-to-file "build/gensrc/MakeTemplate.java"
                          (lambda _
                            (display "import org.stringtemplate.v4.ST;
import org.stringtemplate.v4.STGroup;
import org.stringtemplate.v4.STGroupDir;
import org.stringtemplate.v4.misc.ErrorBuffer;
import org.stringtemplate.v4.AutoIndentWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Map;

public class MakeTemplate {
    public static void main(String[] argv) {
        String dir=argv[0];
        String name=argv[1];
        String res=argv[2];

        STGroup group = new STGroupDir(dir);
        ST st = group.getInstanceOf(name);

        for (Map.Entry<String,Object> e: org.antlr.v4.unicode.UnicodeDataTemplateController.getProperties().entrySet())
            st.add(e.getKey(), e.getValue());

        try (FileWriter out = new FileWriter(res)) {
            ErrorBuffer listener = new ErrorBuffer();
            st.write(new AutoIndentWriter(out), listener);
            if(!listener.errors.isEmpty())
                throw new IOException(listener.toString());
        } catch (IOException x) {
            x.printStackTrace(System.err);
            System.exit(1);
        }
    }
}")))
                        (mkdir "build/genclasses")
                        (invoke "javac"
                                "-d" "build/genclasses"
                                "-classpath"
                                (string-join
                                 (append
                                  '("build/classes")
                                  (find-files (assoc-ref inputs "stringtemplate") "\\.jar$")
                                  (find-files (assoc-ref inputs "icu4j") "\\.jar$"))
                                 ":")
                                "tool/src/org/antlr/v4/unicode/UnicodeDataTemplateController.java"
                                "build/gensrc/MakeTemplate.java")
                        #t))
                    (add-after 'build-controller 'process-templates
                      (lambda* (#:key inputs #:allow-other-keys)
                        (mkdir-p "build/gensrc/tool/org/antlr/v4/unicode")
                        (invoke "java"
                                "-classpath"
                                (string-join
                                 (append
                                  '("build/classes" "build/genclasses")
                                  (find-files (assoc-ref inputs "stringtemplate") "\\.jar$")
                                  (find-files (assoc-ref inputs "antlr3") "\\.jar$")
                                  (find-files (assoc-ref inputs "icu4j") "\\.jar$"))
                                 ":")
                                "MakeTemplate"
                                "tool/resources/org/antlr/v4/tool/templates"
                                "unicodedata"
                                "build/gensrc/tool/org/antlr/v4/unicode/UnicodeData.java")))
                    (add-before 'build 'fix-build-xml
                      (lambda _
                        (substitute* "build.xml"
                          (("target name=\"compile\">")
                           "target name=\"compile\">
<copy todir=\"${classes.dir}\">
<fileset dir=\"tool/resources\">
<include name=\"**/*.stg\"/>
<include name=\"**/*.st\"/>
<include name=\"**/*.sti\"/>
</fileset>
</copy>")
                          (("(<javac.*srcdir=\"tool/src[^>]*)/>" all letters)
                           (string-append letters "><exclude name=\"org/antlr/v4/unicode/UnicodeDataTemplateController.java\"/>
<exclude name=\"org/antlr/v4/gui/**\"/>
</javac>")))
                        #t)))))
    (native-inputs
     `(("icu4j" ,java-icu4j-66)
       ("antlr3" ,antlr3)
       ))
    (inputs
     `(("junit" ,java-junit)
       ("stringtemplate" ,java-stringtemplate)
       ("jsonp" ,jsonp)
       ))
    (propagated-inputs
     `(
       ("antlr3" ,antlr3)
       ("stringtemplate" ,java-stringtemplate)
       ))
    (home-page "https://www.antlr.org")
    (synopsis "Framework for constructing recognisers, compilers, and translators")
    (description "ANTLR, ANother Tool for Language Recognition, (formerly PCCTS)
is a language tool that provides a framework for constructing recognisers,
compilers, and translators from grammatical descriptions containing Java, C#,
C++, or Python actions.  ANTLR provides excellent support for tree construction,
tree walking, and translation.")
    (license license:bsd-3)))