# use normal make for this Makefile
#
# Makefile for building user programs to run on top of Nachos
#
# Several things to be aware of:
#
#    Nachos assumes that the location of the program startup routine (the
# 	location the kernel jumps to when the program initially starts up)
#       is at location 0.  This means: start.o must be the first .o passed 
# 	to ld, in order for the routine "Start" to be loaded at location 0
#
# if you are cross-compiling, you need to point to the right executables
# and change the flags to ld and the build procedure for as
# GCCDIR = ~/gnu/local/decstation-ultrix/bin/
# LDFLAGS = -T script -N
# ASFLAGS = -mips
# CPPFLAGS = $(INCDIR)
# if you aren't cross-compiling:
# 27/Feb/96 Direccion del cross-compiler
# GCCDIR =
# LDFLAGS = -N -T 0
# ASFLAGS =
# CPPFLAGS = -P $(INCDIR)
# Estamos utilizando un cross-compiler, ver comentario arriba
GCCDIR = /usr/local/nachos/decstation-ultrix/bin/
LDFLAGS = -T script -N
ASFLAGS = -mips
CPPFLAGS = $(INCDIR)

CC = /usr/local/nachos/decstation-ultrix/bin/gcc
AS = $(GCCDIR)as
LD = $(GCCDIR)ld

CPP = /usr/ccs/lib/cpp
INCDIR =-I../userprog -I../threads
# CFLAGS = -G 0 -c $(INCDIR)
CFLAGS = -G -c $(INCDIR)


all: halt shell matmult sort forkPrueba pruebaSem read

halt.o:	halt.c
	$(CC) $(CFLAGS) -c halt.c
halt:	halt.o start.o
	$(LD) $(LDFLAGS) start.o halt.o -o halt.coff
	../bin/coff2noff halt.coff halt

start.o: start.s ../userprog/syscall.h
	$(CPP) $(CPPFLAGS) start.s > strt.s
	$(AS) $(ASFLAGS) -o start.o strt.s
	rm strt.s

BradAgua.o: BradAgua.c
	$(CC) $(CFLAGS) -c BradAgua.c
BradAgua: BradAgua.o start.o
	$(LD) $(LDFLAGS) start.o BradAgua.o -o BradAgua.coff
	../bin/coff2noff BradAgua.coff BradAgua
 
BradPingPong.o: BradPingPong.c 
	$(CC) $(CFLAGS) -c BradPingPong.c
BradPingPong: BradPingPong.o start.o
	$(LD) $(LDFLAGS) start.o BradPingPong.o -o BradPingPong.coff
	../bin/coff2noff BradPingPong.coff BradPingPong
 
BradPingPong2.o: BradPingPong2.c 
	$(CC) $(CFLAGS) -c BradPingPong2.c
BradPingPong2: BradPingPong2.o start.o
	$(LD) $(LDFLAGS) start.o BradPingPong2.o -o BradPingPong2.coff
	../bin/coff2noff BradPingPong2.coff BradPingPong2
 
BradFork.o: BradFork.c 
	$(CC) $(CFLAGS) -c BradFork.c
BradFork: BradFork.o start.o
	$(LD) $(LDFLAGS) start.o BradFork.o -o BradFork.coff
	../bin/coff2noff BradFork.coff BradFork
 
BradFileTest.o: BradFileTest.c 
	$(CC) $(CFLAGS) -c BradFileTest.c
BradFileTest: BradFileTest.o start.o
	$(LD) $(LDFLAGS) start.o BradFileTest.o -o BradFileTest.coff
	../bin/coff2noff BradFileTest.coff BradFileTest
 
BradTest.o: BradTest.c 
	$(CC) $(CFLAGS) -c BradTest.c
BradTest: BradTest.o start.o
	$(LD) $(LDFLAGS) start.o BradTest.o -o BradTest.coff
	../bin/coff2noff BradTest.coff BradTest
 
