I found the same problem last year, that no adequate makefile for an x86 Linux
system is available in the sample directory
I developed a makefile that does exactly what you want: it compiles multiple
modules for a x86 Linux system, both loadable (with make) and inboard (with
make exe).
try ``make help'' for the options available.
If you want to add a module, the makefile has to be modified in five place
1: Add to the list of module declarations
2: Add OBJ_YourModule to the OBJS variable
3: Add EXE_YourModule to the EXECS variable
4: Add MDF_YourModule to the MDF variable
5: Add the compilation commands to the list of targets
Of coarse, I am using a bunch of my own libraries that you don't have, so
these should be removed from the make file. This also means that probably
all the targets won't compile. But at least you have an idea how I did it.
I you want my complete setup, including libraries, please let me know
Hope that this helps
Cheers
Eelco
On Mon, 24 Jun 2002, Mike H. Miller wrote:
> Hi,
> I'm learning how to write modules for OpenDX now, and was trying to
> create samples of all three (inboard, outboard, and loadable) modules.
> My problem is that there are no valid makefiles for an x86 linux system
> in the sample directory. I found this (slightly modified) on the
> internet for an outboard:
>
> BASE = /s/gordo/paredsoft/local/dx
> FILES = outboard.o hello.o
> LITELIBS = -L$(BASE)/lib_linux -lDXlite -lm
> CC = gcc
> CFLAGS = -O -Dlinux -I$(BASE)/include
> LIBS = -L$(BASE)/lib_linux -L/usr/X11R6/lib -L/usr/local/lib /usr/lib
> -lDX -lMagick -lpng -ltiff -lGL -lm -lX11 -ldl -lnsl
> # make the outboard
> hello: hello.c
> $(CC) $(CFLAGS) -DUSERMODULE=m_Hello -c $(BASE)/lib/outboard.c
> $(CC) $(CFLAGS) -c hello.c
> $(CC) $(FILES) $(LITELIBS) -o hello
>
> And for an inboard, I succeeded in using this:
> SHELL = /bin/sh
> BASE = /s/gordo/paredsoft/local/dx
> include $(BASE)/lib_$(DXARCH)/arch.mak
> FILES_firstmodule = userfirstmodule.$(OBJEXT) firstmodule.$(OBJEXT)
> BIN = $(BASE)/bin
> CFLAGS = -I./ -I$(BASE)/include $(DX_CFLAGS)
> LDFLAGS = -L$(BASE)/lib_$(DXARCH)
> LIBS = -lDX $(DX_GL_LINK_LIBS) $(DXEXECLINKLIBS)
> OLIBS = -lDXlite -lm
> BIN = $(BASE)/bin
> # create the necessary executable
> dxexec: $(FILES_firstmodule)
> $(CC) $(LDFLAGS) $(FILES_firstmodule) $(LIBS) -o dxexec
> .c.o: ; cc -c $(DXABI) $(DX_RTL_CFLAGS) $(CFLAGS) $*.c
> .C.o: ; cc -c $(DXABI) $(DX_RTL_CFLAGS) $(CFLAGS) $*.C
> # a command to run the user module
> run: dxexec
> dx -edit -exec ./dxexec -mdf firstmodule.mdf &
> # make the user files
> userfirstmodule.c: firstmodule.mdf
> $(BIN)/mdf2c firstmodule.mdf > userfirstmodule.c
> # kluge for when DXARCH isn't set
> $(BASE)/lib_/arch.mak:
> (export DXARCH=`dx -whicharch` ; $(MAKE) -f firstmodule.make )
> echo YOU NEED TO SET DXARCH via dx -whicharch
>
> Both compile just fine. The inboard actually works great, but since that
> only allows one module, that's not my ideal solution. The outboard seems
> to work, but gives an "error connecting to localhost" when I try and run
> it. My real problem is that I want to be able to create loadable
> modules-- does anyone have a Makefile to do that? Thanks.
>
> --
> Mike Miller
> [EMAIL PROTECTED] ->
> [EMAIL PROTECTED]
>
SHELL = /bin/sh
# klftdh06 base
#BASE = /usr/local/dx
# klftcs01 BASE
BASE = /opt/dx-4.1.3/dx
MYLIBDIR =/home/eelco/prog/mylib
############################################################################
# The path definitions
#
############################################################################
# import the general dx configutation make file
include $(BASE)/lib_$(DXARCH)/arch.mak
BIN = $(BASE)/bin
DXEXEC = dxexec
# define some directories
SRCDIR = ./src
SRCDIR_IO= $(SRCDIR)/io
SRCDIR_UT= $(SRCDIR)/utils
SRCDIR_IM= $(SRCDIR)/image
INCLDIR = ./incl
OBJDIR = ./obj
LIBDIR = ./lib
#LIBDIR = $(MYLIBDIR)
EXEDIR = ./bin
# define the library files
LIBFILES = $(LIBDIR)/libSC.a \
$(LIBDIR)/libvec.a \
$(LIBDIR)/libutil.a \
$(LIBDIR)/libNRc.a \
/opt/fftw-2.1.3/lib
#
# define the libraries added by the user
USERLIBS = -lsfftw -lSC -lvec -lNRc -lutil
#
# define all the include files
INCL = $(INCLDIR)/error.h\
$(INCLDIR)/SC.h\
$(INCLDIR)/util.h\
$(INCLDIR)/nrutil.h\
$(INCLDIR)/nr.h\
$(INCLDIR)/libvec.h
#
############################################################################
############################################################################
# The MODULES declarations
#
#C##########################################################################
#
#A#
# AddImage
ROOT_AddImage = AddImage
OBJ_AddImage = $(OBJDIR)/$(ROOT_AddImage).o
EXE_AddImage = $(EXEDIR)/$(ROOT_AddImage)
MDF_AddImage = $(SRCDIR_IM)/$(ROOT_AddImage).mdf
# AverageImage
ROOT_AverageImage = AverageImage
OBJ_AverageImage = $(OBJDIR)/$(ROOT_AverageImage).o
EXE_AverageImage = $(EXEDIR)/$(ROOT_AverageImage)
MDF_AverageImage = $(SRCDIR_IM)/$(ROOT_AverageImage).mdf
#C#
# Cartesian2Polar
ROOT_Cartesian2Polar = Cartesian2Polar
OBJ_Cartesian2Polar = $(OBJDIR)/$(ROOT_Cartesian2Polar).o
EXE_Cartesian2Polar = $(EXEDIR)/$(ROOT_Cartesian2Polar)
MDF_Cartesian2Polar = $(SRCDIR_IM)/$(ROOT_Cartesian2Polar).mdf
# CopyPartImage
ROOT_CopyPartImage = CopyPartImage
OBJ_CopyPartImage = $(OBJDIR)/$(ROOT_CopyPartImage).o
EXE_CopyPartImage = $(EXEDIR)/$(ROOT_CopyPartImage)
MDF_CopyPartImage = $(SRCDIR_IM)/$(ROOT_CopyPartImage).mdf
#
# DevideImage
ROOT_DevideImage = DevideImage
OBJ_DevideImage = $(OBJDIR)/$(ROOT_DevideImage).o
EXE_DevideImage = $(EXEDIR)/$(ROOT_DevideImage)
MDF_DevideImage = $(SRCDIR_IM)/$(ROOT_DevideImage).mdf
# DevideImage2D
ROOT_DevideImage2D = DevideImage2D
OBJ_DevideImage2D = $(OBJDIR)/$(ROOT_DevideImage2D).o
EXE_DevideImage2D = $(EXEDIR)/$(ROOT_DevideImage2D)
MDF_DevideImage2D = $(SRCDIR_IM)/$(ROOT_DevideImage2D).mdf
#E#
# ExportICS
ROOT_ExportICS = ExportICS
OBJ_ExportICS = $(OBJDIR)/$(ROOT_ExportICS).o
EXE_ExportICS = $(EXEDIR)/$(ROOT_ExportICS)
MDF_ExportICS = $(SRCDIR_IO)/$(ROOT_ExportICS).mdf
# ExportAsci
ROOT_ExportAsci = ExportAsci
OBJ_ExportAsci = $(OBJDIR)/$(ROOT_ExportAsci).o
EXE_ExportAsci = $(EXEDIR)/$(ROOT_ExportAsci)
MDF_ExportAsci = $(SRCDIR_IO)/$(ROOT_ExportAsci).mdf
# ExportTecplot
ROOT_ExportTecplot = ExportTecplot
OBJ_ExportTecplot = $(OBJDIR)/$(ROOT_ExportTecplot).o
EXE_ExportTecplot = $(EXEDIR)/$(ROOT_ExportTecplot)
MDF_ExportTecplot = $(SRCDIR_IO)/$(ROOT_ExportTecplot).mdf
# ExtractFileName
ROOT_ExtractFileName = ExtractFileName
OBJ_ExtractFileName = $(OBJDIR)/$(ROOT_ExtractFileName).o
EXE_ExtractFileName = $(EXEDIR)/$(ROOT_ExtractFileName)
MDF_ExtractFileName = $(SRCDIR_UT)/$(ROOT_ExtractFileName).mdf
#F#
# FFTW
ROOT_FFTW = FFTW
OBJ_FFTW = $(OBJDIR)/$(ROOT_FFTW).o
EXE_FFTW = $(EXEDIR)/$(ROOT_FFTW)
MDF_FFTW = $(SRCDIR_IM)/$(ROOT_FFTW).mdf
#G#
# GenNoise module
ROOT_GenNoise = GenNoise
OBJ_GenNoise = $(OBJDIR)/$(ROOT_GenNoise).o
EXE_GenNoise = $(EXEDIR)/$(ROOT_GenNoise)
MDF_GenNoise = $(SRCDIR_IM)/$(ROOT_GenNoise).mdf
# GenQuadratic module
ROOT_GenQuadratic = GenQuadratic
OBJ_GenQuadratic = $(OBJDIR)/$(ROOT_GenQuadratic).o
EXE_GenQuadratic = $(EXEDIR)/$(ROOT_GenQuadratic)
MDF_GenQuadratic = $(SRCDIR_IM)/$(ROOT_GenQuadratic).mdf
# GetCameraSettings module
ROOT_GetCameraSettings = GetCameraSettings
OBJ_GetCameraSettings = $(OBJDIR)/$(ROOT_GetCameraSettings).o
EXE_GetCameraSettings = $(EXEDIR)/$(ROOT_GetCameraSettings)
MDF_GetCameraSettings = $(SRCDIR_UT)/$(ROOT_GetCameraSettings).mdf
# GetCounts module
ROOT_GetCounts = GetCounts
OBJ_GetCounts = $(OBJDIR)/$(ROOT_GetCounts).o
EXE_GetCounts = $(EXEDIR)/$(ROOT_GetCounts)
MDF_GetCounts = $(SRCDIR_UT)/$(ROOT_GetCounts).mdf
# GetDimsICS module
ROOT_GetDimsICS = GetDimsICS
OBJ_GetDimsICS = $(OBJDIR)/$(ROOT_GetDimsICS).o
EXE_GetDimsICS = $(EXEDIR)/$(ROOT_GetDimsICS)
MDF_GetDimsICS = $(SRCDIR_IO)/$(ROOT_GetDimsICS).mdf
# GetPeak module
ROOT_GetPeak = GetPeak
OBJ_GetPeak = $(OBJDIR)/$(ROOT_GetPeak).o
EXE_GetPeak = $(EXEDIR)/$(ROOT_GetPeak)
MDF_GetPeak = $(SRCDIR_IM)/$(ROOT_GetPeak).mdf
# GetPeaks module
ROOT_GetPeaks = GetPeaks
OBJ_GetPeaks = $(OBJDIR)/$(ROOT_GetPeaks).o
EXE_GetPeaks = $(EXEDIR)/$(ROOT_GetPeaks)
MDF_GetPeaks = $(SRCDIR_IM)/$(ROOT_GetPeaks).mdf
# Gradient3D26Points module
ROOT_Gradient3D26Points = Gradient3D26Points
OBJ_Gradient3D26Points = $(OBJDIR)/$(ROOT_Gradient3D26Points).o
EXE_Gradient3D26Points = $(EXEDIR)/$(ROOT_Gradient3D26Points)
MDF_Gradient3D26Points = $(SRCDIR_IM)/$(ROOT_Gradient3D26Points).mdf
# Gradient3D module
ROOT_Gradient3D = Gradient3D
OBJ_Gradient3D = $(OBJDIR)/$(ROOT_Gradient3D).o
EXE_Gradient3D = $(EXEDIR)/$(ROOT_Gradient3D)
MDF_Gradient3D = $(SRCDIR_IM)/$(ROOT_Gradient3D).mdf
# Gradient4D module
ROOT_Gradient4D = Gradient4D
OBJ_Gradient4D = $(OBJDIR)/$(ROOT_Gradient4D).o
EXE_Gradient4D = $(EXEDIR)/$(ROOT_Gradient4D)
MDF_Gradient4D = $(SRCDIR_IM)/$(ROOT_Gradient4D).mdf
#H#
# HalfSize
ROOT_HalfSize = HalfSize
OBJ_HalfSize = $(OBJDIR)/$(ROOT_HalfSize).o
EXE_HalfSize = $(EXEDIR)/$(ROOT_HalfSize)
MDF_HalfSize = $(SRCDIR_IM)/$(ROOT_HalfSize).mdf
#I#
# ImortICS module
ROOT_ImportICS = ImportICS
OBJ_ImportICS = $(OBJDIR)/$(ROOT_ImportICS).o
EXE_ImportICS = $(EXEDIR)/$(ROOT_ImportICS)
MDF_ImportICS = $(SRCDIR_IO)/$(ROOT_ImportICS).mdf
#M#
# MultiplyFloat
ROOT_MultiplyFloat = MultiplyFloat
OBJ_MultiplyFloat = $(OBJDIR)/$(ROOT_MultiplyFloat).o
EXE_MultiplyFloat = $(EXEDIR)/$(ROOT_MultiplyFloat)
MDF_MultiplyFloat = $(SRCDIR_IM)/$(ROOT_MultiplyFloat).mdf
#S#
# Statistics2
ROOT_Statistics2 = Statistics2
OBJ_Statistics2 = $(OBJDIR)/$(ROOT_Statistics2).o
EXE_Statistics2 = $(EXEDIR)/$(ROOT_Statistics2)
MDF_Statistics2 = $(SRCDIR_IM)/$(ROOT_Statistics2).mdf
# SubtractImage
ROOT_SubtractImage = SubtractImage
OBJ_SubtractImage = $(OBJDIR)/$(ROOT_SubtractImage).o
EXE_SubtractImage = $(EXEDIR)/$(ROOT_SubtractImage)
MDF_SubtractImage = $(SRCDIR_IM)/$(ROOT_SubtractImage).mdf
# SubtractImage2D
ROOT_SubtractImage2D = SubtractImage2D
OBJ_SubtractImage2D = $(OBJDIR)/$(ROOT_SubtractImage2D).o
EXE_SubtractImage2D = $(EXEDIR)/$(ROOT_SubtractImage2D)
MDF_SubtractImage2D = $(SRCDIR_IM)/$(ROOT_SubtractImage2D).mdf
# Sum
ROOT_Sum = Sum
OBJ_Sum = $(OBJDIR)/$(ROOT_Sum).o
EXE_Sum = $(EXEDIR)/$(ROOT_Sum)
MDF_Sum = $(SRCDIR_UT)/$(ROOT_Sum).mdf
# SumHistogram
ROOT_SumHistogram = SumHistogram
OBJ_SumHistogram = $(OBJDIR)/$(ROOT_SumHistogram).o
EXE_SumHistogram = $(EXEDIR)/$(ROOT_SumHistogram)
MDF_SumHistogram = $(SRCDIR_UT)/$(ROOT_SumHistogram).mdf
# SumMask
ROOT_SumMask = SumMask
OBJ_SumMask = $(OBJDIR)/$(ROOT_SumMask).o
EXE_SumMask = $(EXEDIR)/$(ROOT_SumMask)
MDF_SumMask = $(SRCDIR_UT)/$(ROOT_SumMask).mdf
#T#
# TransformImage
ROOT_TransformImage = TransformImage
OBJ_TransformImage = $(OBJDIR)/$(ROOT_TransformImage).o
EXE_TransformImage = $(EXEDIR)/$(ROOT_TransformImage)
MDF_TransformImage = $(SRCDIR_IM)/$(ROOT_TransformImage).mdf
#W#
# WriteString
ROOT_WriteString = WriteString
OBJ_WriteString = $(OBJDIR)/$(ROOT_WriteString).o
EXE_WriteString = $(EXEDIR)/$(ROOT_WriteString)
MDF_WriteString = $(SRCDIR_IO)/$(ROOT_WriteString).mdf
############################################################################
# Add all the stuff into variables
#
############################################################################
# add all the file into one variable
OBJS = $(OBJ_ImportICS) $(OBJ_GetDimsICS)
$(OBJ_ExtractFileName) \
$(OBJ_CopyPartImage) $(OBJ_HalfSize)
$(OBJ_GenQuadratic) \
$(OBJ_GetCounts) $(OBJ_GetCameraSettings)
$(OBJ_AverageImage) \
$(OBJ_SubtractImage2D) $(OBJ_MultiplyFloat)
$(OBJ_SubtractImage)\
$(OBJ_AddImage) $(OBJ_Sum)
$(OBJ_Cartesian2Polar)\
$(OBJ_DevideImage2D) $(OBJ_DevideImage)
$(OBJ_TransformImage)\
$(OBJ_SumHistogram) $(OBJ_SumMask)
$(OBJ_Gradient3D26Points) \
$(OBJ_GetPeak) $(OBJ_ExportTecplot)
$(OBJ_GetPeaks)\
$(OBJ_ExportAsci) $(OBJ_FFTW)
$(OBJ_Statistics2) $(OBJ_ExportICS)\
$(OBJ_WriteString) $(OBJ_Gradient3D)
$(OBJ_Gradient4D)\
$(OBJ_GenNoise)
# add all the executable into one variable
EXECS = $(EXE_ImportICS) $(EXE_GetDimsICS)
$(EXE_ExtractFileName) \
$(EXE_CopyPartImage) $(EXE_HalfSize)
$(EXE_GenQuadratic) \
$(EXE_GetCounts) $(EXE_GetCameraSettings)
$(EXE_AverageImage) \
$(EXE_SubtractImage2D) $(EXE_MultiplyFloat)
$(EXE_SubtractImage)\
$(EXE_AddImage) $(EXE_Sum)
$(EXE_Cartesian2Polar)\
$(EXE_DevideImage2D) $(EXE_DevideImage)
$(EXE_TransformImage)\
$(EXE_SumHistogram) $(EXE_SumMask)
$(EXE_Gradient3D26Points)\
$(EXE_GetPeak) $(EXE_ExportTecplot)
$(EXE_GetPeaks)\
$(EXE_ExportAsci) $(EXE_FFTW)
$(EXE_Statistics2) $(EXE_ExportICS)\
$(EXE_WriteString) $(EXE_Gradient3D)
$(EXE_Gradient4D)\
$(EXE_GenNoise)
# add all the mdf file into one variable
MDFS = $(MDF_ImportICS) $(MDF_GetDimsICS) \
$(MDF_ExtractFileName)
$(MDF_CopyPartImage) \
$(MDF_HalfSize) $(MDF_GenQuadratic)
$(MDF_GetCounts) \
$(MDF_GetCameraSettings)
$(MDF_AverageImage) \
$(MDF_SubtractImage2D)
$(MDF_MultiplyFloat) $(MDF_SubtractImage)\
$(MDF_AddImage) $(MDF_Sum)
$(MDF_Cartesian2Polar)\
$(MDF_DevideImage2D) $(MDF_DevideImage)
$(MDF_TransformImage)\
$(MDF_SumHistogram) $(MDF_SumMask)
$(MDF_Gradient3D26Points) \
$(MDF_GetPeak) $(MDF_ExportTecplot)
$(MDF_GetPeaks)\
$(MDF_ExportAsci) $(MDF_FFTW)
$(MDF_Statistics2) \
$(MDF_ExportICS) $(MDF_WriteString)
$(MDF_Gradient3D) \
$(MDF_Gradient4D) $(MDF_GenNoise)
# The compilation flags and libraries
#
############################################################################
# define the C comilation flags. Include here also the search path of all the
# C include file using -I.. option.
# For debugging: add the -g option !! Remove is to optimize.
# If you want to optimize: add -O2 here
# Just uncomment the proper line. The distinction is made in the
# /usr/local/dx/lib_linux/arch.mak file
#CFLAGS = -I./ -I$(BASE)/include $(DXCFLAGS) -I$(INCLDIR)
CFLAGS = -I./ -I$(BASE)/include $(DXCFLAGSDEBUG) -I$(INCLDIR)
-I/opt/fftw-2.1.3/include
# define the C libraries. Inlude here the search path to your
# libraries with -L
LDFLAGS = -L$(BASE)/lib_$(DXARCH) -L$(LIBDIR) -L/opt/fftw-2.1.3/lib
# put all the libraries into the variable LIBS
#
LIBS = -lDX $(DX_GL_LINK_LIBS) $(DXEXECLINKLIBS)
# define the search path: Import that all sources and object are in it!!!
VPATH = .:$(OBJDIR):$(SRCDIR):$(SRCDIR_IO):$(SRCDIR_UT):\
$(SRCDIR_IM)
############################################################################
# The target the build the stuff
#
############################################################################
all: $(EXECS)
# Make the object files from the .c files
$(OBJDIR)/%.o: %.c $(INCL) $(LIBFILES)
@echo compiling $<
@$(CC) $(DXABI) $(DX_RTL_CFLAGS) $(CFLAGS) -c $< -o
$(OBJDIR)/$(@F)
%.c: incl/error.h
# create the necessary executable
#A#
$(EXE_AddImage): $(OBJ_AddImage) $(MDF_AddImage)
@echo compiling $(MDF_AddImage)
@$(BIN)/mdf2c -m $(MDF_AddImage) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_AddImage)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_AddImage) $(OBJ_AddImage)
user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_AverageImage): $(OBJ_AverageImage) $(MDF_AverageImage)
@echo compiling $(MDF_AverageImage)
@$(BIN)/mdf2c -m $(MDF_AverageImage) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_AverageImage)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_AverageImage)
$(OBJ_AverageImage) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#C#
$(EXE_Cartesian2Polar): $(OBJ_Cartesian2Polar) $(MDF_Cartesian2Polar)
@echo compiling $(MDF_Cartesian2Polar)
@$(BIN)/mdf2c -m $(MDF_Cartesian2Polar) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_Cartesian2Polar)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_Cartesian2Polar)
$(OBJ_Cartesian2Polar) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_CopyPartImage): $(OBJ_CopyPartImage) $(MDF_CopyPartImage)
@echo compiling $(MDF_CopyPartImage)
@$(BIN)/mdf2c -m $(MDF_CopyPartImage) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_CopyPartImage)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_CopyPartImage)
$(OBJ_CopyPartImage) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#D#
$(EXE_DevideImage): $(OBJ_DevideImage) $(MDF_DevideImage)
@echo compiling $(MDF_DevideImage)
@$(BIN)/mdf2c -m $(MDF_DevideImage) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_DevideImage)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_DevideImage)
$(OBJ_DevideImage) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_DevideImage2D): $(OBJ_DevideImage2D) $(MDF_DevideImage2D)
@echo compiling $(MDF_DevideImage2D)
@$(BIN)/mdf2c -m $(MDF_DevideImage2D) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_DevideImage2D)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_DevideImage2D)
$(OBJ_DevideImage2D) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#E#
$(EXE_ExportICS): $(OBJ_ExportICS) $(MDF_ExportICS)
@echo compiling $(MDF_ExportICS)
@$(BIN)/mdf2c -m $(MDF_ExportICS) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_ExportICS)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_ExportICS)
$(OBJ_ExportICS) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_ExportAsci): $(OBJ_ExportAsci) $(MDF_ExportAsci)
@echo compiling $(MDF_ExportAsci)
@$(BIN)/mdf2c -m $(MDF_ExportAsci) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_ExportAsci)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_ExportAsci)
$(OBJ_ExportAsci) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_ExportTecplot): $(OBJ_ExportTecplot) $(MDF_ExportTecplot)
@echo compiling $(MDF_ExportTecplot)
@$(BIN)/mdf2c -m $(MDF_ExportTecplot) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_ExportTecplot)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_ExportTecplot)
$(OBJ_ExportTecplot) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_ExtractFileName): $(OBJ_ExtractFileName) $(MDF_ExtractFileName)
@echo compiling $(MDF_ExtractFileName)
@$(BIN)/mdf2c -m $(MDF_ExtractFileName) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_ExtractFileName)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_ExtractFileName)
$(OBJ_ExtractFileName) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#F#
$(EXE_FFTW): $(OBJ_FFTW) $(MDF_FFTW)
@echo compiling $(MDF_FFTW)
@$(BIN)/mdf2c -m $(MDF_FFTW) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_FFTW)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_FFTW) $(OBJ_FFTW) user.o
$(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#G#
$(EXE_GenNoise): $(OBJ_GenNoise) $(MDF_GenNoise)
@echo compiling $(MDF_GenNoise)
@$(BIN)/mdf2c -m $(MDF_GenNoise) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_GenNoise)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_GenNoise) $(OBJ_GenNoise)
user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_GenQuadratic): $(OBJ_GenQuadratic) $(MDF_GenQuadratic)
@echo compiling $(MDF_GenQuadratic)
@$(BIN)/mdf2c -m $(MDF_GenQuadratic) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_GenQuadratic)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_GenQuadratic)
$(OBJ_GenQuadratic) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_GetCameraSettings): $(OBJ_GetCameraSettings) $(MDF_GetCameraSettings)
@echo compiling $(MDF_GetCameraSettings)
@$(BIN)/mdf2c -m $(MDF_GetCameraSettings) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_GetCameraSettings)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_GetCameraSettings)
$(OBJ_GetCameraSettings) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_GetCounts): $(OBJ_GetCounts) $(LIBFILES) $(MDF_GetCounts)
@echo compiling $(MDF_GetCounts)
@$(BIN)/mdf2c -m $(MDF_GetCounts) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_GetCounts)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_GetCounts)
$(OBJ_GetCounts) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_GetDimsICS): $(OBJ_GetDimsICS) $(LIBFILES) $(MDF_GetDimsICS)
@echo compiling $(MDF_GetDimsICS)
@$(BIN)/mdf2c -m $(MDF_GetDimsICS) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_GetDimsICS)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_GetDimsICS)
$(OBJ_GetDimsICS) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_GetPeak): $(OBJ_GetPeak) $(LIBFILES) $(MDF_GetPeak)
@echo compiling $(MDF_GetPeak)
@$(BIN)/mdf2c -m $(MDF_GetPeak) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_GetPeak)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_GetPeak) $(OBJ_GetPeak)
user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_GetPeaks): $(OBJ_GetPeaks) $(LIBFILES) $(MDF_GetPeaks)
@echo compiling $(MDF_GetPeaks)
@$(BIN)/mdf2c -m $(MDF_GetPeaks) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_GetPeaks)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_GetPeaks) $(OBJ_GetPeaks)
user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_Gradient3D26Points): $(OBJ_Gradient3D26Points) $(LIBFILES)
$(MDF_Gradient3D26Points)
@echo compiling $(MDF_Gradient3D26Points)
@$(BIN)/mdf2c -m $(MDF_Gradient3D26Points) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_Gradient3D26Points)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_Gradient3D26Points)
$(OBJ_Gradient3D26Points) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_Gradient3D): $(OBJ_Gradient3D) $(LIBFILES) $(MDF_Gradient3D)
@echo compiling $(MDF_Gradient3D)
@$(BIN)/mdf2c -m $(MDF_Gradient3D) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_Gradient3D)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_Gradient3D)
$(OBJ_Gradient3D) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_Gradient4D): $(OBJ_Gradient4D) $(LIBFILES) $(MDF_Gradient4D)
@echo compiling $(MDF_Gradient4D)
@$(BIN)/mdf2c -m $(MDF_Gradient4D) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_Gradient4D)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_Gradient4D)
$(OBJ_Gradient4D) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#H#
$(EXE_HalfSize): $(OBJ_HalfSize) $(MDF_HalfSize)
@echo compiling $(MDF_HalfSize)
@$(BIN)/mdf2c -m $(MDF_HalfSize) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_HalfSize)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_HalfSize) $(OBJ_HalfSize)
user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#I#
$(EXE_ImportICS): $(OBJ_ImportICS) $(LIBFILES) $(MDF_ImportICS)
@echo compiling $(MDF_ImportICS)
@$(BIN)/mdf2c -m $(MDF_ImportICS) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_ImportICS)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_ImportICS)
$(OBJ_ImportICS) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#M#
$(EXE_MultiplyFloat): $(OBJ_MultiplyFloat) $(MDF_MultiplyFloat)
@echo compiling $(MDF_MultiplyFloat)
@$(BIN)/mdf2c -m $(MDF_MultiplyFloat) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_MultiplyFloat)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_MultiplyFloat)
$(OBJ_MultiplyFloat) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#S#
$(EXE_Statistics2): $(OBJ_Statistics2) $(MDF_Statistics2)
@echo compiling $(MDF_Statistics2)
@$(BIN)/mdf2c -m $(MDF_Statistics2) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_Statistics2)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_Statistics2)
$(OBJ_Statistics2) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_SubtractImage): $(OBJ_SubtractImage) $(MDF_SubtractImage)
@echo compiling $(MDF_SubtractImage)
@$(BIN)/mdf2c -m $(MDF_SubtractImage) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_SubtractImage)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_SubtractImage)
$(OBJ_SubtractImage) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_SubtractImage2D): $(OBJ_SubtractImage2D) $(MDF_SubtractImage2D)
@echo compiling $(MDF_SubtractImage2D)
@$(BIN)/mdf2c -m $(MDF_SubtractImage2D) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_SubtractImage2D)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_SubtractImage2D)
$(OBJ_SubtractImage2D) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_Sum): $(OBJ_Sum) $(MDF_Sum)
@echo compiling $(MDF_Sum)
@$(BIN)/mdf2c -m $(MDF_Sum) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_Sum)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_Sum) $(OBJ_Sum) user.o
$(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_SumHistogram): $(OBJ_SumHistogram) $(MDF_SumHistogram)
@echo compiling $(MDF_SumHistogram)
@$(BIN)/mdf2c -m $(MDF_SumHistogram) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_SumHistogram)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_SumHistogram)
$(OBJ_SumHistogram) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
$(EXE_SumMask): $(OBJ_SumMask) $(MDF_SumMask)
@echo compiling $(MDF_SumMask)
@$(BIN)/mdf2c -m $(MDF_SumMask) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_SumMask)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_SumMask) $(OBJ_SumMask)
user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#T#
$(EXE_TransformImage): $(OBJ_TransformImage) $(MDF_TransformImage)
@echo compiling $(MDF_TransformImage)
@$(BIN)/mdf2c -m $(MDF_TransformImage) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_TransformImage)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_TransformImage)
$(OBJ_TransformImage) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
#W#
$(EXE_WriteString): $(OBJ_WriteString) $(MDF_WriteString)
@echo compiling $(MDF_WriteString)
@$(BIN)/mdf2c -m $(MDF_WriteString) > user.c
@$(CC) $(CFLAGS) -c user.c
@echo "linking $(EXE_WriteString)"
@$(SHARED_LINK) $(DXABI) $(LDFLAGS) -o $(EXE_WriteString)
$(OBJ_WriteString) user.o $(DX_RTL_LDFLAGS) $(SYSLIBS) $(USERLIBS)
#
exe:
@echo "making user.mdf"
@cat $(MDFS) > user.mdf
@$(BIN)/mdf2c user.mdf > user.c
@$(CC) $(CFLAGS) -c user.c
@echo linking executable $(DXEXEC)
@$(CC) $(LDFLAGS) $(OBJS) user.o $(LIBS) $(USERLIBS) -o
$(EXEDIR)/$(DXEXEC)
@rm user.*
#
# a command to run the user module
edit:
@cat $(MDFS) > user.mdf
dx -edit $(FILE) -mdf user.mdf &
#
# run in executing mode with a given net file
run:
@cat $(MDFS) > user.mdf
dx -image -menubar $(FILE) -mdf user.mdf &
#
# run in script mode
runscript:
@cat $(MDFS) > user.mdf
dx -image -menubar $(FILE) -mdf user.mdf -script &
#
# edit the inboard executable
editexe:
@cat $(MDFS) |awk '$$1!="LOADABLE" {print $0}' > user.mdf
dx -edit -exec $(EXEDIR)/$(DXEXEC) -mdf user.mdf &
#
# run the inboard executable
runexe:
@cat $(MDFS) |awk '$$1!="LOADABLE" {print $0}' > user.mdf
dx -image -menubar -exec $(EXEDIR)/$(DXEXEC) -mdf user.mdf &
#
#
#debug:
# @cat $(MDFS) > user.mdf
# dx -uionly -mdf user.mdf &
# ddd dx -edit -mdf user.mdf &
#
# run the inboard executable in debugging mode
debug:
@cat $(MDFS) |awk '$$1!="LOADABLE" {print $0}' > user.mdf
dx -uionly $(FILE) -exec $(EXEDIR)/$(DXEXEC) -mdf user.mdf &
ddd $(EXEDIR)/$(DXEXEC) &
#
clean:
@echo cleaning objects...
@find . -name "*.o" -exec rm {} \;
@find . -name "*~" -exec rm {} \;
@find . -name "user.*" -exec rm {} \;
#
show:
@echo $(VPATH)
@echo $(INCL)
#
back:
@echo backing up net files
@tar uvf Backup.tar ./net/*.net ./net/*.cfg ./Makefile
@tar uvf Backup.tar ./macros/*.net ./Makefile
showback:
@echo showing backup net files
tar tvf Backup.tar
getback:
@ls $(FILE).net $(FILE).cfg | awk \
'{printf("mv %s
~/trashbin\n",$$0)}' |bash
@tar xf Backup.tar -O $(FILE).net | awk\
'{if ($$0~/time:/) OUT=0;
\
if ($$0~/time:/ && $$0 ~ /$(TIME)/)
OUT = 1; \
if (OUT == 1) print $$0}' >
$(FILE).net
@tar xf Backup.tar -O $(FILE).cfg | awk\
'{if ($$0~/time:/) OUT=0;
\
if ($$0~/time:/ && $$0 ~ /$(TIME)/)
OUT = 1; \
if (OUT == 1) print $$0}' >
$(FILE).cfg
#
cleanall:
@echo cleaning binaries...
@ls bin | awk '{printf("mv ./bin/%s ~/trashbin\n",$$0)}' |bash
#
help:
@echo Makefile options
@echo "make : compile and link
objects to loadable moldulels"
@echo "make exe : compile and link
objects to inboard executable"
@echo "make edit [FILE=<netfile>] : edit DX netfile with
loadable modules"
@echo "make editexe [FILE=<netfile>] : edit DX netfile as
inboard executable"
@echo "make run [FILE=<netfile>] : run DX netfile with
loadable modules"
@echo "make runexe [FILE=<netfile>] : run DX netfile as
inboard executable"
@echo "make debug [FILE=<netfile>] : debug a opendx as
inboard executable"
@echo "make clean : remove all object and
bak files"
@echo "make cleanall : clean + remove all
loadable executables"
@echo "make back : makes a backup of all
the .net and .cfg files"
@echo "make showback : shows a list of all
the back up files"
@echo "make getback FILE=<filename> TIME=<timestamp> :"
@echo " restores the back up file <filename>
(without extension)"
@echo " and the given time stamp"
