# PCN System
# Please see the DISCLAIMER file in the top level directory of the
# distribution regarding the provisions under which this software
# is distributed.


In this directory (configs) are configurations for a variety of
different machines.  Each config directory consists of the following
	config: a bourne shell script that sets a bunch of variables
which are read in by the various scripts
	cmain.c: a file containing a main() procedure when linking
with the C compiler
	fmain.c: a file containing a main() procedure when linking
with the Fortran compiler.

For example, configs/next040.cf is for the NeXT computer -- it has all
the machine specific information needed to make the complete PCN
system on the NeXT computer.  When './configure next040' is run from
the top level PCN source directory, a shadow tree with the proper
Makefile configurations is built for the NeXT.

What follows is a descriptions of all the bourne shell variables that
need to be set in these configuration files.

Many of the variables are paths to programs such as mkdir, cp, mv,
etc.  You should use full paths here so that the installation is not
dependent on the users path.


This is the base directory into which PCN will be installed.
Directories will be created under this one during installation.  This
directory should exist and be writable before the installation is


This is the set of contrib programs (programs where are not part of
the basic installation, and reside in the contrib directory) that will
be built and installed by the makefiles.

Normally for a workstation that supports X windows, this should be set
to "gauge", in order to have the gauge X windows profile analysis tool
built and installed.  On non-workstations (for example, the ipsc860),
or on workstations that do not support X, this should be set to "".

If you want multiple contrib programs built and installed, just set
this variable to be a space separated list of the programs.  For
example, "gauge program2".

Note: Gauge assumes X windows version 11 release 5 (X11R5).  If your
machine does not support this, it is highly doubtful that gauge will
build and run properly.


This is the architecture type. The emulator uses this for #ifdef's, to
customize code for a specific machine.  That is, a '-D$(G_ARCH)' is
automatically added to the compile lines when building the emulator.

The following are the supported values for G_ARCH:

	dec5000		- DECstations 5000 (or 3100)
	delta		- Intel Touchstone Delta
	hp9k8		- HP 9000 series 800 running HP/UX
	hp9k7		- HP 9000 series 700 running HP/UX
	hp9k3		- HP 9000 series 300 running HP/UX
	ipsc860		- Intel iPSC/860
	iris		- Silicon Graphics Iris
	next040		- NeXT
	rs6000		- IBM RS/6000
	s2010		- Symult 2010
	sun3		- Sun 3
	sun4		- Sun 4
	symmetry	- Sequent Symmetry running Dynix


If you set G_XCOMP_TARGET="no", then this config is for a complete

If you set G_XCOMP_TARGET="yes", then this config is for a cross
compilation target, and is meant to be installed on top of some other
complete installation.


These will be used during installation to set the file modes for
executable files, regular (non-executable) files, and directories.
They are used as arguments to chmod.  For more information on file
modes, see the man page for chmod.


The C compiler to use to build the various parts of the runtime
system, when linking, etc.


The standard optimized C compiler flags to use (i.e. -g, -O, -I<dir>)
when compiling the various parts of the runtime system, and when
linking a non-PDB version of the system with pcnlink.


The standard debugging C compiler flags to use (i.e. -g, -O, -I<dir>)
when compiling the various parts of the runtime system, and when
linking a PDB version of the system with pcnlink.


Any extra libraries that need to be linked in during links in pcnlink.


The Fortran compiler to used for linking when you use the -fortran
flag on pcncomp.


The standard optimized Fortran compiler flags to use (i.e. -g, -O,
-I<dir>) during non-PDB Fortran links (with 'pcnlink -fortran')


The standard debugging Fortran compiler flags to use (i.e. -g, -O,
-I<dir>) during PDB Fortran links (with 'pcnlink -fortran')


Any extra libraries that need to be linked in during fortran builds
('pcnlink -fortran').

Note: When doing a fortran build, the G_FLIBS are used in place of the
G_CLIBS, not in addition to the G_CLIBS.