SimpleProgram.o: SimpleProgram.c 
	$(CC) $(CFLAGS) -c SimpleProgram.c
SimpleProgram: SimpleProgram.o start.o
	$(LD) $(LDFLAGS) start.o SimpleProgram.o -o SimpleProgram.coff
	../bin/coff2noff SimpleProgram.coff SimpleProgram

dejarArchivoAbierto.o: dejarArchivoAbierto.c
	$(CC) $(CFLAGS) -c dejarArchivoAbierto.c

dejarArchivoAbierto:	dejarArchivoAbierto.o start.o
	$(LD) $(LDFLAGS) start.o dejarArchivoAbierto.o -o dejarArchivoAbierto.coff
	../bin/coff2noff dejarArchivoAbierto.coff dejarArchivoAbierto


todos.o: todos.c
	$(CC) $(CFLAGS) -c todos.c
todos:	todos.o start.o
	$(LD) $(LDFLAGS) start.o todos.o -o todos.coff
	../bin/coff2noff todos.coff todos

ejecutarA.o: ejecutarA.c
	$(CC) $(CFLAGS) -c ejecutarA.c

ejecutarA: ejecutarA.o start.o
	$(LD) $(LDFLAGS) start.o ejecutarA.o -o ejecutarA.coff
	../bin/coff2noff ejecutarA.coff ejecutarA

ejecutarB.o: ejecutarB.c
	$(CC) $(CFLAGS) -c ejecutarB.c

ejecutarB: ejecutarB.o start.o
	$(LD) $(LDFLAGS) start.o ejecutarB.o -o ejecutarB.coff
	../bin/coff2noff ejecutarB.coff ejecutarB

abrir.o: abrir.c
	$(CC) $(CFLAGS) -c abrir.c

abrir: abrir.o start.o
	$(LD) $(LDFLAGS) start.o abrir.o -o abrir.coff
	../bin/coff2noff abrir.coff abrir

todo.o: todo.c
	$(CC) $(CFLAGS) -c todo.c
todo:  todo.o start.o
	$(LD) $(LDFLAGS) start.o todo.o -o todo.coff
	../bin/coff2noff todo.coff todo

fork.o: fork.c
	$(CC) $(CFLAGS) -c fork.c
fork:	fork.o start.o
	$(LD) $(LDFLAGS) start.o fork.o -o fork.coff
	../bin/coff2noff fork.coff fork

fork2.o: fork2.c
	 $(CC) $(CFLAGS) -c fork2.c  
fork2:   fork2.o start.o
	$(LD) $(LDFLAGS) start.o fork2.o -o fork2.coff
	../bin/coff2noff fork2.coff fork2


Halt2.o:	Halt2.c
	$(CC) $(CFLAGS) -c Halt2.c
Halt2:	Halt2.o start.o
	$(LD) $(LDFLAGS) start.o Halt2.o -o Halt2.coff
	../bin/coff2noff Halt2.coff Halt2

shell.o: shell.c
	$(CC) $(CFLAGS) -c shell.c
shell: shell.o start.o
	$(LD) $(LDFLAGS) start.o shell.o -o shell.coff
	../bin/coff2noff shell.coff shell

pruebita.o: pruebita.c
	$(CC) $(CFLAGS) -c pruebita.c
pruebita: pruebita.o start.o
	$(LD) $(LDFLAGS) start.o pruebita.o -o pruebita.coff
	 ../bin/coff2noff pruebita.coff pruebita


sort.o: sort.c
	$(CC) $(CFLAGS) -c sort.c
sort: sort.o start.o
	$(LD) $(LDFLAGS) start.o sort.o -o sort.coff
	../bin/coff2noff sort.coff sort

matmult.o: matmult.c
	$(CC) $(CFLAGS) -c matmult.c
matmult: matmult.o start.o
	$(LD) $(LDFLAGS) start.o matmult.o -o matmult.coff
	../bin/coff2noff matmult.coff matmult

