[libimdb-commit] CVS: libimdb Makefile,NONE,1.1 README,NONE,1.1 constants.mk,NONE,1.1 rules.mk,NONE,1.1

[Jerry V. <jve...@us...>]

Update of /cvsroot/libimdb/libimdb
In directory sc8-pr-cvs1:/tmp/cvs-serv11812

Added Files:
	Makefile README constants.mk rules.mk 
Log Message:
initial checkin

--- NEW FILE: Makefile ---
#
# $Id: Makefile,v 1.1 2003/06/16 04:18:37 jveldhuis Exp $
#

SUBPROJECTS := include libjlog parser java demo

include config.mk

ifneq "$(origin PROJECT_TOP)" "undefined"
include constants.mk
endif

build clean clobber depend: config.mk
	@for sub in $(SUBPROJECTS); do \
		[ -d $$sub ] || continue; \
		$(ECHO) "`$(DATECMD)`: $@ing $$sub"; \
		(cd $$sub; $(MAKE) $@) || exit 1; \
	done;

distclean: clobber
	rm -f config.mk

install:
	@[ -d $(INSTALL_ROOT) ] || mkdir -p $(INSTALL_ROOT)

config\
config.mk: Makefile
	@echo "creating config.mk..."
	@(echo "PROJECT_TOP=`pwd`";\
	  echo "JAVA_COMPILER=SUNJava14" ;\
	  echo "JAVA_RUNTIME=SUNJava14" ;\
	  echo "JAVADOC_RUNTIME=SUNJava14" ;\
	  echo "RT_JAR=SUNJava14" ;\
	  ) > config.mk

--- NEW FILE: README ---

Short list to get things out.
 - build env
 - roll out c library
 - roll out beta java interface
 - simple web page and setup of cvs, mailing lists etc.
 - will want to use something like mpatrol to assess what
   the memory requirements are for different parts of the
   library.
 - need to version things.
   libimdb_getVersion();

   libimdb_getListFileInfo(); ??

 - is it easy to convert lfetch to a c program ?
   libimdb_updateListFile();

 - look at perl script to just get list files
 - look at perl script to get and merge list diff files.

Things to be done
-----------------

Since movie lables are the key to the database, maybe a temperary
(option) on-disk db database to hold the movie info and rest of
them return references to entries via a movie key. The user does
a second set of lookups when the movie detail is needed. Making
it optional means not paying the disk price and instead paying
the memory price. (may also just be a runtime optional though,
since we may want to use an in-memory db still - this could be
substituted for a non-db solution later).

Guess that means we may need to lookup movies by key, but also
generate a list of movie label based results when searching by
title. This may require a second pass over the movie database.

Need to take a closer look at all the list file to assess if
this is the best strategy.

Simpler scan actor db one at a time - callbacks get a single actors
  and multiple movie keys (and char info).

perl interface and callback using swig'd interface
 - build simple example and look for help via
   perl5 book and swig mailing list.

  - support callback or first/next... processing ?
    - first/next might be just simpler for perl
    - probably pretty easy to support both.

libjlog
  - main log_open should initialize default
    logtracker and logtee from env variables
    - do we want this to happen every log_open ?
      - yes
  - how do we define filters ?
    - file/func filters
    - in/out filters
    - regexp ?
    - config file

  - can mklog.pl generate/manage the list of
    modules supported ? Would require that
    enum gets initialized though.
    - one enum should alwyas be MOD_OKAY=0

  - completely separate tree for jvlog ?

  - can success/failure callback be combined
    with current callback mechanism ?

  - support success call from void function

  - LOGerror_e should become LOGvalues_e
    and include LOG_SUCCESS=0, enum values should be negative
    for error

  - how can we get gcc to check __attribute()__ stuff ?

nuke build environment and re-write.

 - use simple gmake makefiles that need to be
   massaged to work....

 - could have basic configure at the top.

 - swig generation should be separate target and
   not part of normal build.
    - change name of .javaswig file to not specify
      packaging, explicit move command and rmdir
      with warnings if files end up lying around

 - cvs ci should include java generated c etc.

 - can I or should I use sysinclude.h ?
   - probably don't need it... would need to test port to
     cygwin for compiling into a dll.

   - can probably keep it if I get rid of Precise/Invidi
     related bits (NATIVE_WINDOWS)
     (switch if !defined(NATIVE_WINDOWS) to if defined(LINUX))
     etc.

Utility for downloading/managing ftp list files

What is this thing for ?
------------------------
- look at what Scott did for mysql loading.

- look at xmltv2db on sf for a basic example of
  putting data into jdbc database - now sure how useful this is.

- support gzip'd list files.
  - www.gzip.org/zlib
    - can probably just include it.

- need bigger picture plan... what is libimdb ?
  - for use with tv_imdb ?
    - maybe tv_imdb just uses a libimdb database
      - libimdb's own database could just be a
	series of text files in sorted key order.
	then use look to locate things.
      - perl interface kept simple, while libimdb
	could use binary search algorithm.
      - still doesn't require mysql and is platform
	independent.
      - what other db options are out there ? gdbm ?
      - nothing to say we can't use dynamic libimdb.so
        for searching, provide a generic interface
	that includes what you want for tv_imdb
        Then just have java and a perl interface.

    - guess a perl script is the easies to load
      things into mysql ?

    - xml output of db entry (probably useful for
      debugging as well).

    - xmlrpc ? what is it, is it useful here ?

  - linux and windows supported ?
  - load imdb data into hsqldb / mysqldb
    - how do we standardize on db tables ?
    - how do you look flexible ?
    - interface must support db clean, load
    - way in the future what can we do about doing
      minimal updates ? Can we only update the table
      entries that changed since the last fresh build ?
      Maybe the parse should support an update
      operation ? How do we identify things that have
      to be removed ? Can we ? Maybe intermediate db
      (flat sorted index) and a compare or refresh mysql
      utility.
  - query data 
  - do all of this from java and perl

- can I build a java centric database loader (int hsqldb ?)
  - what kind of progress bars are in java ?

  - JFreeChart to plot things ?
    - number of actors / movie
    - years of movies ?
    - present stats generated from loader ?
    - actors to actresses totals
    - movie ratings (user rated) against years

- what about a imdb server that has XML-RPC interfaces
  for queries ?
  perl use Soap::Lite package (www.soaplite.com)

--- NEW FILE: constants.mk ---
#
# $Id: constants.mk,v 1.1 2003/06/16 04:18:37 jveldhuis Exp $
#

#
# Required re-defined variables
#  PROJECT_TOP
#  JAVA_COMPILER (see comments below)
#  JAVA_RUNTIME (see comments below)
#  JAVADOC_RUNTIME (see comments below)
#

