OpenCCG is a Java library which can handle both parsing and generation. I’ve mostly used it for surface realization, converting fairly syntactic meaning representations into a natural language text, but you can use it for parsing or for generation from higher-level semantic representations if you’d like.
This tutorial is intended to help you:
- Install the current version of OpenCCG.
We’re partly following the OpenCCG README in these guidelines, and you should defer to the official documentation if anything in this tutorial conflicts with that, unless otherwise noted.
- Java 1.6 or later
- Python 2.4 or later (check Py3 compatibility)
Getting the code
If you want to keep your version up to date with the official releases, the easiest way to do that is to clone the repository from GitHub:
git clone https://github.com/OpenCCG/openccg.git
This will create a directory
openccg/ in your current working directory and
fill it with the code from the project.
Alternatively, you can download a compressed archive of OpenCCG on SourceForge.
At the time of writing, the SourceForge page provides version 0.9.5 while GitHub has version 0.9.6. The differences between these two, however, appear to be purely cosmetic (i.e. the version number was updated when files were prepared for release on GitHub).
Getting required libraries for the Git Repo
The one downside to using
git is that it is not intended to track binary
files, so if you chose to clone the git repo above, you will need to download
the archive from SourceForge anyway in order to get the following libraries:
The libraries are located in the
lib/ directory of
you installed via git, copy these files to the
lib/ directory of your openccg
If you’re installing from SourceForge, they’re already in the right place, so you can ignore this step.
Building and installing OpenCCG
In order to use OpenCCG, we first have to compile the code. This requires setting a few ‘environment variables’ on your computer so it knows where to find (1) the Java Development Kit (JDK) and (2) OpenCCG.
Then we can run the
ccg-build script to build the project and make it
Setting Environment Variables
We have to set at least two environment variables for OpenCCG to work:
JAVA_HOME, which is where our JDK is installed, and
OPENCCG_HOME for the
location of our
bash, you can find out where Java is installed by running
which java. The
following examples show the result on my computer:
$ which java /usr/bin/java
This is often a symbolic link (a shortcut), though, so it is helpful to get the full listing and keep going until we have a real file and not a shortcut:
$ ls -l /usr/bin/java /etc/alternatives/java $ ls -l /etc/alternatives/java /usr/lib/jvm/java-1.8.0-openjdk-22.214.171.124-1.b12.fc25.x86_64/jre/bin/java
We see here that this is the location of
java, but several of the OpenCCG
javac (the Java compiler) by adding
bin/javac to the
environment variable, so we want to set our
If you run into errors, double check that you have
javac installed in addition
java. Plain Java is often distributed as the Java Runtime Environment (JRE)
to run compiled Java code from, e.g.,
.jar files, while
javac is a part of
In Linux & Mac you can use the
bash shell in a terminal window to set
$ export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-126.96.36.199-1.b12.fc25.x86_64
(Note that the
$ is not a part of the command. It just represents the command
If you are using something other than
bash on Mac or Linux, try
googling ‘setting environment variables in OPERATING SYSTEM OR TERMINAL’ for
your operating system or terminal/shell. The OpenCCG README also includes some
details for configuring these variables in Windows.
We should similarly set the environment variable OPENCCG_HOME to point to the
openccg/ directory. If installed to
user’s home directory, this would be
$ export OPENCCG_HOME=/home/user/openccg
on most (all?) Linux distributions.
Setting persistent environment variables
In Linux, you can modify the
.bashrc file located in your user’s home directory
to include the export statements mentioned above. Otherwise you will have to
re-set them every time you want to run OpenCCG in a new session.
In a terminal, navigate to your
openccg/ directory and execute the following:
The OpenCCG project uses Apache’s “Ant” build system to handle all the compiling (and then some).
If this worked, you should see a bunch of output followed by “BUILD SUCCESSFUL” and an estimate of how long the build took.
And that’s it! Now you should be able to use OpenCCG. If you’re not sure what to do next, keep an eye out for additional OpenCCG tutorials in the near future.