#!/usr/ccs/bin/make -f
######################################################################
# Projekt:	Parallaxis-III
# Filename:	p3versions
# Autor:	Hartmut Keller
# Datum:	Montag, 20. November 1995, 15:57:26
#
# Beschreibung
# ------------
# Ein Makefile zur automatischen Generierung von Parallaxis-III
# Versionen. Idee: Im Verzeichnis p3solaris wird die aktuelle
# CVS-Version ausgepackt, alle anderen Verzeichnisse haben nur Links
# auf diese Files.
# Wird nun eine andere Version als Solaris compiliert, wird trotzdem die
# Solaris-Version benutzt um zuerst mal die Files durch Cocktail zu
# schicken. 
#
# Benutzung:
# Entweder 
#             make -f p3versions <targets>
# oder
#             p3versions <targets>
# Als <targets> gehen dabei: SGI, SUNOS, SOLARIS, LINUX, AIX, ULTRIX,
#                            HPUX, source, all(=default=alle obigen)
#
# ACHTUNG: Dieses File benoetigt einen Solaris-Rechner zur Ausfuehrung,
# z.B. matisse oder modnrian. Ausserdem muss auf diesem Rechner das
# Compilerbau-Toolkit Cocktail installiert sein (rex, ell, ast, ag,
# cg, puma)
#
# Folgende Rechner werden zur Compilierung benutzt:
#
#    Target     Rechner
#   --------------------------------
#    SUNOS:    	odysseus
#    SOLARIS:  	lokaler Rechner
#    SGI:	raffael
#    LINUX:	robopc2
#    AIX:       oedipus
#    ULTRIX:	priamos
#    HPUX:	duerer
######################################################################


#----------------------------------------------------------------------
# Einstellungen fuer SUN (SunOS 4.1.x):

# Rechnername (Aufruf ueber rsh): 
M_SUNOS = odysseus

# Name des Unterverzeichnisses und des tar-Files:
P3SUNOS= p3sunos

# Pfad, in dem compiliert wird:
P_SUNOS = /usr/local/bv/data/P3_SOURCES/$(P3SUNOS)

# Files der Binary-Version (inklusive Pfad):
BINSUNOS= $(P3SUNOS)/p3 $(P3SUNOS)/p3c $(P3SUNOS)/p3.1 $(P3SUNOS)/libp3.a \
          $(P3SUNOS)/SYSTEM_C.h $(P3SUNOS)/README.sunos.beta $(P3SUNOS)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer SUN (Solaris 2.x):

# Rechnername (Aufruf direkt, kein rsh):
M_SOLARIS = matisse

# Name des Unterverzeichnisses und des tar-Files:
P3SOLARIS= p3solaris

# Pfad, in dem compiliert wird:
P_SOLARIS= /usr/local/bv/data/P3_SOURCES/$(P3SOLARIS)

# Files der Binary-Version (inklusive Pfad):
BINSOLARIS= $(P3SOLARIS)/p3 $(P3SOLARIS)/p3c $(P3SOLARIS)/p3.1 \
            $(P3SOLARIS)/libp3.a $(P3SOLARIS)/SYSTEM_C.h \
            $(P3SOLARIS)/README.solaris.beta $(P3SOLARIS)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer Silicon Graphics (IRIX):

# Rechnername (Aufruf ueber rsh):
M_SGI = raffael

# Name des Unterverzeichnisses und des tar-Files:
P3SGI= p3sgi

# Pfad, in dem compiliert wird:
P_SGI= /usr/local/bv/data/P3_SOURCES/$(P3SGI)

# Files der Binary-Version (inklusive Pfad):
BINSGI= $(P3SGI)/p3 $(P3SGI)/p3c $(P3SGI)/p3.1 $(P3SGI)/libp3.a \
        $(P3SGI)/SYSTEM_C.h $(P3SGI)/README.sgi.beta $(P3SGI)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer IBM RS6000 (AIX):

# Rechnername (Aufruf ueber rsh):
M_AIX = oedipus

# Name des Unterverzeichnisses und des tar-Files:
P3AIX= p3rs6000

# Pfad, in dem compiliert wird:
P_AIX= /usr/local/bv/data/P3_SOURCES/$(P3AIX)

# Files der Binary-Version (inklusive Pfad):
BINAIX= $(P3AIX)/p3 $(P3AIX)/p3c $(P3AIX)/p3.1 $(P3AIX)/libp3.a \
        $(P3AIX)/SYSTEM_C.h $(P3AIX)/README.rs6000.beta $(P3AIX)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer PC (Linux):

# Rechnername (Aufruf ueber rsh):
M_LINUX = robopc2

# Name des Unterverzeichnisses und des tar-Files:
P3LINUX= p3linux

# Pfad, in dem compiliert wird:
P_LINUX= /usr/local/bv/data/P3_SOURCES/$(P3LINUX)

# Files der Binary-Version (inklusive Pfad):
BINLINUX= $(P3LINUX)/p3 $(P3LINUX)/p3c $(P3LINUX)/p3.1 $(P3LINUX)/libp3.a \
          $(P3LINUX)/SYSTEM_C.h $(P3LINUX)/README.linux.beta \
          $(P3LINUX)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer DEC (Ultrix):

