######################################################
#
#   Dwayne Phillips
#   The C Image Processing System
#   written for
#   The C Users Journal
#   1990-1993
#
#   This makefile uses Microsoft's nmake 
#   program.  See "Microsoft C Advanced Programming
#   Techniques," Chapter 6, Microsoft Corp., 1990.
#
#
#      C O N T E N T S
#
#   Define Macros
#   Compile Source Files
#   Composite Files
#   CIPS Programs
#   CIPS Backups
#   cipscat
#   fit
#
######################################################
#
#      D E F I N E   M A C R O S
#
#   Microsoft C 6.0 commands
#   compile options
#      /AL = large memory model
#      /c  = do not create .exe file
#      /Zi = prepare for Codeview
#      /Od = remove optimization for Codeview
#      /G2 = create 80286 code instead of 8086 code
#
#   linker options
#      /CO = prepare for Codeview
#      /STACK:50000 = allocate 50000 bytes for stack
#

#   Define the compile command for the large model
CC = CL /AL /c

#   Define the compile command for the large model
#   and the Codeview debugger
CCV = CL /AL /Zi /od /c

#   Define the compile and link in one command
CAL = CL /AL /o

#   Define the Codeview and stack command
#   for the linker commands.
#   The $* means the target's base name
#   with no extensions.  So
#   /STACK:40000,$*,$*; equals
#   /STACK:40000,toc,toc;
#ST40K = /STACK:40000,$*,$*;
#ST45K = /STACK:45000,$*,$*;
#ST50K = /STACK:50000,$*,$*;
#COST40K = /CO /STACK:40000,$*,$*;
#COST45K = /CO /STACK:45000,$*,$*;
#COST50K = /CO /STACK:50000,$*,$*;
#   NOTE:  When I installed my Microsoft C, I
#          included the Microsoft graphics library
#          in the main library.  If you did not
#          do this, you should use the following
#          for the stack linker commands (assuming
#          you installed Microsoft C in d:):
#
#
#   1-25-94 
#   I am now using Microsoft C/C++ 7.0 so I need
#   to reach the graphics.lib file.

LIBDIR = c:\c700\lib

#ST40K = /STACK:40000,$*,$*,d:\c600\lib\graphics.lib;
#ST45K = /STACK:45000,$*,$*,d:\c600\lib\graphics.lib;
#ST50K = /STACK:50000,$*,$*,d:\c600\lib\graphics.lib;
#COST40K = /CO /STACK:40000,$*,$*,d:\c600\lib\graphics.lib;
#COST45K = /CO /STACK:45000,$*,$*,d:\c600\lib\graphics.lib;
#COST50K = /CO /STACK:50000,$*,$*,d:\c600\lib\graphics.lib;
ST40K = /STACK:40000,$*,$*,$(LIBDIR)\graphics.lib;
ST45K = /STACK:45000,$*,$*,$(LIBDIR)\graphics.lib;
ST50K = /STACK:50000,$*,$*,$(LIBDIR)\graphics.lib;
COST40K = /CO /STACK:40000,$*,$*,$(LIBDIR)\graphics.lib;
COST45K = /CO /STACK:45000,$*,$*,$(LIBDIR)\graphics.lib;
COST50K = /CO /STACK:50000,$*,$*,$(LIBDIR)\graphics.lib;




######################################################
#
#      C O M P I L E   S O U R C E   F I L E S
#

pattern.obj :  pattern.c cips.h
     $(CC) pattern.c

segment3.obj :  segment3.c cips.h
     $(CC) segment3.c

roundoff.obj :  roundoff.c cips.h
     $(CC) roundoff.c

ndir.obj :  ndir.c
     $(CC) ndir.c

tiff.obj :  tiff.c cips.h
     $(CC) tiff.c

gin.obj :  gin.c cips.h
     $(CC) gin.c

rstring.obj :  rstring.c cips.h
     $(CC) rstring.c

texture.obj :  texture.c cips.h
     $(CC) texture.c

xtra.obj :  xtra.c cips.h
     $(CC) xtra.c

txtrsubs.obj :  txtrsubs.c cips.h
     $(CC) txtrsubs.c

geosubs.obj :  geosubs.c cips.h
     $(CC) geosubs.c

warpsubs.obj :  warpsubs.c cips.h
     $(CC) warpsubs.c

geometry.obj :  geometry.c cips.h
     $(CC) geometry.c