COMPILE_BIN=$(PROJECT_TOP)/bin

HOST_DETAILED_ARCH := $(shell uname -m)
HOST_DETAILED_OS   := $(shell uname -sr | sed 's/ /-/')
HOST_NAME          := $(shell uname -n)

__HOST_ARCH__ :=case "$(HOST_DETAILED_ARCH)" in \
     sun4u) echo sun4;; \
  586|i586) echo i586;; \
  686|i686) echo i686;; \
         *) echo "bad HOST_DETAILED_ARCH: $(HOST_DETAILED_ARCH)" >&2; exit 1;; \
      esac

HOST_ARCH := $(shell $(__HOST_ARCH__))

__HOST_OS__ :=case "$(HOST_DETAILED_OS)" in \
     Linux-2.*) echo LINUX;; \
  CYGWIN_NT-5*) echo CYGWIN;; \
             *) echo "bad HOST_DETAILED_OS: $(HOST_DETAILED_OS)" >&2; exit 1;; \
          esac

HOST_OS := $(shell $(__HOST_OS__))

__HOST_OS_VERSION__ :=case "$(HOST_DETAILED_OS)" in \
	Linux-2.*) echo 2;; \
	Windows_NT-4) echo 4;; \
	*) echo "bad HOST_OS: $(HOST_OS)" >&2; exit 1;; \
	esac

HOST_OS_VERSION := $(shell $(__HOST_OS_VERSION__))

# backward compatibility
OS=$(HOST_OS)

#
# BUILD_ARCH / _OS and _PLATFORM
#
BUILD_ARCH      =$(HOST_ARCH)
BUILD_OS        =$(HOST_OS)
BUILD_OS_VERSION=$(HOST_OS)$(HOST_OS_VERSION)
BUILD_PLATFORM  =$(HOST_ARCH)-$(HOST_OS)

#
# TARGET_ARCH / _OS and _PLATFORM
#
TARGET_ARCH      =$(BUILD_ARCH)
TARGET_OS        =$(BUILD_OS)
TARGET_OS_VERSION=$(BUILD_OS_VERSION)
TARGET_PLATFORM  =$(TARGET_ARCH)-$(TARGET_OS)

#
# list of TARGET_PLATFORMS we currently support
#
ifneq "$(TARGET_PLATFORM)" "i686-LINUX"
  ifneq "$(TARGET_PLATFORM)" "i686-CYGWIN"
    ifneq "$(TARGET_PLATFORM)" "i686-MINGW"
      $(error invalid TARGET_PLATFORM="$(TARGET_PLATFORM)")
    endif
  endif
endif

# WHOAMI_LINUX   := /usr/bin/whoami
# WHOAMI_CYGWIN  := /bin/whoami
# WHOAMI = $(WHOAMI_$(BUILD_OS))
#
# USER_NAME := $(shell $(WHOAMI))

CLASSPATH_SEP_CYGWIN  :=;
CLASSPATH_SEP_LINUX   :=:
CLASSPATH_SEP=$(CLASSPATH_SEP_$(BUILD_OS))

# used by among other things javadoc
SOURCEPATH_SEP_CYGWIN  :=;
SOURCEPATH_SEP_LINUX   :=:
SOURCEPATH_SEP=$(SOURCEPATH_SEP_$(BUILD_OS))

# these are used for commands like $(subst $(space),$(SEP),$(PATH))
empty:=
space:=$(empty) $(empty)
dot:=.
slash:=/
colon:=:
semicolon:=;
plus:=+

# create shell-ready classpath given an argument that is a space separated
# list of paths
# - we no longer use this function since make screws up the $$ expansion
#   in $(call) function usage in make 
#createClassPath=$(subst $(space),$(CLASSPATH_SEP),$(strip $(1)))


AR_CYGWIN  := /bin/ar
AR_LINUX   := /usr/bin/ar
AR = $(AR_$(BUILD_OS))

ARFLAGS = cr

AWK_CYGWIN   := /bin/awk
AWK_LINUX    := /bin/awk
AWK = $(AWK_$(BUILD_OS))

BISON_CYGWIN  := /bin/bison
BISON_LINUX   := /usr/bin/bison
BISON         = $(BISON_$(BUILD_OS))

CHMOD_CYGWIN  := /bin/chmod
CHMOD_LINUX   := /bin/chmod
CHMOD         = $(CHMOD_$(BUILD_OS))

CMP_CYGWIN  := /bin/cmp
CMP_LINUX   := /usr/bin/cmp
CMP         = $(CMP_$(BUILD_OS))

CC_CYGWIN  := /usr/bin/gcc
CC_LINUX   := /usr/bin/gcc
CC          = $(CC_$(BUILD_OS))

# define CC_COMPILER as being the basename of the compiler.
# this can be (is) used to switch between compiler-dependent flags etc
# (it replaces the previous CC_BASENAME, mostly we may have compilers
#  whose basenames aren't legal gmake variables ie CFLAGS_g++)
#CC_BASENAME = $(notdir $(basename $(filter-out perl, $(CC_$(BUILD_OS)))))
CC_COMPILER = $(subst $(plus),x,$(notdir $(basename $(filter-out perl, $(CC_$(BUILD_OS))))))

CXX_CYGWIN  := /usr/bin/g++
CXX_LINUX   := /usr/bin/g++
CXX          = $(CXX_$(BUILD_OS))

# define CXX_COMPILER as being the basename of the compiler.
# this can be (is) used to switch between compiler-dependent flags etc
# (it replaces the previous CXX_BASENAME, mostly we may have compilers
#  whose basenames aren't legal gmake variables ie CFLAGS_g++)
#CXX_BASENAME = $(notdir $(basename $(filter-out perl, $(CCC_$(BUILD_OS)))))
CXX_COMPILER = $(subst $(plus),x,$(notdir $(basename $(CXX_$(BUILD_OS)))))

# extensions:
O_CYGWIN  :=o
O_LINUX   :=o
O:=$(O_$(BUILD_OS))

A_CYGWIN  :=lib
A_LINUX   :=a
A:=$(A_$(BUILD_OS))

SO_CYGWIN  :=dll
SO_LINUX   :=so
SO:=$(SO_$(BUILD_OS))

JAR:=jar

# placing a value in PROFILE causes compilation for coverage analysis:
# this includes:
# - stoping creation of dynamic libraries or installation of them.
# - object files to not be compiled with position independent code (-fpic).
# - adds -a to CFLAGS to turn on gcc basic block profiling.
# - binaries link with static (.a) libs instead of dynamic (.so).
# sideffects 
#   - for this to work, everyone has to compile both a dynamic and static lib
#   - makefiles must use $(SO) for library extenions in LIBS definitions
#PROFILE := yes