# Rechnername (Aufruf ueber rsh): 
M_ULTRIX = priamos

# Name des Unterverzeichnisses und des tar-Files:
P3ULTRIX= p3ultrix

# Pfad, in dem compiliert wird:
P_ULTRIX = $(PWD)/$(P3ULTRIX)

# Files der Binary-Version (inklusive Pfad):
BINULTRIX= $(P3ULTRIX)/p3 $(P3ULTRIX)/p3c $(P3ULTRIX)/p3.1 $(P3ULTRIX)/libp3.a \
           $(P3ULTRIX)/SYSTEM_C.h $(P3ULTRIX)/README.ultrix.beta \
           $(P3ULTRIX)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer DEC (Alpha):

# Rechnername (Aufruf ueber rsh): 
M_ALPHA = chaos

# Name des Unterverzeichnisses und des tar-Files:
P3ALPHA= p3alpha

# Pfad, in dem compiliert wird:
P_ALPHA = $(PWD)/$(P3ALPHA)

# Files der Binary-Version (inklusive Pfad):
BINALPHA= $(P3ALPHA)/p3 $(P3ALPHA)/p3c $(P3ALPHA)/p3.1 $(P3ALPHA)/libp3.a \
           $(P3ALPHA)/SYSTEM_C.h $(P3ALPHA)/README.alpha.beta \
           $(P3ALPHA)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer HP9000/730 (HP-UX):

# Rechnername (Aufruf ueber rsh):
M_HPUX = duerer

# Name des Unterverzeichnisses und des tar-Files:
P3HPUX= p3hp9000s700

# Pfad, in dem compiliert wird:
P_HPUX= /usr/local/bv/data/P3_SOURCES/$(P3HPUX)

# Files der Binary-Version (inklusive Pfad):
BINHPUX=    $(P3HPUX)/p3 $(P3HPUX)/p3c $(P3HPUX)/p3.1 \
            $(P3HPUX)/libp3.a $(P3HPUX)/SYSTEM_C.h \
            $(P3HPUX)/README.hpux.beta $(P3HPUX)/KnownBugs


#----------------------------------------------------------------------
# Einstellungen fuer die Source-Distribution:

# Name des Unterverzeichnisses und des tar-Files:
P3SOURCE= p3source


#======================================================================

# Hier jetzt die Regeln fuer die Targets:

# Default-Target:
all: solaris sunos sgi aix linux ultrix hpux source

#----------------------------------------------------------------------
# Alle Files, die von Cocktail generiert werden:

CREATED = Code.c Code.h Eval.c Eval.h Parser.c Parser.h \
          Scanner.c Scanner.h Symbols.c Symbols.h \
          Tree.TS Tree.c Tree.h \
          yyCode.w yySymbols.w yyTree.w 

# Files generieren, die von Cocktail erzeugt werden:
# 1. Neueste Version der Source-Files aus CVS ins $(P3SOLARIS)-Verzeichnis
#    holen 
# 2. Ueber make die neueste Version dieser Files uebersetzen

cocktail:
	cd $(P3SOLARIS); cvs update; make -f export BV
	cd $(P3SOLARIS); make $(CREATED) 


#----------------------------------------------------------------------
# SunOS-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    Solaris-Verzeichnis)
# 2. SunOS-Version auf SunOS-Rechner compilieren (make SUNOS)
# 3. Archiv packen (tar, gzip)

sunos SUNOS: cocktail
	rsh $(M_SUNOS) \
	  "cd $(P_SUNOS); make SUNOS REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib STDINC=/usr/5include STATIC=-static"
	tar cvhf - $(BINSUNOS) | gzip >$(P3SUNOS).tar.gz


#----------------------------------------------------------------------
# Solaris-Version:
# 1. Neueste Files aus CVS holen (cvs update)
# 2. Solaris-Version auf lokalem Rechner compilieren (make SOLARIS)
# 3. Archiv packen (tar, gzip)

solaris SOLARIS: cocktail
	cd $(P_SOLARIS); make SOLARIS REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib.sun5 ARFLAGS=crs RANLIB=: STATIC=-static
	tar cvhf - $(BINSOLARIS) | gzip >$(P3SOLARIS).tar.gz


#----------------------------------------------------------------------
# SGI-Version (alt):
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    Solaris-Verzeichnis)
# 2. Files an SGI-Rechner schicken (rcp)
# 3. SGI-Version auf SGI-Rechner compilieren (make SGI)
# 4. Erzeugte Files wieder zurueckschicken (rcp)
# 5. Archiv packen (tar, gzip)

#sgi SGI: cocktail
#	rcp -p $(P3SGI)/* $(M_SGI):$(P_SGI)
#	rsh $(M_SGI) "cd $(P_SGI); make -f Makefile.C REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib ARFLAGS=crs RANLIB=:; rcp -p p3c p3 p3.1 libp3.a $(HOST):$(PWD)/$(P3SGI)"
#	tar cvhf - $(BINSGI) | gzip >$(P3SGI).tar.gz