warp.obj :  warp.c cips.h
     $(CC) warp.c

mrw.obj :  mrw.c cips.h
     $(CC) mrw.c

mof.obj :  mof.c cips.h
     $(CC) mof.c

rtiff.obj :  rtiff.c cips.h
     $(CC) rtiff.c

cips.obj :  cips.c cips.h
     $(CC) cips.c

show.obj :  show.c cips.h
     $(CC) show.c

cipspr.obj :  cipspr.c cips.h
     $(CC) cipspr.c

gpcips.obj :  gpcips.c cips.h
     $(CC) gpcips.c

mymsc.obj :  mymsc.c cips.h
     $(CC) mymsc.c

fwrite.obj :  fwrite.c cips.h
     $(CC) fwrite.c

numcvrt.obj :  numcvrt.c cips.h
     $(CC) numcvrt.c

display.obj :  display.c cips.h
     $(CC) display.c
#   xdisplay.c is a version of display.c
#   containing experimental code that
#   is not used in CIPS
xdisplay.obj :  xdisplay.c cips.h
     $(CC) xdisplay.c

hist.obj :  hist.c cips.h
     $(CC) hist.c

strappnd.obj :  strappnd.c cips.h
     $(CC) strappnd.c

pi.obj :  pi.c cips.h
     $(CC) pi.c

ht.obj :  ht.c cips.h
     $(CC) ht.c

djet.obj :  djet.c cips.h
     $(CC) djet.c

filter.obj :  filter.c cips.h
     $(CC) filter.c

addsub.obj :  addsub.c cips.h
     $(CC) addsub.c

rotate.obj :  rotate.c cips.h
     $(CC) rotate.c

cutp.obj :  cutp.c cips.h
     $(CC) cutp.c

scale.obj :  scale.c cips.h
     $(CC) scale.c

mainas.obj :  mainas.c cips.h
     $(CC) mainas.c

mainr.obj :  mainr.c cips.h
     $(CC) mainr.c

maincp.obj :  maincp.c cips.h
     $(CC) maincp.c

main422.obj : main422.c cips.h
     $(CC) main422.c

half.obj : half.c cips.h
     $(CC) half.c

double.obj :  double.c cips.h
     $(CC) double.c

stretch.obj :  stretch.c cips.h
     $(CC) stretch.c

side.obj : side.c cips.h
     $(CC) side.c

edge.obj :  edge.c cips.h
     $(CC) edge.c

edge2.obj :  edge2.c cips.h
     $(CC) edge2.c

edge3.obj :  edge3.c cips.h
     $(CC) edge3.c

wtiff.obj :  wtiff.c cips.h
     $(CC) wtiff.c

create.obj :  create.c cips.h
     $(CC) create.c

wtiffh.obj :  wtiffh.c cips.h
     $(CC) wtiffh.c

boole.obj : boole.c cips.h
     $(CC) boole.c

boolean.obj : boolean.c cips.h
     $(CC) boolean.c

overlay.obj : overlay.c cips.h
     $(CC) overlay.c

ed.obj : ed.c cips.h
     $(CC) ed.c

skeleton.obj : skeleton.c cips.h
     $(CC) skeleton.c

mainsk.obj : mainsk.c cips.h
     $(CC) mainsk.c
invert.obj : invert.c cips.h
     $(CC) invert.c

mainover.obj : mainover.c cips.h
     $(CC) mainover.c

mainedge.obj :  mainedge.c cips.h
     $(CC) mainedge.c

mainhist.obj :  mainhist.c cips.h
     $(CC) mainhist.c

mainfilt.obj :  mainfilt.c cips.h
     $(CC) mainfilt.c

mainseg.obj : mainseg.c cips.h
     $(CC) mainseg.c

main2seg.obj : main2seg.c cips.h
     $(CC) main2seg.c

main3seg.obj : main3seg.c cips.h
     $(CC) main3seg.c

fixt.obj : fixt.c cips.h
     $(CC) fixt.c

unfixt.obj : unfixt.c cips.h
     $(CC) unfixt.c

segment.obj : segment.c cips.h
     $(CC) segment.c

segment2.obj :  segment2.c cips.h
     $(CC) segment2.c