ifdef PROFILE
   BUILDING_DYNAMIC :=false
   CFLAGS_FPIC:=
   CFLAGS_PROFILE=-a
   SO=$(A)

   # for now, the same as CFLAGS_FPIC
   CCFLAGS_FPIC	:=$(CFLAGS_FPIC)
else
   # BUILDING_DYNAMIC says whether we are building dynamic libraries for this
   # release. The value can be overriden in a particular Makefile.
   BUILDING_DYNAMIC_CYGWIN  :=true
   BUILDING_DYNAMIC_LINUX   :=true
   BUILDING_DYNAMIC =$(BUILDING_DYNAMIC_$(BUILD_OS))

   CFLAGS_FPIC_CYGWIN_gcc      :=
   CFLAGS_FPIC_LINUX_gcc       :=-fpic
   CFLAGS_FPIC	:=$(CFLAGS_FPIC_$(BUILD_OS)_$(CC_COMPILER))

   # for now, the same as CFLAGS_FPIC
   CCFLAGS_FPIC	:=$(CFLAGS_FPIC)

   CFLAGS_PROFILE=
endif

# it's important to build the dynamic objects first because:
# - OBJS_TYPE=DYNAMIC causes -fpic (or equivalent) to be added to CFLAGS
# - there is no distinction between dynamic and static object directories
#   on Solaris, SunOS, Linux ..., so only the first make will build anything.
#   So, we want that one build to have -fpic defined in order to make the
#   dynamic libraries.  If we were efficiency nuts we could make two object
#   directories on all platforms.
ifdef DYNAMIC
OBJS_TYPE =DYNAMIC
else
OBJS_TYPE =STATIC
endif

#BUILD_BASE=bdir-$(BUILD_OS)-$(TARGET_OS)
BUILD_BASE=bdir-$(BUILD_OS)
BUILD_CFG=$(BUILD_BASE)
BUILD_DIR=$(BUILD_CFG)

# override should contain $(BUILD_CFG) eg. BUILD_DIR = ../$(BUILD_CFG)
# BUILD_CFG should never contain a slash

OBJS_CFG_CYGWIN  =$(BUILD_CFG)
OBJS_CFG_LINUX   =$(BUILD_CFG)
OBJS_CFG         =$(OBJS_CFG_$(BUILD_OS))

OBJS_DIR =$(OBJS_CFG)

# CFLAGS, CCFLAGS and CPPFLAGS are not set by := so that project
# specific flags can be set like
#	CFLAGS += ...
# in leaf Makefile

CFLAGS_gcc   :=-O -g -Wall -Wstrict-prototypes -Wmissing-prototypes -Wshadow -Waggregate-return

#  -fcheck-memory-usage
CFLAGS_gcc_LINUX  :=

CFLAGS_gcc_TARGET_MINGW  :=-mno-cygwin

# this doens't work if you have empty defines :)
#ifeq "$(CFLAGS_$(CC_COMPILER))" "undef"
#   $(error CFLAGS_$(CC_COMPILER)) was left undefined, fix constants.mk)
#endif

CFLAGS_DYNAMIC := $(CFLAGS_FPIC)
CFLAGS_STATIC  :=

CFLAGS=$(filter-out $(CFLAGS_DROP),$(CFLAGS_PROFILE) $(CFLAGS_$(CC_COMPILER)) $(CFLAGS_$(CC_COMPILER)_$(BUILD_OS)) $(CFLAGS_$(CC_COMPILER)_TARGET_$(BUILD_OS)) $(CFLAGS_$(OBJS_TYPE)))

# note: -mno-cygwin removed from CCFLAGS_cxx_CYGWIN so default is to build dependent on cygwin
CCFLAGS_gxx  :=-g -Wall -Wstrict-prototypes -Wmissing-prototypes -Wshadow

CCFLAGS_gxx_TARGET_MINGW  :=-mno-cygwin

# this doens't work if you have empty defines :)
#ifeq "$(CCFLAGS_$(CXX_COMPILER))" ""
#   $(error CCFLAGS_$(CXX_COMPILER)) was left undefined, fix constants.mk)
#endif
CCFLAGS_DYNAMIC := $(CCFLAGS_FPIC)
CCFLAGS_STATIC  :=

CCFLAGS =$(filter-out $(CCFLAGS_DROP),$(CCFLAGS_$(CXX_COMPILER)) $(CCFLAGS_$(CXX_COMPILER)_BUILD_$(BUILD_OS)) $(CCFLAGS_$(CXX_COMPILER)_TARGET_$(TARGET_OS)) $(CCFLAGS_$(OBJS_TYPE)))

CPPFLAGS_gcc :=

# this doens't work if you have empty defines :)
#ifeq "$(CPPFLAGS_$(CC_COMPILER))" ""
#   $(error CPPFLAGS_$(CC_COMPILER)) was left undefined, fix constants.mk)
#endif
CPPFLAGS =$(filter-out $(CPPFLAGS_DROP),$(CPPFLAGS_$(CC_COMPILER)) -D$(BUILD_OS) -D$(BUILD_OS_VERSION))

DATE_CYGWIN   := /bin/date
DATE_LINUX    := /bin/date
DATE = $(DATE_$(BUILD_OS))

DATECMD := $(DATE) '+%h %d %T'

DU_CYGWIN  := /bin/du
DU_LINUX   := /bin/du
DU          = $(DU_$(BUILD_OS))

DUFLAGS = -sk

ETAGS_CYGWIN  := /bin/etags
ETAGS_LINUX   := /usr/bin/etags
ETAGS          = $(ETAGS_$(BUILD_OS))

FIND_CYGWIN   := /bin/find
FIND_LINUX    := /usr/bin/find
FIND = $(FIND_$(BUILD_OS))

TAIL_CYGWIN   := /bin/tail
TAIL_LINUX    := /bin/tail
TAIL = $(TAIL_$(BUILD_OS))

LEX_CYGWIN  := /bin/flex
LEX_LINUX   := /usr/bin/flex
LEX          = $(LEX_$(BUILD_OS))

LEXFLAGS = -t

# default MASSAGE is a no-op
MASSAGE := /bin/true

RM_CYGWIN   := /bin/rm
RM_LINUX    := /bin/rm
RM = $(RM_$(BUILD_OS))

MV_CYGWIN   := /bin/mv
MV_LINUX    := /bin/mv
MV = $(MV_$(BUILD_OS))

CP_CYGWIN   := /bin/cp
CP_LINUX    := /bin/cp
CP = $(CP_$(BUILD_OS))

CAT_CYGWIN   := /bin/cat
CAT_LINUX    := /bin/cat
CAT = $(CAT_$(BUILD_OS))

