Sorry, I forgot the attachment
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"