###############################################
#
#      C O M P O S I T E   F I L E S
#
#  Composite files are like small libraries.
#  A composite file contains several .c file
#  concatenated together.  This makes the
#  command lines shorter for linking the .obj
#  files into .exe files.
#
#  The cipscat program (see end of makefile)
#  concatenates these together automatically.
#
#
#
#
#  COMPOSITE FILE
#  tiffs.c = rtiff.c + wtiff.c + tiff.c
tiffs.obj :  tiffs.c cips.h
     $(CC) tiffs.c

tiffs.c: rtiff.c  wtiff.c  tiff.c
     cipscat rtiff.c  wtiff.c  tiff.c -o tiffs.c



#  COMPOSITE FILE
# cips2.c = rstring + mof + mrw + gpcips
#           + numcvrt + strappnd
#
#   The above was changed to the below
#   12 May 1993
#
# cips2.c = gpcips + numcvrt + mymsc.c
cips2.obj :  cips2.c cips.h
     $(CC) cips2.c

cips2.c: gpcips.c numcvrt.c mymsc.c
     cipscat gpcips.c numcvrt.c mymsc.c -o cips2.c



#  COMPOSITE FILE
# cips3.c = addsub + cutp + rotate
cips3.obj :  cips3.c cips.h
     $(CC) cips3.c

cips3.c: addsub.c cutp.c rotate.c
     cipscat addsub.c cutp.c rotate.c -o cips3.c



#  COMPOSITE FILE
# cips4.c = gin + fwrite + hist + pi + ht
#
#   The above was changed to the below
#   12 May 1993
#
# cips4.c = gin + hist + pi + ht
cips4.obj :  cips4.c cips.h
     $(CC) cips4.c

cips4.c: gin.c  hist.c  pi.c  ht.c
     cipscat gin.c hist.c pi.c ht.c -o cips4.c



#  COMPOSITE FILE
# cips5.c = boole + overlay + txtrsubs
cips5.obj :  cips5.c cips.h
     $(CC) cips5.c

cips5.c: boole.c overlay.c txtrsubs.c
     cipscat boole.c overlay.c txtrsubs.c -o cips5.c



#  COMPOSITE FILE
# cips6.c = filter + display + djet + scale
cips6.obj :  cips6.c cips.h
     $(CC) cips6.c

cips6.c: filter.c display.c djet.c scale.c
     cipscat filter.c display.c djet.c scale.c -o cips6.c



#  COMPOSITE FILE
# cips7.c = filter + display + djet + scale
cips7.obj :  cips7.c cips.h
     $(CC) cips7.c

cips7.c: ed.c skeleton.c segment.c segment2.c
     cipscat ed.c skeleton.c segment.c segment2.c -o cips7.c



#  COMPOSITE FILE
# edges.c = edge.c + edge2.c + edge3.c
edges.obj :  edges.c cips.h
     $(CC) edges.c

edges.c: edge.c edge2.c edge3.c
     cipscat edge.c edge2.c edge3.c -o edges.c



######################################################
#
#      C I P S   P R O G R A M S
#
#   Special make targets:
#      allip - makes all .exe's - may not work because
#              the compiler runs out of heap space and
#              things like that.  Use the makeall.bat
#              file to do this
#
#      cleanobj - deletes all the .obj files
#      cleanexe - deletes all the .exe files
#


allip:
   nmake cipscat.exe
   nmake cips.exe
   nmake mainedge.exe
   nmake mainhist.exe
   nmake mainfilt.exe
   nmake mainas.exe
   nmake mainr.exe
   nmake maincp.exe
   nmake main422.exe
   nmake side.exe
   nmake half.exe
   nmake double.exe
   nmake stretch.exe
   nmake create.exe
   nmake mainseg.exe
   nmake main2seg
   nmake pattern.exe
   nmake roundoff.exe
   nmake show.exe
   nmake cipspr.exe
   nmake fixt.exe
   nmake unfixt.exe
   nmake boolean.exe
   nmake mainover.exe
   nmake invert.exe
   nmake mainsk.exe
   nmake ilabel.exe
   nmake texture.exe
   nmake geometry.exe
   nmake warp.exe

cleanobj:
     del *.obj

cleanexe:
     del *.exe


######################################################
#
#      Define the files needed by CIPS
#      First define the C source files and then
#      define the object files and link files
#      in terms of the source files.
#
#      If you add any files to cips, you only
#      need to add them to CIPSSRC.
#
#              17 October 1992

CIPSSRC = tiffs.c edges.c \
cips.c cips2.c cips3.c cips4.c cips5.c cips6.c \
cips7.c fitt.c geosubs.c warpsubs.c