SH_CYGWIN   := /bin/sh
SH_LINUX    := /bin/sh
SH = $(SH_$(BUILD_OS))

TAR_CYGWIN   := /bin/tar
TAR_LINUX    := /bin/tar
TAR = $(TAR_$(BUILD_OS))

SLEEP_CYGWIN   := /bin/sleep
SLEEP_LINUX    := /bin/sleep
SLEEP = $(SLEEP_$(BUILD_OS))

ISPELL_CYGWIN   := /usr/local/bin/ispell
ISPELL_LINUX    := /usr/bin/ispell
ISPELL = $(ISPELL_$(BUILD_OS))

STRIP_CYGWIN  := /bin/strip
STRIP_LINUX   := /usr/bin/strip
STRIP          = $(STRIP_$(BUILD_OS))

SED_CYGWIN   := /bin/sed
SED_LINUX    := /bin/sed
SED = $(SED_$(BUILD_OS))

TOUCH_CYGWIN   := /bin/touch
TOUCH_LINUX    := /bin/touch
TOUCH = $(TOUCH_$(BUILD_OS))

DIRNAME_CYGWIN   := /bin/dirname
DIRNAME_LINUX    := /bin/dirname
DIRNAME = $(DIRNAME_$(BUILD_OS))

RMDIR_CYGWIN   := /bin/rmdir
RMDIR_LINUX    := /bin/rmdir
RMDIR = $(RMDIR_$(BUILD_OS))

GZIP_CYGWIN   := /bin/gzip
GZIP_LINUX    := /bin/gzip
GZIP = $(GZIP_$(BUILD_OS))

ZIP_CYGWIN   := /bin/zip
ZIP_LINUX    := /bin/zip
ZIP = $(ZIP_$(BUILD_OS))

UNZIP_CYGWIN   := /bin/unzip
UNZIP_LINUX    := /usr/bin/unzip
UNZIP = $(UNZIP_$(BUILD_OS))

WC_CYGWIN   := /bin/wc
WC_LINUX    := /usr/bin/wc
WC = $(WC_$(BUILD_OS))

LD   :=$(CC)
LDXX :=$(CXX)

LDD_CYGWIN  := false
LDD_LINUX   := /usr/bin/ldd
LDD := $(LDD_$(BUILD_OS))

# need the real ld to create dynamic libraries:
LD_DYNAMIC_CYGWIN  :=/usr/bin/gcc
LD_DYNAMIC_LINUX   :=/usr/bin/ld
LD_DYNAMIC          =$(LD_DYNAMIC_$(BUILD_OS))
LD_DYNAMIC_BASENAME =$(subst $(plus),x,$(notdir $(basename $(LD_DYNAMIC))))

# need the real ld to create dynamic libraries containing c++ source:
LDXX_DYNAMIC_CYGWIN  :=/usr/bin/g++
LDXX_DYNAMIC_LINUX   :=/usr/bin/g++
LDXX_DYNAMIC          =$(LDXX_DYNAMIC_$(BUILD_OS))
LDXX_DYNAMIC_BASENAME =$(subst $(plus),x,$(notdir $(basename $(LDXX_DYNAMIC))))

# note: -mno-cygwin removed from LD_DYNAMIC_FLAGS_CYGWIN so default is to build dependent on cygwin
LD_DYNAMIC_FLAGS_gcc_BUILD_CYGWIN  =-shared -Wl,--add-stdcall-alias
LD_DYNAMIC_FLAGS_ld_BUILD_LINUX    =-shared -h $(basename $(@F))

LD_DYNAMIC_FLAGS_gxx_TARGET_MINGW  :=-mno-cygwin

LD_DYNAMIC_FLAGS=$(LD_DYNAMIC_FLAGS_$(LD_DYNAMIC_BASENAME)_BUILD_$(BUILD_OS)) \
	         $(LD_DYNAMIC_FLAGS_$(LD_DYNAMIC_BASENAME)_TARGET_$(TARGET_OS))

# note: -mno-cygwin removed from LDXX_DYNAMIC_FLAGS_CYGWIN so default is to build dependent on cygwin
LDXX_DYNAMIC_FLAGS_gxx_BUILD_CYGWIN  =-shared -Wl,--add-stdcall-alias
LDXX_DYNAMIC_FLAGS_gxx_BUILD_LINUX   =-shared -Wl,'-h $(basename $(@F))'

LDXX_DYNAMIC_FLAGS_gxx_TARGET_MINGW  =-mno-cygwin

LDXX_DYNAMIC_FLAGS=$(LDXX_DYNAMIC_FLAGS_$(LDXX_DYNAMIC_BASENAME)_BUILD_$(BUILD_OS)) \
		   $(LDXX_DYNAMIC_FLAGS_$(LDXX_DYNAMIC_BASENAME)_TARGET_$(TARGET_OS))

# the distributed m4 doesn't handle -D command line arguments correctly,
# so we use the gnu one.
M4_CYGWIN  := /bin/m4
M4_LINUX   := /usr/bin/m4
M4          = $(M4_$(BUILD_OS))

RANLIB_CYGWIN  := :
RANLIB_LINUX   := :
RANLIB          = $(RANLIB_$(BUILD_OS))

SORT_CYGWIN  := /bin/sort
SORT_LINUX   := /bin/sort
SORT         = $(SORT_$(BUILD_OS))

MKDIR_CYGWIN   := /bin/mkdir
MKDIR_LINUX    := /bin/mkdir
MKDIR = $(MKDIR_$(BUILD_OS))

MKPATH = $(MKDIR) -p

ECHO_CYGWIN   := /bin/echo
ECHO_LINUX    := /bin/echo
ECHO = $(ECHO_$(BUILD_OS))

EXPR_CYGWIN   := /bin/expr
EXPR_LINUX    := /usr/bin/expr
EXPR = $(EXPR_$(BUILD_OS))

LS_CYGWIN  := /bin/ls
LS_LINUX   := /bin/ls
LS	   = $(LS_$(BUILD_OS))

TR_CYGWIN  := /bin/tr
TR_LINUX   := /usr/bin/tr
TR	   = $(TR_$(BUILD_OS))

LN_CYGWIN  := /bin/ln
LN_LINUX   := /bin/ln
LN	   = $(LN_$(BUILD_OS))

EGREP_CYGWIN  := /bin/egrep
EGREP_LINUX   := /bin/egrep
EGREP = $(EGREP_$(BUILD_OS))

HOSTNAME := $(HOST_NAME)

NM_CYGWIN  := /bin/nm
NM_LINUX   := /usr/bin/nm
NM = $(NM_$(BUILD_OS))