abrir2.o: abrir2.c
	$(CC) $(CFLAGS) -c abrir2.c
abrir2: abrir2.o start.o
	$(LD) $(LDFLAGS) start.o abrir2.o -o abrir2.coff
	../bin/coff2noff abrir2.coff abrir2

blos5.o: blos5.c
	$(CC) $(CFLAGS) -c blos5.c
blos5: blos5.o start.o
	$(LD) $(LDFLAGS) start.o blos5.o -o blos5.coff
	../bin/coff2noff blos5.coff blos5

sem.o: sem.c
	$(CC) $(CFLAGS) -c sem.c
sem: sem.o start.o
	$(LD) $(LDFLAGS) start.o sem.o -o sem.coff
	../bin/coff2noff sem.coff sem

h1.o: h1.c
	$(CC) $(CFLAGS) -c h1.c
h1: h1.o start.o
	$(LD) $(LDFLAGS) start.o h1.o -o h1.coff
	../bin/coff2noff h1.coff h1

open.o: open.c
	$(CC) $(CFLAGS) -c open.c
open: open.o start.o
	$(LD) $(LDFLAGS) start.o open.o -o open.coff
	../bin/coff2noff open.coff open

JQATest.o: JQATest.c
	 $(CC) $(CFLAGS) -c JQATest.c
JQATest: JQATest.o start.o
	$(LD) $(LDFLAGS) start.o JQATest.o -o JQATest.coff
	../bin/coff2noff JQATest.coff JQATest

fork4.o: fork4.c
	$(CC) $(CFLAGS) -c fork4.c

fork4:	fork4.o start.o
	$(LD) $(LDFLAGS) start.o fork4.o -o fork4.coff
	../bin/coff2noff fork4.coff fork4

create.o: create.c
	$(CC) $(CFLAGS) -c create.c
        
create:	create.o start.o
	$(LD) $(LDFLAGS) start.o create.o -o create.coff
	../bin/coff2noff create.coff create


create1.o: create1.c
	$(CC) $(CFLAGS) -c create1.c

create1: create1.o start.o
	$(LD) $(LDFLAGS) start.o create1.o -o create1.coff
	../bin/coff2noff create1.coff create1

crear.o: crear.c
	$(CC) $(CFLAGS) -c crear.c
        
crear:	crear.o start.o
	$(LD) $(LDFLAGS) start.o crear.o -o crear.coff
	../bin/coff2noff crear.coff crear

nuevo.o: nuevo.c
	$(CC) $(CFLAGS) -c nuevo.c
        
nuevo:	nuevo.o start.o
	$(LD) $(LDFLAGS) start.o nuevo.o -o nuevo.coff
	../bin/coff2noff nuevo.coff nuevo

crear1.o: crear1.c
	$(CC) $(CFLAGS) -c crear1.c
crear1:	crear1.o start.o
	$(LD) $(LDFLAGS) start.o crear1.o -o crear1.coff
	../bin/coff2noff crear1.coff crear1

micrear.o: micrear.c
	$(CC) $(CFLAGS) -c micrear.c
        
micrear:	micrear.o start.o
	$(LD) $(LDFLAGS) start.o micrear.o -o micrear.coff
	../bin/coff2noff micrear.coff micrear

lg.o: lg.c
	$(CC) $(CFLAGS) -c lg.c
lg:	lg.o start.o
	$(LD) $(LDFLAGS) start.o lg.o -o lg.coff
	../bin/coff2noff lg.coff lg

execlg.o: execlg.c
	$(CC) $(CFLAGS) -c execlg.c
execlg:	execlg.o start.o
	$(LD) $(LDFLAGS) start.o execlg.o -o execlg.coff
	../bin/coff2noff execlg.coff execlg

exec1lg.o: exec1lg.c
	$(CC) $(CFLAGS) -c exec1lg.c