CIPSOBJ  = $(CIPSSRC:.c=.obj)
CIPSLIST = $(CIPSSRC:.c=)

cips.exe: $(CIPSOBJ)
     link $(CIPSLIST) $(ST45K)
cips: cips.exe



######################################################
#
#     Define the stand alone application programs
#     in a similar manner as cips above.


SHOWSRC = tiffs.c cips4.c cips2.c show.c \
          display.c cips3.c
SHOWOBJ  = $(SHOWSRC:.c=.obj)
SHOWLIST = $(SHOWSRC:.c=)
show: show.exe
show.exe: $(SHOWOBJ)
     link $(SHOWLIST) $(ST45K)


STSTSRC = tiffs.c cips4.c cips2.c showtest.c \
          disptest.c cips3.c
STSTOBJ  = $(STSTSRC:.c=.obj)
STSTLIST = $(STSTSRC:.c=)
showtest: showtest.exe
showtest.exe: $(STSTOBJ)
     link $(STSTLIST) $(ST45K)



CIPSPRSRC = tiffs.c cips4.c cips2.c cipspr.c djet.c \
            cips3.c display.c
CIPSPROBJ  = $(CIPSPRSRC:.c=.obj)
CIPSPRLIST = $(CIPSPRSRC:.c=)
cipspr: cipspr.exe
cipspr.exe: $(CIPSPROBJ)
     link $(CIPSPRLIST) $(ST45K)



ESRC  = tiffs.c gin.c cips2.c mainedge.c \
        edges.c filter.c
EOBJ  = $(ESRC:.c=.obj)
ELIST = $(ESRC:.c=)
mainedge.exe: $(EOBJ)
     link $(ELIST) $(ST50K)
mainedge: mainedge.exe



TSRC  = tiffs.c gin.c cips2.c texture.c \
        txtrsubs.c filter.c edges.c fitt.c
TOBJ  = $(TSRC:.c=.obj)
TLIST = $(TSRC:.c=)
texture.exe: $(TOBJ)
     link $(TLIST) $(ST50K)
texture: texture.exe



GSRC  = tiffs.c gin.c cips2.c geometry.c \
        geosubs.c 
GOBJ  = $(GSRC:.c=.obj)
GLIST = $(GSRC:.c=)
geometry.exe: $(GOBJ)
     link $(GLIST) $(ST40K)
geometry: geometry.exe



WSRC  = tiffs.c gin.c cips2.c warp.c \
        warpsubs.c geosubs.c 
WOBJ  = $(WSRC:.c=.obj)
WLIST = $(WSRC:.c=)
warp.exe: $(WOBJ)
     link $(WLIST) $(ST40K)
warp: warp.exe



MHSRC  = tiffs.c cips4.c cips2.c mainhist.c
MHOBJ  = $(MHSRC:.c=.obj)
MHLIST = $(MHSRC:.c=)
mainhist.exe: $(MHOBJ)
     link  $(MHLIST) $(ST45K)
mainhist: mainhist.exe



MFSRC  = tiffs.c cips2.c cips4.c mainfilt.c \
         edge.c filter.c
MFOBJ  = $(MFSRC:.c=.obj)
MFLIST = $(MFSRC:.c=)
mainfilt.exe: $(MFOBJ)
     link $(MFLIST) $(ST45K)
mainfilt: mainfilt.exe



MASSRC  = tiffs.c cips2.c cips4.c edge.c \
          mainas.c addsub.c
MASOBJ  = $(MASSRC:.c=.obj)
MASLIST = $(MASSRC:.c=)
mainas.exe: $(MASOBJ)
     link $(MASLIST) $(ST45K)
mainas: mainas.exe



MRSRC  = tiffs.c cips2.c mainr.c edge.c rotate.c
MROBJ  = $(MRSRC:.c=.obj)
MRLIST = $(MRSRC:.c=)
mainr.exe: $(MROBJ)
     link  $(MRLIST) $(ST45K)
mainr: mainr.exe



maincp: maincp.exe
MCPSRC  = tiffs.c cips2.c maincp.c cutp.c
MCPOBJ  = $(MCPSRC:.c=.obj)
MCPLIST = $(MCPSRC:.c=)
maincp.exe: $(MCPOBJ)
     link  $(MCPLIST) $(ST45K)