# since some of the perl packages we use fail
# to work under perl-5.6.0, on some linux boxes we
# install a later version that works in /usr/local/bin/perl.
# sigh...

PERL_CYGWIN        := /usr/bin/perl
PERL_LINUX         := /usr/bin/perl
PERL = $(PERL_$(BUILD_OS))

# PERL_INCLUDE is used for building swig projects providing perl interfaces
PERL_INCLUDE         :=$(shell $(PERL) -e 'use Config; print "$$Config{archlib}/CORE";')

RSH_CYGWIN      := /bin/rsh
RSH_LINUX       := /bin/rsh
RSH             = $(RSH_$(BUILD_OS))

# place for optionally installed software
# - no real criteria of what belongs here, since
#   what is called optional is rarely is (optional)
#   and optional may be included in the standard
#   installation for a given system
SWIG_CYGWIN  :=/usr/bin/swig
SWIG_LINUX   :=/usr/local/bin/swig
SWIG = $(SWIG_$(BUILD_OS))

TEST_CYGWIN   :=/usr/bin/test
TEST_LINUX    :=/usr/bin/test
TEST = $(TEST_$(BUILD_OS))

DOXYGEN_CYGWIN  :=
DOXYGEN_LINUX   :=/usr/bin/doxygen
DOXYGEN = $(DOXYGEN_$(BUILD_OS))

#
# Java compilers and JVMs
#

# for convience we define the install path for sun javac
SUNJava14_HOME_CYGWIN  :=c:/j2sdk1.4
SUNJava14_HOME_LINUX   :=/usr/java/j2sdk1.4
SUNJava14_HOME         :=$(SUNJava14_HOME_$(BUILD_OS))

# JAVAC
# - requires JAVA_COMPILER be one of:
#   SUNJava14
#   Do *not* use Jikes 1.13 -- it is broken.
#
ifeq "$(JAVA_COMPILER)" "SUNJava14"
JAVAC_CYGWIN :=$(SUNJava14_HOME)/bin/javac
JAVAC_LINUX  :=$(SUNJava14_HOME)/bin/javac
JAVAC         =$(JAVAC_$(BUILD_OS))
endif

ifeq "$(JAVAC)" ""
   $(error JAVAC was left undefined, failed to find JAVA_COMPILER '$(JAVA_COMPILER)')
endif

# JAVA
# - requires JAVA_RUNTIME be one of:
#   SUNJava14
#
ifeq "$(JAVA_RUNTIME)" "SUNJava14"
JAVA_CYGWIN :=$(SUNJava14_HOME)/bin/java
JAVA_LINUX  :=$(SUNJava14_HOME)/bin/java
JAVA         =$(JAVA_$(BUILD_OS))
endif

ifeq "$(JAVA)" ""
   $(error JAVA was left undefined, failed to find JAVA_RUNTIME '$(JAVA_RUNTIME)')
endif

# JAVADOC
# - requires JAVADOC_RUNTIME be one of:
#   SUNJava14
#
ifeq "$(JAVADOC_RUNTIME)" "SUNJava14"
JAVADOC_CYGWIN :=$(SUNJava14_HOME)/bin/javadoc
JAVADOC_LINUX  :=$(SUNJava14_HOME)/bin/javadoc
JAVADOC         =$(JAVADOC_$(BUILD_OS))
endif

ifeq "$(JAVADOC)" ""
   $(error JAVADOC was left undefined, failed to find JAVADOC_RUNTIME '$(JAVADOC_RUNTIME)')
endif

# JAR
# - requires JAR_RUNTIME be one of:
#   SUNJava14
#
ifeq "$(JAR_RUNTIME)" "SUNJava14"
JAR_CYGWIN :=$(SUNJava14_HOME)/bin/jar
JAR_LINUX  :=$(SUNJava14_HOME)/bin/jar
JAR         =$(JAR_$(BUILD_OS))
endif

ifeq "$(JAR)" ""
   $(error JAR was left undefined, failed to find JAR_RUNTIME '$(JAR_RUNTIME)')
endif

# RT_JAR
# - requires RT_JAR be one of:
#   SUNJava14
#
# JNI_INCLUDE
# - used for swig projects building jni interfaces
#
ifeq "$(RT_JAR)" "SUNJava14"
RT_JAR_HOME_CYGWIN :=$(SUNJava14_HOME)
RT_JAR_HOME_LINUX  :=$(SUNJava14_HOME)
RT_JAR_HOME         =$(RT_JAR_HOME_$(BUILD_OS))

JNI_INCLUDE_DIR    :=$(SUNJava14_HOME)/include
endif

ifeq "$(RT_JAR_HOME)" ""
   $(error RT_JAR_HOME was left undefined, failed to find RT_JAR '$(RT_JAR)')
endif

ifeq "$(JNI_INCLUDE_DIR)" ""
   $(error JNI_INCLUDE_DIR was left undefined, check RT_JAR '$(RT_JAR)' defines)
endif

JNI_CPPFLAGS_CYGWIN :=-I$(JNI_INCLUDE_DIR)/win32
JNI_CPPFLAGS_LINUX  :=-I$(JNI_INCLUDE_DIR)/linux
JNI_CPPFLAGS        :=-I$(JNI_INCLUDE_DIR) $(JNI_CPPFLAGS_$(BUILD_OS))

# JAVAC compiler flags
#
# swap -O for -g for optimized
JAVAC_FLAGS_SUNJava14    :=-deprecation -encoding iso-8859-1 -source 1.4 -target 1.4 -g:none -g

JAVAC_FLAGS =$(JAVAC_FLAGS_$(JAVA_COMPILER))

JAVAC_CLASSPATH:=
JAVAC_SOURCEPATH=.

# define PROJECT_TOP in java runtime environment (mostly for testing utilites)
#JAVA_FLAGS =-DPROJECT_TOP=$(PROJECT_TOP) -DproxySet=true -DproxyHost=proxy -DproxyPort=3128
JAVA_FLAGS =-DPROJECT_TOP=$(PROJECT_TOP)

# Now add the remaining stuff
JAVA_CLASSPATH +=$(JAR_CLASSPATH)

# path to java sources
JAVA_SRCS_SOURCEPATH_CYGWIN :=$(RT_JAR_HOME)/src
JAVA_SRCS_SOURCEPATH_LINUX  :=$(RT_JAR_HOME)/src
JAVA_SRCS_SOURCEPATH        :=$(JAVA_SRCS_SOURCEPATH_$(BUILD_OS))

JAVADOC_FLAGS_13	:= -link http://web.interdynamix.com/~release/java/jdk1.3/docs/api
JAVADOC_FLAGS_14	:= -link http://web.interdynamix.com/~release/java/jdk1.4/docs/api -source 1.4