exec1lg:	exec1lg.o start.o
	$(LD) $(LDFLAGS) start.o exec1lg.o -o exec1lg.coff
	../bin/coff2noff exec1lg.coff exec1lg

HolaMundo.o: HolaMundo.c   
	$(CC) $(CFLAGS) -c HolaMundo.c
        
HolaMundo:	HolaMundo.o start.o
	$(LD) $(LDFLAGS) start.o HolaMundo.o -o HolaMundo.coff
	../bin/coff2noff HolaMundo.coff HolaMundo

forkPrueba.o: forkPrueba.c
	$(CC) $(CFLAGS) -c forkPrueba.c

forkPrueba: forkPrueba.o start.o
	$(LD) $(LDFLAGS) start.o forkPrueba.o -o forkPrueba.coff
	../bin/coff2noff forkPrueba.coff forkPrueba

marito.o: marito.c
	$(CC) $(CFLAGS) -c marito.c
        
marito: marito.o start.o
	$(LD) $(LDFLAGS) start.o marito.o -o marito.coff
	../bin/coff2noff marito.coff marito


jose.o: jose.c
	$(CC) $(CFLAGS) -c jose.c

jose: jose.o start.o  
	$(LD) $(LDFLAGS) start.o jose.o -o jose.coff
	../bin/coff2noff jose.coff jose

read.o: read.c
	$(CC) $(CFLAGS) -c read.c

read: read.o start.o
	$(LD) $(LDFLAGS) start.o read.o -o read.coff
	../bin/coff2noff read.coff read


pruebaSem.o: pruebaSem.c
	$(CC) $(CFLAGS) -c pruebaSem.c

pruebaSem: pruebaSem.o start.o
	$(LD) $(LDFLAGS) start.o pruebaSem.o -o pruebaSem.coff
	../bin/coff2noff pruebaSem.coff pruebaSem

otraPrueba.o: otraPrueba.c
	$(CC) $(CFLAGS) -c otraPrueba.c

otraPrueba: otraPrueba.o start.o
	$(LD) $(LDFLAGS) start.o otraPrueba.o -o otraPrueba.coff
	../bin/coff2noff otraPrueba.coff otraPrueba

pruebaRead.o: pruebaRead.c
	$(CC) $(CFLAGS) -c pruebaRead.c

pruebaRead: pruebaRead.o start.o
	$(LD) $(LDFLAGS) start.o pruebaRead.o -o pruebaRead.coff
	../bin/coff2noff pruebaRead.coff pruebaRead

exec31.o: exec31.c
	$(CC) $(CFLAGS) -c exec31.c

exec31: exec31.o start.o
	$(LD) $(LDFLAGS) start.o exec31.o -o exec31.coff
	../bin/coff2noff exec31.coff exec31

matmult4.o: matmult4.c
	$(CC) $(CFLAGS) -c matmult4.c
matmult4: matmult4.o start.o
	$(LD) $(LDFLAGS) start.o matmult4.o -o matmult4.coff
	../bin/coff2noff matmult4.coff matmult4

matmult2.o: matmult2.c
	$(CC) $(CFLAGS) -c matmult2.c
matmult2: matmult2.o start.o
	$(LD) $(LDFLAGS) start.o matmult2.o -o matmult2.coff
	../bin/coff2noff matmult2.coff matmult2

matmult5.o: matmult5.c
	$(CC) $(CFLAGS) -c matmult5.c
matmult5: matmult5.o start.o
	$(LD) $(LDFLAGS) start.o matmult5.o -o matmult5.coff
	../bin/coff2noff matmult5.coff matmult5

matmult6.o: matmult6.c
	$(CC) $(CFLAGS) -c matmult6.c
matmult6: matmult6.o start.o
	$(LD) $(LDFLAGS) start.o matmult6.o -o matmult6.coff
	../bin/coff2noff matmult6.coff matmult6

matmult7.o: matmult7.c
	$(CC) $(CFLAGS) -c matmult7.c
