# %W% %E%

#

# -------------- no need to change anything below ----------

LIBNAME=libbasic

LIB=libbasic.$(A)

SUBDIRS=

STCOPT=$(LIBBASIC_STCOPT)

TOP=..

I       = $(INCLUDE)

STCFLAGS= -H../include -warnGlobalAssign $(STCOPT)

all::   $(OBJTARGET)

shared:

	make STCOPT=$(STCOPT)" +sharedLibCode" O=so objs auxobjs

install:: 

	-mkdir $(DESTLIBDIR)

	-$(INSTALL) $(LIBNAME)$(OBJNAME) $(DESTLIBDIR)

qinstall::

	-mkdir $(DESTLIBDIR)

	-$(INSTALL) $(LIBNAME)$(OBJNAME) $(DESTLIBDIR)

libe:   $(LIB)

#

# only needed for NeXT - assembler dumps core with long name ?!?!

#

SeqColl.$(O):

	$(STC) -CC="$(CC)" $(STCFLAGS) +shortNames $(CFLAGS) -c $*.st

PSPrStr.$(O):

	$(STC) -CC="$(CC)" $(STCFLAGS) +limitSuperInclude $(CFLAGS) -c $*.st

HPIIPrStr.$(O):

	$(STC) -CC="$(CC)" $(STCFLAGS) +limitSuperInclude $(CFLAGS) -c $*.st

FX1PrStr.$(O):

	$(STC) -CC="$(CC)" $(STCFLAGS) +limitSuperInclude $(CFLAGS) -c $*.st

Class:

	$(MAKE) Class.o OPT=""

Metaclass:

	$(MAKE) Metaclass.o OPT=""

i_Class.o:

	$(MAKE) I_CLASS OPT=""

i_Metaclass.o:

	$(MAKE) I_METACLASS OPT=""

I_CLASS:

	$(CC) -c $(CFLAGS) i_Class.c

I_METACLASS:

	$(CC) -c $(CFLAGS) i_Metaclass.c

cleanjunk::

	-rm -f *.c *.H

clean::

	-rm -f *.c *.H

clobber::

	-rm -f *.c *.H