JAVADOC_FLAGS_SUNJava14		:= $(JAVADOC_FLAGS_14)
JAVADOC_FLAGS_JIKES118		:= $(JAVADOC_FLAGS_13)

JAVADOC_FLAGS = -use -private -splitIndex -version \
		-windowtitle "Project libimdb API (`$(DATECMD)`)" \
		-doctitle "Project libimdb API (build:`$(DATECMD)`)" \
		-header 'Project libimdb API' \
		-bottom 'Project libimdb API' \
		$(JAVADOC_FLAGS_$(JAVA_COMPILER))

JAVADOC_SOURCEPATH =.
JAVADOC_CLASSPATH  =

# binary extensions
EXE_CYGWIN  :=
EXE_LINUX   :=
EXE          =$(EXE_$(BUILD_OS))

INSTALL       :=$(PERL) $(COMPILE_BIN)/install.pl
INSTALLBIN    :=$(INSTALL) -m755
INSTALLSCRIPT :=$(INSTALL) -m755
INSTALLFILE   :=$(INSTALL) -m644
INSTALLDIR    :=$(INSTALL) -d -m755

INSTALLBIN    :=$(INSTALL) 
INSTALLSCRIPT :=$(INSTALL) 
INSTALLFILE   :=$(INSTALL) 
INSTALLDIR    :=$(INSTALL) -d

ifeq "$(BUILDING_DYNAMIC)" "false"
    INSTALLDYN :=@$(ECHO) "NOT installing"
else
    INSTALLDYN    :=@f() { \
		dir=`$(DIRNAME) $$1`; \
		base=`$(EXPR) $$1 : ".*/\([^.]*\)"`; \
		ver=`$(EXPR) $$1 : ".*\.s[ao]\.\(.*\)"`; \
		ver_M=`$(EXPR) $$ver : "\([^.]\)"`; \
		ver_m=`$(EXPR) $$ver : ".*\([^.]\)"`; \
		so=`$(EXPR) $$1 : ".*\.\(s[ao]\)\."`; \
		$(ECHO) "$(INSTALLFILE) $$dir/$$base.$$so.$$ver $$2"; \
		$(INSTALLFILE) $$dir/$$base.$$so.$$ver $$2 ; \
		   $(ECHO) "$(RM) -f $$2/$$base.$$so.$$ver_M" ; \
		   $(RM) -f $$2/$$base.$$so.$$ver_M; \
		   $(ECHO) "ln -s $$base.$$so.$$ver $$2/$$base.$$so.$$ver_M" ; \
		   ln -s $$base.$$so.$$ver $$2/$$base.$$so.$$ver_M; \
		fi; }; f
endif

MYDYNAMIC_CYGWIN  =$(BUILD_DIR)/$(LIB_BASE).$(SO)
MYDYNAMIC_LINUX   =$(BUILD_DIR)/lib$(LIB_BASE).$(SO).$(LIB_VERSION)
MYDYNAMIC         =$(MYDYNAMIC_$(BUILD_OS))

MYLIBRARY	  =$(BUILD_DIR)/lib$(LIB_BASE).$(A)

MYJAR             =$(BUILD_DIR)/$(JAR_BASE).$(JAR)

#
# $(wildcard *.c *.cc) is empty if there are no files
# that match, as opposed to 'echo *.c *.cc'
# Also, we need to include GENERATED_SRCS for projects
# that have no other kind, otherwise, a program's dependencies
# will be empty.
#

SRCS.C   =$(wildcard *.c)
SRCS.CC  =$(wildcard *.cc *.cpp)
SRCS.L   =$(wildcard *.l)
SRCS.Y   =$(wildcard *.y)
SRCS.JAVA=$(wildcard *.java)

SRCS.PERLSWIG=$(wildcard *.perlswig)
SRCS.JAVASWIG=$(wildcard *.javaswig)
SRCS.JAVASWIGXX=$(wildcard *.javaswigxx)

GENERATED_SRCS =$(patsubst %.l,   gen_$(BUILD_OS)/%.c, $(SRCS.L)) \
		$(patsubst %.y,   gen_$(BUILD_OS)/%.c, $(SRCS.Y)) \
		$(patsubst %.perlswig, gen_$(BUILD_OS)/%_swig.c, $(SRCS.PERLSWIG)) \
		$(patsubst %.javaswig, gen_$(BUILD_OS)/%_swig.c, $(SRCS.JAVASWIG)) \
		$(patsubst %.javaswigxx, gen_$(BUILD_OS)/%_swig.cpp, $(SRCS.JAVASWIGXX))

GENERATED_HDRS =$(patsubst %.y,   gen_$(BUILD_OS)/%.h, $(SRCS.Y)) 

GENERATED_JAVA_SRCS =
GENERATED_FILES = $(GENERATED_SRCS) $(GENERATED_HDRS)

# when all projects are using the guidelines for generated files
# (specifically, no generated files in the source directory), then
# we can remove the tr and sort -u.
#DEFAULT_SRCS = $(shell echo $(wildcard *.c *.cc) $(GENERATED_SRCS) | tr -s ' 	' '\012' | $(SORT) -u)
DEFAULT_SRCS =$(wildcard *.c *.cc *.cpp) $(GENERATED_SRCS)

#
# get list of srcs we want
SRCS =$(DEFAULT_SRCS)

# we need the notdir to remove the gen_$(BUILD_OS) portion from the
# list of GENERATED_SRCS.  The basename is used to remove
# all extensions.

OBJS =$(patsubst %, $(OBJS_DIR)/%.$(O), $(notdir $(basename $(SRCS))))

# default java sources to include in JAVAPACKAGE
JAVA_SRCS =$(wildcard *.java) $(GENERATED_JAVA_SRCS)

# create LIBS_LOCAL without the suffixes
LIBS_LOCAL =$(filter %.$(SO), $(LIBS)) $(filter %.$(A), $(LIBS))

__LIBS_LINK__ =\
       set x $(LIBS); shift; \
       for lib in $$*; do \
	  case $$lib in \
	  *.$(SO)) $(ECHO) "-l`$(EXPR) $$lib : '.*/lib\(.*\)\.$(SO)'`";; \
	  *) $(ECHO) $$lib;; \
	  esac; \
       done

LDFLAGS_LINK =$(patsubst %/, -L%, $(dir $(filter %.$(SO), $(LIBS))))

# if compiler is NOT insure we remove the insure directived from the link line
ifeq "$(CC_COMPILER)" "insure"
    LIBS_LINK =$(shell $(__LIBS_LINK__))
else
    LIBS_LINK =$(filter-out -Z%, $(shell $(__LIBS_LINK__)))
endif