matmult7: matmult7.o start.o
	$(LD) $(LDFLAGS) start.o matmult7.o -o matmult7.coff
	../bin/coff2noff matmult7.coff matmult7

matmult13.o: matmult13.c
	$(CC) $(CFLAGS) -c matmult13.c
matmult13: matmult13.o start.o
	$(LD) $(LDFLAGS) start.o matmult13.o -o matmult13.coff
	../bin/coff2noff matmult13.coff matmult13

matmultS.o: matmultS.c
	$(CC) $(CFLAGS) -c matmultS.c
matmultS: matmultS.o start.o
	$(LD) $(LDFLAGS) start.o matmultS.o -o matmultS.coff
	../bin/coff2noff matmultS.coff matmultS

matmult8.o: matmult8.c
	$(CC) $(CFLAGS) -c matmult8.c
matmult8: matmult8.o start.o
	$(LD) $(LDFLAGS) start.o matmult8.o -o matmult8.coff
	../bin/coff2noff matmult8.coff matmult8

matmult10.o: matmult10.c
	$(CC) $(CFLAGS) -c matmult10.c
matmult10: matmult10.o start.o
	$(LD) $(LDFLAGS) start.o matmult10.o -o matmult10.coff
	../bin/coff2noff matmult10.coff matmult10


mamut.o: mamut.c
	$(CC) $(CFLAGS) -c mamut.c
mamut: mamut.o start.o
	$(LD) $(LDFLAGS) start.o mamut.o -o mamut.coff
	../bin/coff2noff mamut.coff mamut

semaforito.o: semaforito.c
	$(CC) $(CFLAGS) -c semaforito.c
semaforito: semaforito.o start.o 
	$(LD) $(LDFLAGS) start.o semaforito.o -o semaforito.coff
	../bin/coff2noff semaforito.coff semaforito

copy2.o: copy2.c
	$(CC) $(CFLAGS) -c copy2.c
copy2: copy2.o start.o 
	$(LD) $(LDFLAGS) start.o copy2.o -o copy2.coff
	../bin/coff2noff copy2.coff copy2

arg.o: arg.c
	$(CC) $(CFLAGS) -c arg.c
arg: arg.o start.o 
	$(LD) $(LDFLAGS) start.o arg.o -o arg.coff
	../bin/coff2noff arg.coff arg


join.o: join.c
	$(CC) $(CFLAGS) -c join.c
join: join.o start.o
	$(LD) $(LDFLAGS) start.o join.o -o join.coff
	../bin/coff2noff join.coff join

pruebaComp.o: pruebaComp.c
	$(CC) $(CFLAGS) -c pruebaComp.c
pruebaComp: pruebaComp.o start.o
	$(LD) $(LDFLAGS) start.o pruebaComp.o -o pruebaComp.coff
	../bin/coff2noff pruebaComp.coff pruebaComp

waaaazaaaa.o: waaaazaaaa.c
	$(CC) $(CFLAGS) -c waaaazaaaa.c
waaaazaaaa: waaaazaaaa.o start.o
	$(LD) $(LDFLAGS) start.o waaaazaaaa.o -o waaaazaaaa.coff
	../bin/coff2noff waaaazaaaa.coff waaaazaaaa

forkX.o: forkX.c
	$(CC) $(CFLAGS) -c forkX.c
forkX: forkX.o start.o
	$(LD) $(LDFLAGS) start.o forkX.o -o forkX.coff
	../bin/coff2noff forkX.coff forkX

writeP.o: writeP.c
	$(CC) $(CFLAGS) -c writeP.c
writeP: writeP.o start.o
	$(LD) $(LDFLAGS) start.o writeP.o -o writeP.coff
	../bin/coff2noff writeP.coff writeP

copy.o: copy.c
	$(CC) $(CFLAGS) -c copy.c
copy: copy.o start.o
	$(LD) $(LDFLAGS) start.o copy.o -o copy.coff
	../bin/coff2noff copy.coff copy