The object file suffix for this machine.  Normally this is just "o"
(meaning object files have a .o suffix).  However, the Cosmic
Environment uses different object file suffixes.  For example, the
s2010 G_OFILE should be "s2010_o".


Flags that should be used during the final link stage of the


Flags to use when compiling the PCN system source.

Options for G_DEFS:
  -DPCN_BIT_FIELDS_R_TO_L: Bit fields are placed in word from right
				to left.  Use of this flag depends on
				how the compiler packs bit fields into
				structures.  When creating a new config
				file and you're not sure which way it
				packs bit fields, try it both ways --
				only one way will work...
  -DPCN_ALIGN_DOUBLES	: Add this flag to double word align double
			  precision floating point numbers.  This is
			  required on some machines like the iPSC/860.
  -DPCN_USE_BSD_TIME	: This tells Gauge and Upshot to use the BSD
			  time primitives (gettimeofday() from <sys/time.h>).
			  If this is not defined, then the code must be
			  modified for the the given architecture in:
  -DPCN_SYSV		: System V machine
  -DPCN_SYSV3_2		: System V version 3_2 machine
  -DPCN_INCLUDE_STRINGS	: Code can #include <strings.h>
  -DPCN_DONT_INCLUDE_STRING    : Code should NOT #include <string.h>
  -DPCN_DONT_INCLUDE_SYS_PARAM : Code should NOT #include <sys/param.h>
  -DPCN_DONT_INCLUDE_ANSI      : Code should NOT include the ANSI header files:
  -DPCN_USE_BZERO	: use bzero() instead of memset() to zero out memory
  -DPCN_MEMCPY_TO_BCOPY	: define memcpy() to use bcopy()
  -DPCN_NO_MEMMOVE	: no memmove() procedure exists, so define one
				that uses memcpy().
  -DPCN_GETWD_TO_GETCWD	: define getwd() to use getcwd()
  -DPCN_STRCHR_TO_INDEX	: define strchr() to use index()
  -DPCN_RANDOM_TO_RAND	: define random() to use rand()
  -DPCN_REMOVE_TO_UNLINK: define remove() to use unlink()
  -DPCN_RENAME_TO_LINK  : define rename() to use link() and unlink()
  -DPCN_FPRINTF_HACK    : hack stdio:fprintf() to work around fprintf()'s
				that do not return the number of 
				characters printed.
  -DDEBUG=<n>	: Compile debugging code into the emulator, and
		  set the default global debug level to <n>.
		  This is automatically set when compiling "pdb"
		  and "debug" VERSIONS.

Note: As long as pcn is compiled with -DDEBUG=0, then the debug levels
can be set a run time using command line arguments.  However, the PDB
version of the runtime system will have this set already, so you
generally do not need to set this flag.


This should be set to either "yes" or "no".  If "yes", then the linker
(pcnlink) will strip the trailing underscore off the name of any
foreign procedures that PCN code is trying to call.

Why would one do this?  On most machines the Fortran compiler
automatically inserts a trailing underscore onto the ends of all
procedure names.  Therefore, in order to call those procedures from C
or PCN, you need to call that procedure with the trailing underscore.
So in PCN, the convention is that when calling a Fortran procedure
that you always add the trailing underscore to the name of the
procedure in the call.  However, on some machines (i.e., IBM RS/6000
and HP) the Fortran compiler does not add this trailing underscore.
By setting G_STRIP_TRAILING_UNDERSCORE="yes" in the configuration for
these machines, then all of this PCN that calls Fortran procedures
will trailing underscores will correctly, since those underscores will
get stripped by pcnlink before trying to resolve the call against the
Fortran code.


The machine dependent module to use.  The module name should not
include a suffix.  Normally you would use G_MD_MODULE="md_unix".
However, some systems such as the Intel iPSC/860 use a different
machine dependent module (i.e. G_MD_MODULE="md_nx"). 


The send/receive module to use. (no suffix)