# placing a value in MPATROL enables the use of
# mpatrol to check memory allocation.
ifdef MPATROL
    ifeq "$(BUILD_OS)" "LINUX"
	CPPFLAGS+=-DMPATROL
	LIBS_LINK+=/usr/local/lib/libmpatrol.$(SO) -lbfd -liberty -ldl
    else
	$(error "MPATROL usage under OS=$(BUILD_OS) not yet suppored")
    endif
endif


# don't put the dependency file in $(BUILD_DIR), because some projects
# have multiple directories sharing $(BUILD_DIR)
DEPEND_FILE =$(BUILD_BASE)/.dependencies

DEPEND_CC_CYGWIN  :=/usr/bin/gcc
DEPEND_CC_LINUX   :=/usr/bin/gcc
DEPEND_CC=$(DEPEND_CC_$(BUILD_OS))

DEPEND_CC_BASENAME=$(subst $(plus),x,$(notdir $(basename $(DEPEND_CC))))

#
# WARNING:we re-use DEPEND_CC here
#
DEPEND_CXX=$(DEPEND_CC_$(BUILD_OS))
DEPEND_CXX_BASENAME=$(subst $(plus),x,$(notdir $(basename $(DEPEND_CXX))))

DEPEND_CPPFLAGS_CC_gcc :=-MM

DEPEND_CPPFLAGS_CC_BUILD_gcc :=

DEPEND_CPPFLAGS_CC_TARGET_gcc_MINGW :=-mno-cygwin

DEPEND_CPPFLAGS_CC =$(DEPEND_CPPFLAGS_CC_$(DEPEND_CC_BASENAME)) \
		    $(DEPEND_CPPFLAGS_CC_BUILD_$(DEPEND_CC_BASENAME)) \
		    $(DEPEND_CPPFLAGS_CC_TARGET_$(DEPEND_CC_BASENAME)) \
		    $(DEPEND_CPPFLAGS_CC_TARGET_$(DEPEND_CC_BASENAME)_$(TARGET_OS))

DEPEND_CPPFLAGS_CXX_gcc :=-MM

DEPEND_CPPFLAGS_CXX_BUILD_gxx :=

DEPEND_CPPFLAGS_CXX_TARGET_gcc_MINGW :=-mno-cygwin

DEPEND_CPPFLAGS_CXX =$(DEPEND_CPPFLAGS_CXX_$(DEPEND_CXX_BASENAME)) \
		     $(DEPEND_CPPFLAGS_CXX_BUILD_$(DEPEND_CXX_BASENAME)) \
		     $(DEPEND_CPPFLAGS_CXX_TARGET_$(DEPEND_CXX_BASENAME)) \
		     $(DEPEND_CPPFLAGS_CXX_TARGET_$(DEPEND_CXX_BASENAME)_$(TARGET_OS))

#
# These are used by 'make install' related operations
#
INSTALL_BINDIR = $(INSTALL_ROOT)/bin
INSTALL_ETCDIR = $(INSTALL_ROOT)/etc
INSTALL_LIBDIR = $(INSTALL_ROOT)/lib

# These adjust the default target when you define PROGRAM, LIBRARY or DYNAMIC
# so that you can do this:
#	$(MAKE) PROGRAM=x
# instead of this:
#	$(MAKE) $(PROGRAM) PROGRAM=x

ifdef PROGRAM
$(PROGRAM):
endif

ifdef LIBRARY
$(LIBRARY):
endif

ifdef DYNAMIC
$(DYNAMIC):
endif

#
# List of JARs available in the system
#

3RD_PARTY_JAR_PATH =$(PROJECT_TOP)/lib/java

ALL_3RD_PARTY_JARS =

--- NEW FILE: rules.mk ---
#
# $Id: rules.mk,v 1.1 2003/06/16 04:18:37 jveldhuis Exp $
#

.DELETE_ON_ERROR:

clean::
	@if [ "$(OBJS)" != "" ] ; then \
	   echo "$(RM) -f $(OBJS)"; \
	   $(RM) -f $(OBJS) ;\
	fi
	@rm -f *~


clobber:: clean
ifneq "$(LIB_BASE)" ""
	$(RM) -rf $(MYLIBRARY) $(MYDYNAMIC) $(basename $(MYDYNAMIC)) $(basename $(basename $(MYDYNAMIC)))
endif
	$(RM) -rf $(BUILD_CFG) gen_$(BUILD_OS)

oldclobber:

depend::
	$(RM) -f $(DEPEND_FILE) $(DEPEND_FILE)-*

install: build

playpen::
	@true

ifeq "$(BUILDING_DYNAMIC)-$(OBJS_TYPE)" "false-DYNAMIC"
    objs:; @$(ECHO) NOT building dynamic objs
else
    objs: $(OBJS)
endif

$(DEPEND_FILE): $(GENERATED_FILES)
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	@$(ECHO) "generating $@.."
ifeq ($(strip $(DEFAULT_SRCS)),)
	   $(TOUCH) $@
else
	@for f in X $(DEFAULT_SRCS); do \
	    [ "$$f" = X ] && continue; \
	    case $$f in \
		*.cc)    $(DEPEND_CXX) $(CPPFLAGS) $(DEPEND_CPPFLAGS_CXX) $$f;; \
		*.cpp)   $(DEPEND_CXX) $(CPPFLAGS) $(DEPEND_CPPFLAGS_CXX) $$f;; \
		 *.c)    $(DEPEND_CC) $(CPPFLAGS) $(DEPEND_CPPFLAGS_CC) $$f;; \
		 *)      $(ECHO) "rules.mk: missing case statement for file type (example:$$f)" && exit 1;; \
	    esac; \
	done | $(SED) -e 's/\.o:/\.$(O):/' -e '/^[^ ]/s,^,$$(OBJS_DIR)/,' > $@
endif
	@[ "$(SRCS.SWIG)" = "" ] || $(PERL) $(COMPILE_BIN)/swigdepend.pl $(CPPFLAGS) $(SRCS.SWIG) >> $@

ifdef PROGRAM
  INCLUDE_DEPENDENCIES = TRUE
  ifeq "$(findstring .cpp,$(SRCS))$(findstring .cc,$(SRCS))" ""
    MYLINKER_CMD=$(LD)
  else
    MYLINKER_CMD=$(LDXX)
  endif
$(PROGRAM): $(OBJS) $(LIBS_LOCAL) Makefile
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	LD_LIBRARY_PATH="" $(MYLINKER_CMD) $(LDFLAGS) $(LDFLAGS_LINK) -o $@ $(OBJS) $(LIBS_LINK)
endif