# SGI-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    SunOS-Verzeichnis)
# 2. SGI-Version auf SGI-Rechner compilieren (make SGI)
# 3. Archiv packen (tar, gzip)

sgi SGI: cocktail
	rsh $(M_SGI) "cd $(P_SGI); make SGI REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib.iris4d ARFLAGS=crs RANLIB=: STATIC=-static"
	tar cvhf - $(BINSGI) | gzip >$(P3SGI).tar.gz


#----------------------------------------------------------------------
# RS6000-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    Solaris-Verzeichnis)
# 2. Files an SGI-Rechner schicken (rcp)
# 3. RS6000-Version auf IBM-Rechner compilieren (make AIX)
# 4. Erzeugte Files wieder zurueckschicken (rcp)
# 5. Archiv packen (tar, gzip)

aix AIX: cocktail
	rsh $(M_AIX) "cd $(P_AIX); make AIX REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib.rs6000 ARFLAGS=crs STATIC=-static"
	tar cvhf - $(BINAIX) | gzip >$(P3AIX).tar.gz


#----------------------------------------------------------------------
# LINUX-Version (alt):
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    SunOS-Verzeichnis)
# 2. Files an LINUX-Rechner schicken (rcp)
# 3. LINUX-Version auf LINUX-Rechner compilieren (make LINUX)
# 4. Erzeugte Files wieder zurueckschicken (rcp)
# 5. Archiv packen (tar, gzip)

#linux LINUX: cocktail
#	rcp -p $(P3LINUX)/* $(M_LINUX):$(P_LINUX)
#	rsh $(M_LINUX) "cd $(P_LINUX); make -f Makefile.C REUSEINC=/usr/include REUSELIB=/usr/lib ARFLAGS=crs RANLIB=:; rcp -p p3c p3 p3.1 libp3.a $(HOST):$(PWD)/$(P3LINUX)"
#	tar cvhf - $(BINLINUX) | gzip >$(P3LINUX).tar.gz

# LINUX-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    Solaris-Verzeichnis)
# 2. LINUX-Version auf LINUX-Rechner compilieren (make LINUX)
# 3. Archiv packen (tar, gzip)

linux LINUX: cocktail
	rsh $(M_LINUX) "cd $(P_LINUX); make LINUX REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib.i386-linux ARFLAGS=crs RANLIB=: STATIC=-static"
	tar cvhf - $(BINLINUX) | gzip >$(P3LINUX).tar.gz

tarlinux:
	tar cvhf - $(BINLINUX) | gzip >$(P3LINUX).tar.gz

#----------------------------------------------------------------------
# Ultrix-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    Solaris-Verzeichnis)
# 2. Ultrix-Version auf Decstation-Rechner compilieren (make ULTRIX)
# 3. Archiv packen (tar, gzip)

ultrix ULTRIX: cocktail
	rsh $(M_ULTRIX) \
	  "cd $(P_ULTRIX); make ULTRIX REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib.decstation STATIC=-static"
	tar cvhf - $(BINULTRIX) | gzip >$(P3ULTRIX).tar.gz


#----------------------------------------------------------------------
# Alpha-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    Solaris-Verzeichnis)
# 2. Ultrix-Version auf Decstation-Rechner compilieren (make ULTRIX)
# 3. Archiv packen (tar, gzip)

alpha ALPHA: cocktail
	rsh $(M_ALPHA) \
	  "cd $(P_ALPHA); make ALPHA REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib.alpha STATIC=-static"
	tar cvhf - $(BINALPHA) | gzip >$(P3ALPHA).tar.gz


#----------------------------------------------------------------------
# HP-UX-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    SunOS-Verzeichnis)
# 2. HPUX-Version auf HP-Rechner compilieren (make HPUX)
# 3. Archiv packen (tar, gzip)

hpux HPUX: cocktail
	rsh $(M_HPUX) \
	  "cd $(P_HPUX); make HPUX REUSEINC=/usr/local/bv/include/reuse REUSELIB=/usr/local/bv/lib.hp ARFLAGS=crs RANLIB=: STATIC=-static"
	tar cvhf - $(BINHPUX) | gzip >$(P3HPUX).tar.gz


#----------------------------------------------------------------------
# Source-Version:
# 1. Neueste Files aus CVS holen und mit Cocktail uebersetzen (im
#    SunOS-Verzeichnis)
# 2. Archiv packen (tar, gzip)

source src SOURCE SRC: cocktail
	tar cvhf - $(P3SOURCE)/* | gzip >$(P3SOURCE).tar.gz


#----------------------------------------------------------------------
# Clean the subdirectories to create the new version from scratch

NEW new:
	cd $(P3SUNOS); make Clean
	cd $(P3SOLARIS); make CLEAN
	cd $(P3SGI); make Clean
	cd $(P3AIX); make Clean
	cd $(P3LINUX); make Clean

#end of p3versions