SIDESRC  = tiffs.c cips2.c side.c cutp.c
SIDEOBJ  = $(SIDESRC:.c=.obj)
SIDELIST = $(SIDESRC:.c=)
side.exe: $(SIDEOBJ)
     link $(SIDELIST) $(ST45K)
side: side.exe


M422SRC  = tiffs.c cips2.c main422.c edge.c \
           scale.c filter.c
M422OBJ  = $(M422SRC:.c=.obj)
M422LIST = $(M422SRC:.c=)
main422.exe: $(M422OBJ)
     link  $(M422LIST) $(ST45K)
main422: main422.exe



DBSRC  = tiffs.c cips2.c double.c \
         edge.c filter.c
DBOBJ  = $(DBSRC:.c=.obj)
DBLIST = $(DBSRC:.c=)
double.exe: $(DBOBJ)
     link  $(DBLIST) $(ST45K)
double: double.exe



STSRC  = tiffs.c cips2.c stretch.c
STOBJ  = $(STSRC:.c=.obj)
STLIST = $(STSRC:.c=)
stretch.exe: $(STOBJ)
     link  $(STLIST) $(ST45K)
stretch: stretch.exe



HASRC  = tiffs.c cips2.c half.c edge.c \
         scale.c filter.c
HAOBJ  = $(HASRC:.c=.obj)
HALIST = $(HASRC:.c=)
half.exe: $(HAOBJ)
     link  $(HALIST) $(ST45K)
half: half.exe



CRSRC  =  tiffs.c cips2.c create.c
CROBJ  = $(CRSRC:.c=.obj)
CRLIST = $(CRSRC:.c=)
create.exe: $(CROBJ)
     link  $(CRLIST) $(ST45K)
create: create.exe



PATSRC  = pattern.c tiffs.c cips2.c
PATOBJ  = $(PATSRC:.c=.obj)
PATLIST = $(PATSRC:.c=)
pattern.exe: $(PATOBJ)
     link  $(PATLIST) $(ST45K)
pattern: pattern.exe



ROUNDSRC = roundoff.c tiff.c gin.c cips2.c \
           rtiff.c wtiff.c
ROUNDOBJ = $(ROUNDSRC:.c=.obj)
ROUNDLIST = $(ROUNDSRC:.c=)
roundoff.exe: $(ROUNDOBJ)
     link  $(ROUNDLIST) $(ST45K)
roundoff: roundoff.exe




MAIN2SRC  = tiffs.c cips2.c cips4.c cips7.c \
            edges.c filter.c main2seg.c
MAIN2OBJ  = $(MAIN2SRC:.c=.obj)
MAIN2LIST = $(MAIN2SRC:.c=)
main2seg.exe: $(MAIN2OBJ)
     link $(MAIN2LIST) $(ST40K)
main2seg: main2seg.exe


SEGSRC = tiffs.c cips2.c mainseg.c segment.c cips4.c
SEGOBJ  = $(SEGSRC:.c=.obj)
SEGLIST = $(SEGSRC:.c=)
mainseg.exe: $(SEGOBJ)
     link  $(SEGLIST) $(ST45K)
mainseg: mainseg.exe


FIXTSRC = tiff.c cips2.c rtiff.c fixt.c wtiff.c
FIXTOBJ  = $(FIXTSRC:.c=.obj)
FIXTLIST = $(FIXTSRC:.c=)
fixt.exe: $(FIXTOBJ)
    link  $(FIXTLIST) $(ST40K)
fixt: fixt.exe



UNFIXTSRC = tiff.c cips2.c rtiff.c unfixt.c wtiff.c
UNFIXTOBJ  = $(UNFIXTSRC:.c=.obj)
UNFIXTLIST = $(UNFIXTSRC:.c=)
unfixt.exe: $(UNFIXTOBJ)
    link  $(UNFIXTLIST) $(ST40K)
unfixt: unfixt.exe



BOOLSRC  = tiffs.c boolean.c boole.c cips2.c
BOOLOBJ  = $(BOOLSRC:.c=.obj)
BOOLLIST = $(BOOLSRC:.c=)
boolean.exe: $(BOOLOBJ)
    link  $(BOOLLIST) $(ST40K)
boolean: boolean.exe



OVERSRC  = tiffs.c mainover.c overlay.c cips2.c
OVEROBJ  = $(OVERSRC:.c=.obj)
OVERLIST = $(OVERSRC:.c=)
mainover.exe: $(OVEROBJ)
    link  $(OVERLIST) $(ST45K)