####################################f###################################
# define:
#  LIB_BASE=mylibrary
# use:
#  $(MAKE) $(MYLIBARY) LIBARY=$(MYLIBARY)
# 
ifdef LIBRARY
INCLUDE_DEPENDENCIES = TRUE
$(LIBRARY): $(OBJS) Makefile
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	$(RM) -f $(LIBRARY)
	$(AR) $(ARFLAGS) $@ $(OBJS)
	$(RANLIB) $@
endif

####################################f###################################
# define:
#  LIB_BASE=mylibrary
#  LIB_VERSION=1.0
# use:
#  $(MAKE) $(MYDYNAMIC) DYNAMIC=$(MYDYNAMIC)
# 
ifdef DYNAMIC
  ifeq "$(BUILDING_DYNAMIC)" "true"
    INCLUDE_DEPENDENCIES = TRUE
    ifeq "$(findstring .cpp,$(SRCS))$(findstring .cc,$(SRCS))" ""
      MYLINKER_CMD=$(LD_DYNAMIC) $(LD_DYNAMIC_FLAGS)
    else
      MYLINKER_CMD=$(LDXX_DYNAMIC) $(LDXX_DYNAMIC_FLAGS)
    endif
    $(DYNAMIC): $(OBJS) Makefile $(OBJS_STA)
	@[ -d $(@D) ] || $(MKPATH) $(@D);
	LD_LIBRARY_PATH="" $(MYLINKER_CMD) $(LDFLAGS) $(LDFLAGS_LINK) -o $@ $(OBJS) $(LIBS_LINK) && \
	if [ "$(BUILD_OS)" = "LINUX" ]; then \
	    $(RM) -f $(basename $(basename $@)) $(basename $@); \
	    $(LN) -s $(@F) $(basename $(basename $@)); \
	    $(LN) -s $(@F) $(basename $@); \
	fi
  else
    $(DYNAMIC):; @$(ECHO) NOT building $@;
  endif
endif

#
# generate wrapper for JAVA runtime for non-make usage
#
$(PROJECT_TOP)/gen/runjava: $(PROJECT_TOP)/constants.mk $(PROJECT_TOP)/config.mk $(PROJECT_TOP)/rules.mk
	@$(ECHO) "generating $@.."
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	@$(ECHO) '$(JAVA) $(JAVA_FLAGS) -classpath "$(subst $(space),$(CLASSPATH_SEP),$(strip $(JAVASRCS_CLASSES_DEST) $(JAVA_CLASSPATH)) $(ALL_3RD_PARTY_JARS) $$CLASSPATH)" "$$@"' > $@
	@$(CHMOD) +x $@

#
# generate something useful for java classes like EtherProgram to parse
# and understand how to invoke a controlable (ha) jvm child process
#
#
$(PROJECT_TOP)/gen/jvm.config: $(PROJECT_TOP)/constants.mk $(PROJECT_TOP)/config.mk $(PROJECT_TOP)/rules.mk
	@$(ECHO) "generating $@.."
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	@($(ECHO) "# This file is provided for java classes who";\
	  $(ECHO) "# want to invoke a controlable (ha) jvm child process";\
	  $(ECHO) "# access to the JAVAC command line that otherwise only" ;\
	  $(ECHO) "# Warning:format is compatible with CmdLine class, not shell usage";\
	  $(ECHO) "JDB_PATHNAME $(JDB)";\
	  $(ECHO) "JDB_STANDARD_FLAGS $(JDB_FLAGS)";\
	  $(ECHO) "JVM_PATHNAME $(JAVA)";\
	  $(ECHO) "JVM_STANDARD_FLAGS $(JAVA_FLAGS)";\
	  $(ECHO) "JVM_STANDARD_CLASSPATH $(subst $(space),$(CLASSPATH_SEP),$(strip $(JAVASRCS_CLASSES_DEST) $(JAVA_CLASSPATH)) $$CLASSPATH)" )> $@
	@$(CHMOD) +r $@

#
# generate wrapper for JAVAC runtime for non-make usage
# see comments for more details
#
$(PROJECT_TOP)/gen/runjavac: $(PROJECT_TOP)/constants.mk $(PROJECT_TOP)/config.mk $(PROJECT_TOP)/rules.mk
	@$(ECHO) "generating $@.."
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	@($(ECHO) "# This script is generated during a 'make' to provide" ;\
	  $(ECHO) "# access to the JAVAC command line that otherwise only" ;\
	  $(ECHO) "# make' would have acess to." ;\
	  $(ECHO) "# " ;\
	  $(ECHO) "# Typical usage include providing a '-d <dir>' and a" ;\
	  $(ECHO) "# list of classes to compile, but not required." ;\
	  $(ECHO) '$(JAVAC) $(JAVAC_FLAGS) -sourcepath . -classpath "$(subst $(space),$(CLASSPATH_SEP),$(strip $(JAVASRCS_CLASSES_DEST) $(JAVAC_CLASSPATH)) $$CLASSPATH)" "$$@"' ) > $@
	@$(CHMOD) +x $@

#
# generate wrapper for PERL runtime for non-make usage
#
$(PROJECT_TOP)/gen/runperl: $(PROJECT_TOP)/constants.mk $(PROJECT_TOP)/config.mk $(PROJECT_TOP)/rules.mk
	@$(ECHO) "generating $@.."
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	@($(ECHO) "# This script is generated during a 'make' to provide" ;\
	  $(ECHO) "# an easy way to invoke the perl run-time as defined in constants.mk" ;\
	  $(ECHO) "# without all having to use make to get things done." ;\
	  $(ECHO) "# " ;\
	  $(ECHO) '$(PERL) -I$(PROJECT_TOP)/lib/perl "$$@"') > $@
	@$(CHMOD) +x $@

$(OBJS_DIR)/%.$(O): gen_$(BUILD_OS)/%.c
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $< 

$(OBJS_DIR)/%.$(O): %.c
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $< 

$(OBJS_DIR)/%.$(O): %.cc
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	$(CXX) -c $(CCFLAGS) $(CPPFLAGS) -o $@ $<

$(OBJS_DIR)/%.$(O): %.cpp
	@[ -d $(@D) ] || $(MKPATH) $(@D)
	$(CXX) -c $(CCFLAGS) $(CPPFLAGS) -o $@ $<

#
# Generated sources:
#
gen_$(BUILD_OS)/%.c \
gen_$(BUILD_OS)/%.h: %.y
	@[ -d $(@D) ] || $(MKDIR) $(@D) 
	$(BISON) -d -o gen_$(BUILD_OS)/$*.c $<

gen_$(BUILD_OS)/%.c: %.l
	@[ -d $(@D) ] || $(MKDIR) $(@D) 
	$(LEX) $(LEXFLAGS) $< > $@

ifdef INCLUDE_DEPENDENCIES
include $(DEPEND_FILE)
endif