tar:

	rm -f $(TOP)/DISTRIB/libbasic.tar*

	(cd $(TOP); tar cvf DISTRIB/libbasic.tar \

	                        libbasic/*.st \

	                        libbasic/Make.proto \

	                        libbasic/*.stc)

	compress $(TOP)/DISTRIB/libbasic.tar

#

# next thing I'll build into stc is a makedepend feature for this ...

#

STCHDR=$(I)/stc.h $(I)/stcIntern.h

OBJECT=$(I)/Object.H $(STCHDR)

BOOLEAN=$(I)/Boolean.H $(OBJECT)

BEHAVIOR=$(I)/Behavior.H $(OBJECT)

CLASS=$(I)/Class.H $(I)/ClassDescr.H $(BEHAVIOR)

Object.$(O):    Object.st $(STCHDR)

UndefObj.$(O):  UndefObj.st $(OBJECT)

Message.$(O):   Message.st $(OBJECT)

Unix.o:         Unix.st $(OBJECT)

Autoload.o:     Autoload.st $(OBJECT)

Smalltalk.o:    Smalltalk.st $(OBJECT)

ObjMem.o:       ObjMem.st $(OBJECT)

Process.o:      Process.st $(OBJECT)

ProcSched.o:    ProcSched.st $(OBJECT)

Semaphore.o:    Semaphore.st $(OBJECT)

Queue.o:        Queue.st $(OBJECT)

Delay.o:        Delay.st $(OBJECT)

SharedQueue.o:  SharedQueue.st $(I)/Queue.H $(OBJECT)

MsgTally.o:     MsgTally.st  $(OBJECT)

MiniDebug.o:    MiniDebug.st $(OBJECT)

MiniIns.o:      MiniIns.st $(OBJECT)

Context.o:      Context.st $(OBJECT)

BContext.o:     BContext.st $(I)/Context.H $(OBJECT)

Method.o:       Method.st $(OBJECT)

Block.o:        Block.st $(OBJECT)

BlckContext.o:  BlckContext.st $(OBJECT)

Signal.o:       Signal.st $(OBJECT)

Exception.o:    Exception.st $(OBJECT)

Rectangle.o:    Rectangle.st $(OBJECT)

Assoc.o:        Assoc.st $(OBJECT)

Boolean.o:      Boolean.st $(OBJECT)

True.o:         True.st $(BOOLEAN)

False.o:        False.st $(BOOLEAN)

ExtSource.o:    ExtSource.st $(OBJECT)

Behavior.o:     Behavior.st $(OBJECT)

ClassDescr.o:   ClassDescr.st $(BEHAVIOR)

Class.o:        Class.st $(I)/ClassDescr.H $(BEHAVIOR)

Metaclass.o:    Metaclass.st $(CLASS)

CCReader.o:     CCReader.st $(OBJECT)

BCCReader.o:    BCCReader.st $(I)/CCReader.H $(OBJECT)

Project.o:      Project.st $(OBJECT)

MAGNITUDE=$(I)/Magnitude.H $(OBJECT)

ABSTIME=$(I)/AbsTime.H $(MAGNITUDE)

ARITHVAL=$(I)/ArithVal.H $(MAGNITUDE)

NUMBER=$(I)/Number.H $(ARITHVAL)

INTEGER=$(I)/Integer.H $(NUMBER)

Magnitude.o:    Magnitude.st $(OBJECT)

Point.o:        Point.st $(MAGNITUDE)

Character.o:    Character.st $(MAGNITUDE)

ArithVal.o:     ArithVal.st $(MAGNITUDE)

Number.o:       Number.st $(ARITHVAL)

Integer.o:      Integer.st $(NUMBER)

Fraction.o:     Fraction.st $(NUMBER)

SmallInt.o:     SmallInt.st $(INTEGER)

LargeInt.o:     LargeInt.st $(INTEGER)

AbsTime.o:      AbsTime.st $(MAGNITUDE)

Time.o:         Time.st $(ABSTIME)

Date.o:         Date.st $(ABSTIME)

COLL=$(I)/Coll.H $(OBJECT)

SET=$(I)/Set.H $(COLL)

DICT=$(I)/Dict.H $(COLL)

IDDICT=$(I)/IdDict.H $(DICT)

WEAKIDDICT=$(I)/WeakIdDict.H $(IDDICT)

SEQCOLL=$(I)/SeqColl.H $(COLL)

ARRCOLL=$(I)/ArrColl.H $(SEQCOLL)

ARRAY=$(I)/Array.H $(ARRCOLL)

VARARRAY=$(I)/VarArray.H $(ARRCOLL)

BYTEARRAY=$(I)/ByteArray.H $(ARRCOLL)

Registry.o:     Registry.st $(OBJECT)

Coll.o:         Coll.st $(OBJECT)

FileDir.o:      FileDir.st $(COLL)

SeqColl.o:      SeqColl.st $(COLL)

MappedColl.o:   MappedColl.st $(COLL)

Set.o:          Set.st $(COLL)

IdSet.o:        IdSet.st $(SET)

SignalSet.o:    SignalSet.st $(I)/IdSet.H $(SET)

Bag.o:          Bag.st $(COLL)

Dict.o:         Dict.st $(COLL)

IdDict.o:       IdDict.st $(DICT)

CacheDict.o:    CacheDict.st $(DICT)

WeakIdDict.o:   WeakIdDict.st $(IDDICT)

OrdColl.o:      OrdColl.st $(SEQCOLL)

SortColl.o:     SortColl.st $(I)/OrdColl.H $(SEQCOLL)

ChangeSet.o:    ChangeSet.st $(I)/OrdColl.H $(SEQCOLL)

Interval.o:     Interval.st $(SEQCOLL)

Node.o:         Node.st $(COLL)

Tree.o:         Tree.st $(COLL)

LinkList.o:     LinkList.st $(SEQCOLL)

Link.o:         Link.st $(OBJECT)

ValLink.o:      ValLink.st $(I)/Link.H $(OBJECT)

ArrColl.o:      ArrColl.st $(SEQCOLL)

VarArray.o:     VarArray.st $(ARRCOLL)

VarString.o:    VarString.st $(ARRCOLL)

Text.o:         Text.st $(VARARRAY)

FileText.o:     FileText.st $(I)/Text.H $(VARARRAY)

Array.o:        Array.st $(ARRCOLL)

Polygon.o:      Polygon.st $(ARRAY)

WeakArr.o:      WeakArr.st $(ARRAY)

FloatArray.o:   FloatArray.st $(ARRCOLL)

DoubleArray.o:  DoubleArray.st $(ARRCOLL)

ExtBytes.o:     ExtBytes.st $(ARRCOLL)

ByteArray.o:    ByteArray.st $(ARRCOLL)

UIBytes.o:      UIBytes.st $(BYTEARRAY)

Symbol.o:       Symbol.st $(STRING)

Filename.o:     Filename.st $(STRING)

Change.o:       Change.st $(OBJECT)

ClassChg.o:     ClassChg.st $(OBJECT)

ClsDefChg.o:    ClsDefChg.st $(OBJECT)

ClsComChg.o:    ClsComChg.st $(OBJECT)

MethodChg.o:    MethodChg.st $(OBJECT)

STREAM=$(I)/Stream.H $(OBJECT)

POSSTREAM=$(I)/PosStream.H $(STREAM)

WRITESTREAM=$(I)/WriteStr.H $(POSSTREAM)

RWSTREAM=$(I)/RWStream.H $(WRITESTREAM)

EXTSTREAM=$(I)/ExtStream.H $(RWSTREAM)

NPEXTSTREAM=$(I)/NPExtStr.H $(EXTSTREAM)

PIPESTREAM=$(I)/PipeStr.H $(NPEXTSTREAM)

Stream.o:       Stream.st $(OBJECT)

Random.o:       Random.st $(STREAM)

ReadStr.o:      ReadStr.st $(POSSTREAM)

WriteStr.o:     WriteStr.st $(POSSTREAM)

RWStream.o:     RWStream.st $(WRITESTREAM)

ActorStr.o:     ActorStr.st $(RWSTREAM)

ExtStream.o:    ExtStream.st $(RWSTREAM)

NPExtStr.o:     NPExtStr.st $(EXTSTREAM)

TTYStream.o:    TTYStream.st $(NPEXTSTREAM)

PipeStr.o:      PipeStr.st $(NPEXTSTREAM)

Socket.o:       Socket.st $(NPEXTSTREAM)

PrintStr.o:     PrintStr.st $(PIPESTREAM)

PSPrStr.o:      PSPrStr.st $(I)/PrintStr.H $(PIPESTREAM)

HPIIPrStr.o:    HPIIPrStr.st $(I)/PrintStr.H $(PIPESTREAM)

FX1PrStr.o:     FX1PrStr.st $(I)/PrintStr.H $(PIPESTREAM)

FileStr.o:      FileStr.st $(EXTSTREAM)

SoundStr.o:     SoundStr.st $(I)/FileStr.H $(EXTSTREAM)

DirStr.o:       DirStr.st $(I)/FileStr.H $(EXTSTREAM)