#title JObjC
#
# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation.  Oracle designates this
# particular file as subject to the "Classpath" exception as provided
# by Oracle in the LICENSE file that accompanied this code.
#
# This code is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
# version 2 for more details (a copy is included in the LICENSE file that
# accompanied this code).
#
# You should have received a copy of the GNU General Public License version
# 2 along with this work; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#

JObjC core provides a pure Java interface for calling C functions and
sending ObjC messages. Given some information, it can marshal types
automatically.

It also parses BridgeSupport to generate Java wrappers around
Framework bundles. These wrappers rely on the core to provide access
to the C constants, enums, structs, functions, ObjC classes, etc of a
framework.

* How to build it

Your best option is `ant all`. There's an Xcode "B&I" target that
works for buildit.

You'll need a recent JavaNativeFoundation, and perhaps some other
things. Everything is usually there on SnowLeopard (or Leopard after
the common ~javabuild/bin/update runs).

The build process is quite involved. Xcode takes care of the native
parts, ant takes care of the Java parts, and there's an unholy mix of
external targets and hidden dependencies that keep Xcode and ant (and
buildit on top of that) from stepping on each other. So a warning: the
ant and Xcode targets don't have proper dependencies set up because of
this. They have some dependencies configured, but not the entire
chain. This is because of the jumping back and forth between
externals. If you run the aggregate targets (Xcode B&I, ant all, ant
test, ant bench), everything's is good. But if you manually invoke
individual targets, chances are you'll miss something. Let's go over
it all step by step:

** ant gen-pcoder

The PrimitiveCoder subclasses have a lot of boiler plate which
simplifies the generated MixedPrimitiveCoder classes. So instead of
maintaining it, I maintain a tiny Haskell script that spits out the
Java code. This ant target runs that script if Haskell is available on
the system. If it isn't available, this will silently fail. That's
okay, because chances are the PrimitiveCoder.java that you got from
svn is current and does not need to be updated.

** ant build-core / Xcode build-core-java

Build core simply builds the JObjC core java classes, and also
generates headers for the JNI for Xcode.

** ant build-core-native / Xcode build-core-native

Xcode builds the native core, using the headers from the Java core. It
generates libJObjC.dylib.

** ant build-generator / Xcode build-generator-java

ant builds the generator.

** ant run-generator / Xcode run-generator

ant runs the generator, using the core Java and native classes.

What is rungen? And what's run-generator-old? run-generator-old is the
preferred way to run the generator from ant, but there's a strange bug
when running from buildit that causes run-generator-old to
freeze. Pratik was helping me debug it, inspecting the stack and
snooping dtrace probes, but we never found the reason for the
block. So I figured that maybe if I just add a layer of indirection
maybe it'll work around that. And it did. Sad but true.

** ant build-generated / Xcode build-generated-java

Build the generator output.

** ant build-additions / Xcode build-additions-java

Builds java additions.

** ant build-additions-native / Xcode build-additions-native

This builds a new version of libJObjC.dylib. It will rebuild
everything from the core, and include everything from additions.

** ant assemble-product / Xcode assemble-product-java

Create a jar, copy products to destination, etc.

* How to test it

The test cases also contain a Java component and a native component,
and are built similarly to the above. The benchmarks are built
together with the tests. So "ant build-test" and "ant
build-test-native" will build both the benchmarks and the test. "ant
test" will run the test. "ant bench" will run benchmarks. If you only
want to run a specific benchmark, you can pass a regexp in the
environment variable BENCH_MATCH.

<src>
ant test
ant bench
BENCH_MATCH=Foo ant bench
</src>

Test and bench reports will end up in
build/JObjC.build/Debug/test-reports/

* How to use it

Include the jar in your classpath and set your java.library.path to
the directory that contains the dylib. Same thing for app bundles.