mainover: mainover.exe



INVSRC  = tiffs.c invert.c cips2.c
INVOBJ  = $(INVSRC:.c=.obj)
INVLIST = $(INVSRC:.c=)
invert.exe: $(INVOBJ)
    link  $(INVLIST) $(ST40K)
invert: invert.exe



SKSRC  = cips7.c tiffs.c mainsk.c cips2.c \
         edges.c filter.c
SKOBJ  = $(SKSRC:.c=.obj)
SKLIST = $(SKSRC:.c=)
mainsk.exe: $(SKOBJ)
    link  $(SKLIST) $(ST40K)
mainsk: mainsk.exe


ILSRC  = ilabel.c tiffs.c cips2.c
ILOBJ  = $(ILSRC:.c=.obj)
ILLIST = $(ILSRC:.c=)
ilabel.exe: $(ILOBJ)
    link  $(ILLIST) $(ST40K)
ilabel: ilabel.exe



######################################################
#
#      C I P S   B A C K U P S
#
#      Create a backup utility that will copy all the
#      CIPS source code files to a floppy disk given
#      by CIPSFLOPPY.

CIPSFLOPPY = a:

#      Now - this is the master backup command

cipsbackup:
     nmake bcipscp
     nmake bcipsxtra
     nmake bcipsh
     nmake bcipsmain

#      The copy command copy $** copies all of the
#      dependent files to cipsfloppy
#
#      First define a backup for the CIPSSRC files

bcipscp: $(CIPSSRC)
     !copy $** $(CIPSFLOPPY)

#      CIPSH is all the included .h files

CIPSH      = cips.h makeall.bat

#      CIPSXTRA is all the individual files I used
#      to create the composite files.

CIPSXTRA   = rstring.c gpcips.c numcvrt.c \
             addsub.c cutp.c rotate.c xdisplay.c \
             edge.c edge2.c edge3.c segment.c \
             segment2.c wtiff.c rtiff.c tiff.c \
             gin.c fwrite.c hist.c pi.c ht.c \
             ed.c skeleton.c cipscat.c mymsc.c \
             boole.c overlay.c txtrsubs.c djet.c \
             filter.c display.c scale.c

#      CIPSMAIN is all the main files for the extra
#      programs.

CIPSMAIN   = mainedge.c mainhist.c mainfilt.c \
             mainas.c maincp.c mainr.c main422.c \
             half.c double.c side.c create.c \
             mainseg.c pattern.c roundoff.c \
             fixt.c main2seg.c show.c \
             unfixt.c boolean.c mainover.c invert.c \
             mainsk.c ilabel.c cipspr.c texture.c \
             geometry.c warp.c

#      Backup the xtra files

bcipsxtra: $(CIPSXTRA)
     copy  makefile $(CIPSFLOPPY)
     !copy $** $(CIPSFLOPPY)

#      Backup the include .h  files

bcipsh: $(CIPSH)
     !copy $** $(CIPSFLOPPY)

#      Backup the main.c files

bcipsmain: $(CIPSMAIN)
     !copy $** $(CIPSFLOPPY)

######################################################
#
#     C I P S C A T
#
#   The cipscat program concatenates .c files together
#   but only copies the first occurance of the
#   include cips.h statement.  This allows you to put
#   together files such as addsub.c cutp.c rotate.c
#   into cips3.c with one command:
#   cipscat addsub.c cutp.c rotate.c -o cips3.c

cipscat.obj: cipscat.c
     $(CC) cipscat.c

cipscat.exe: cipscat.obj
     link cipscat $(ST40K)
cipscat: cipscat.exe


######################################################
#
#     F I T
#
#   The following is a special test program to
#   test the fit routine's ability to fit data
#   to a straight line.  The code in the file fitt.c
#   is from Numerical Recipies in C.
#   21 August 1993


FITSSRC = fitt.c mainfit.c
FITSOBJ  = $(FITSSRC:.c=.obj)
FITSLIST = $(FITSSRC:.c=)

mainfit.exe: $(FITSOBJ)
     link $(FITSLIST) $(ST45K)
mainfit: mainfit.exe

mainfit.obj :  mainfit.c cips.h
     $(CC) mainfit.c

fitt.obj :  fitt.c cips.h
     $(CC) fitt.c

stupid.obj: stupid.c
     $(CC) stupid.c

stupid.exe: stupid.obj
     link stupid $(ST40K)
stupid: stupid.exe