In a uniprocessing system, use G_SR_MODULE="sr_null".  Other options for
this variable are:
	sr_null		# Uniprocessing
	sr_bsdipc	# BSD Unix IPC (TCP sockets)
	sr_machipc	# Mach IPC -- for the NeXT computer in particular
	sr_ce		# Cosmic Environment
	sr_seq		# Sequent Symmetry, using shared memory for
				message passing
	sr_nx		# The Intel nX system -- for the iPSC/860 and Delta


These are X Windows configuration options.  Some programs (i.e., gauge)
are X Windows based programs.  So to build them, these variables will
need to be set.

They have the following meanings:
	X_BIN_DIR : X bin directory (i.e., /usr/local/X11/bin)
	X_INC_DIR : X include directory (i.e., /usr/local/X11/include)
	X_LIB_DIR : X lib directory (i.e., /usr/local/X11/lib)
	X_CC      : C compiler to use when compiling X programs
	X_CFLAGS  : Arguments that should be added to the C compile
			line when compiling X programs.
	X_LDFLAGS : Arguments that should be added to the link
			line when linking X programs


The name of the lex program.  This is normally G_LEX="/usr/bin/lex".
Note: the use of flex is not yet supported.


Any flags to pass to lex.


The name of the yacc program.  This is normally G_YACC="/usr/bin/yacc".
Note: the use of flex is not yet supported.


Any flags to pass to lex.


The name of the cpp program -- the C preprocessor.  This should be
specified as a complete path.  Normally this is just set to "/lib/cpp".


The name of the make program.  It is used during recursive makes.
Normally this will be G_MAKE="/bin/make".  However, if you use a
different make you can change this variable.  For example, on the BBN
Butterfly, if this is set to G_MAKE="pmake", then it will do compiles
in parallel.


The archiver program.  This is normally "/bin/ar".  But this may have
to be something different for some system -- particularly those that
are cross compiled.  For example, the ipsc860 uses "/somepath/ar860".


The ranlib program.  On a System V machine that does not have ranlib,
set this to "/bin/true".


The complete path to Perl.  For example, G_PERL="/usr/local/bin/perl".

Perl is NOT required for the installation of PCN.  However, some of
the non-essential PCN utility programs, such as host-control, require
Perl.  In other words, you can run PCN without Perl.  However, some of
the utility programs which might make PCN easier to use in certain
situations cannot be used without Perl.

Perl is a free, publicly available programming language.  It can be
obtained via anonymous ftp from the standard Unix sources archive
sites, such as prep.ai.mit.edu.

If perl is not installed on your machines and you do not wish to (or
cannot) install it on your machines, then you can ignore this
variable. (i.e., Set it to anything you want, including G_PERL="".)
The only thing that will not work in this case are non-essential
utilities such as host-control.


The cp program.  Normally G_CP="/bin/cp".


The mv program.  Normally G_MV="/bin/mv".


The echo program.  Normally G_ECHO="/bin/echo".


The mkdir program.  Normally G_MKDIR="/bin/mkdir".


The chmod program.  Normally G_CHMOD="/bin/chmod".


The sed program.  Normally G_SED="/bin/sed".


The touch program.  Normally G_TOUCH="/bin/touch".


The basename program.  Normally G_BASENAME="/bin/basename".


The expr program.  Normally G_EXPR="/bin/expr".


The cat program.  Normally G_CAT="/bin/cat".


The ln program.  Normally G_LN="/bin/ln".


The shell that will be used by make.  Normally G_SHELL="/bin/sh".


This variable is added to the make lines as follows:

executable:	$(PARALLEL) file1.c file2.c

On some machines, such as the Sequent Symmetry, this will cause
file1.c and file2.c to be made in parallel.

On the Sequent Symmetry, if PARALLEL="&", then compiles will be done
in parallel wherever possible.

On the BBN Butterfly, the presence of the $(PARALLEL) will cause the
make to be done in parallel, assuming you use G_MAKE="pmake".  In this
case, PARALLEL need not be set to anything.

These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.