home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / prgramer / adaptor / src / makef.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-04  |  46.4 KB  |  1,569 lines
  1. /**************************************************************************
  2. *                                                                         *
  3. *  Author      : Dr. Thomas Brandes, GMD, I1.HR                           *
  4. *  Date        : Feb 92                                                   *
  5. *  Last Update : Apr 93                                                   *
  6. *                                                                         *
  7. *  Module      : makefiles                                                *
  8. *                                                                         *
  9. *  Function    : generate makefile for the different machines             *
  10. *                                                                         *
  11. *  Export :                                                               *
  12. *                                                                         *
  13. *   - gen_makefile                                                        *
  14. *                                                                         *
  15. **************************************************************************/
  16.  
  17. # include <stdio.h>
  18. # ifdef alliant
  19. # include <fcntl.h>             /* for testing file access */
  20. # else
  21. # include <unistd.h>             /* for testing file access */
  22. # endif
  23. # include "Idents.h"
  24. # include "StringMe.h"
  25. # include "Tree.h"
  26.  
  27. /*******************************************************************
  28. *                                                                  *
  29. *  More general functions to generate a correct Makefile           *
  30. *                                                                  *
  31. *******************************************************************/
  32.  
  33.      /***********************************************
  34.      *                                              *
  35.      *  generate the header                         *
  36.      *                                              *
  37.      *   BEWARE : ...                               *
  38.      *                                              *
  39.      *   PHOME = ...                                *
  40.      *   DALIB = ...                                *
  41.      *                                              *
  42.      ***********************************************/
  43.  
  44. void gen_header (mf, lib)
  45. FILE *mf;
  46. char lib[];
  47.  
  48.  
  49. {
  50.   char *r;
  51.  
  52.   fprintf (mf,"#\n");
  53.   fprintf (mf,
  54.     "# BEWARE: this Makefile was automatically generated by Adaptor\n");
  55.   fprintf (mf,
  56.     "#         Adaptor will not overwrite any changes you make here,\n");
  57.   fprintf (mf,
  58.     "#         however this Makefile may become out of date\n");
  59.  
  60.   fprintf (mf,"# Target machine is %s (%s)\n",machine_items[target_machine],
  61.            model_items[target_model]);
  62.  
  63.   fprintf (mf,"#\n");
  64. /*
  65.   fprintf (mf,"# PHOME is Home Directory of Adaptor \n");
  66. */
  67.   fprintf (mf,"# DALIB is directory for ADAPTOR libraries and object files\n");
  68.   fprintf (mf,"#\n");
  69. /*
  70.   fprintf (mf,"PHOME =  $(HOME)/adaptor\n", PHOME;
  71. */
  72.   if (!(r = getenv("DALIB")))
  73.      r = "/adaptor/lib";
  74.  
  75.   fprintf (mf,"DALIB = %s\n", r);
  76. /*
  77.   fprintf (mf,"DALIB  = $(PHOME)/dalib/%s\n", lib);
  78. */
  79.   fprintf (mf,"#\n");
  80.   fprintf (mf,"# Standard commands\n");
  81.   fprintf (mf,"ADAPTOR = fadapt\n");
  82.   fprintf (mf,"FSPLIT  = fsplit\n");
  83.   fprintf (mf,"FSTRIP  = fstrip\n");
  84.   fprintf (mf,"#\n");
  85. } /* gen_header */
  86.  
  87.      /***********************************************
  88.      *                                              *
  89.      *  Generating a list of names for              *
  90.      *  all units (host/node) (obj/src)             *
  91.      *                                              *
  92.      ***********************************************/
  93.  
  94. void gen_obj_entries (mf, host, obj)
  95. bool host;
  96. bool obj;
  97. FILE *mf;
  98. { tTree units, unit;
  99.   tIdent name;
  100.   char c, str[50];
  101.   int i, len;
  102.   int nnames = 0;
  103.   int pure;        /* pure subprograms not in host */
  104.  
  105.   units = TreeRoot->COMP_UNIT.COMP_ELEMENTS;
  106.  
  107.   /* traversing is done after passing the node adaption */
  108.  
  109.   while (units->Kind != kDECL_EMPTY )
  110.     { unit = units->DECL_LIST.Elem;
  111.       name = unit->DECL_NODE.Name;
  112.       pure = 0;
  113.       if (unit->Kind == kFUNC_DECL)
  114.          pure = unit->FUNC_DECL.IsPure;
  115.       if (unit->Kind == kPROC_DECL)
  116.          pure = unit->PROC_DECL.IsPure;
  117.       GetString (name, str);
  118.       /*  are the names of node program SUBNAME_N, NODEMODULE */
  119.       /* fsplit generates names with lower letters */
  120.       len = strlen (str);
  121.       for (i=0; i < len; i++)
  122.          str[i] = tolower (str[i]);
  123.       if (host)
  124.          { if (strcmp (str, "nodemodule") == 0)
  125.              strcpy (str, "hostmodule");
  126.             else
  127.              str[len-1] = 'h'; /* h */
  128.          }
  129.       if (obj)
  130.          strcat (str, ".o");
  131.        else
  132.          strcat (str, ".f");
  133.       if (++nnames % 6 == 0)
  134.           fprintf(mf," \\\n\t");
  135.       if (!host || !pure)
  136.          fprintf (mf, " %s", str);
  137.       units = units->DECL_LIST.Next;
  138.     }
  139. } /* gen_obj_entries */
  140.  
  141.      /***********************************************
  142.      *                                              *
  143.      *   NSRC = ....                                *
  144.      *   HSRC = ....                                *
  145.      *                                              *
  146.      *   NODE_OBJ = ....                            *
  147.      *   HOST_OBJ = ....                            *
  148.      *   CUBE_OBJ = ....                            *
  149.      *   OBJ1 = ....                                *
  150.      *                                              *
  151.      ***********************************************/
  152.  
  153. void gen_OBJS (mf, split_flag)
  154. FILE *mf;
  155. bool split_flag;
  156.  
  157. { /* Collect all OBJ files
  158.  
  159.      NODE_OBJ = n_unit1.o n_unit2.o ...
  160.      HOST_OBJ = h_unit1.o h_unit2.o ...        */
  161.  
  162.   fprintf (mf,"# Object Codes\n");
  163.   fprintf (mf,"#\n");
  164.  
  165.   if (split_flag)
  166.     { fprintf (mf,"NODE_OBJ ="); gen_obj_entries (mf, false, true);
  167.       fprintf (mf,"\n");
  168.       fprintf (mf,"NSRC ="); gen_obj_entries (mf, false, false);
  169.       fprintf (mf,"\n");
  170.       fprintf (mf,"#\n");
  171.       fprintf (mf,"HOST_OBJ ="); gen_obj_entries (mf, true, true );
  172.       fprintf (mf,"\n");
  173.       fprintf (mf,"HSRC ="); gen_obj_entries (mf, true, false);
  174.       fprintf (mf,"\n");
  175.       fprintf (mf,"#\n");
  176.       fprintf (mf,"CUBE_OBJ = $(NODE_OBJ)\n");
  177.       fprintf (mf,"OBJ1 = $(NODE_OBJ)\n");
  178.       fprintf (mf,"#\n");
  179.     }
  180.   else
  181.     { fprintf (mf,"NODE_OBJ = node.o\n");
  182.       fprintf (mf,"NSRC = node.f\n");
  183.       fprintf (mf,"#\n");
  184.       fprintf (mf,"HOST_OBJ = host.o\n");
  185.       fprintf (mf,"HSRC = host.f\n");
  186.       fprintf (mf,"#\n");
  187.       fprintf (mf,"CUBE_OBJ = cube.o\n");
  188.       fprintf (mf,"#\n");
  189.       fprintf (mf,"OBJ1 = node1.o\n");
  190.       fprintf (mf,"#\n");
  191.     }
  192. }
  193.  
  194. void gen_split (mf)
  195. FILE *mf;
  196.  
  197. { /* splitting host.f and node.f to generate sources */
  198.  
  199.   char node_source [10];
  200.  
  201.   if (target_model == ONLY_NODE)
  202.      sprintf (node_source, "cube");
  203.   else if (target_model == HOST_NODE)
  204.      sprintf (node_source, "node");
  205.   else
  206.      sprintf (node_source, "node1");
  207.  
  208.   fprintf (mf,"$(HSRC): host.stp host.f\n");
  209.   fprintf (mf,"\trm -f $(HSRC) zzz*.f\n");
  210.   fprintf (mf,"\t$(FSPLIT) host.f\n");
  211.   fprintf (mf,"#\n");
  212.   fprintf (mf,"$(NSRC): %s.stp %s.f\n", node_source, node_source);
  213.   fprintf (mf,"\trm -f $(NSRC) zzz*.f\n");
  214.   fprintf (mf,"\t$(FSPLIT) %s.f\n", node_source);
  215.   fprintf (mf,"#\n");
  216. }
  217.  
  218.           /***************************************************
  219.           *                                                  *
  220.           *  generate Library entries                        *
  221.           *                                                  *
  222.           ***************************************************/
  223.  
  224. void gen_libraries (mf)
  225. FILE *mf;
  226. {
  227. /*
  228.   fprintf (mf,"XLIB  = $(DALIB)/libadpx.a -lX11\n");
  229. */
  230.   fprintf (mf,"NLIB  = $(DALIB)/dalib.a\n");
  231.   fprintf (mf,"HLIB  = $(DALIB)/hostlib.a\n");
  232.   fprintf (mf,"LIB1  = $(DALIB)/unilib.a\n");
  233.  
  234.   fprintf (mf,"#\n");
  235.   fprintf (mf,"# main programs of host, node, cube\n");
  236.   fprintf (mf,"#\n");
  237.  
  238.   fprintf (mf,"MAIN_HOST  = $(DALIB)/mhost.o\n");
  239.   fprintf (mf,"MAIN_NODE  = $(DALIB)/mnode.o\n");
  240.   fprintf (mf,"MAIN_CUBE  = $(DALIB)/mcube.o\n");
  241.   fprintf (mf,"MAIN_NODE1 = $(DALIB)/mnode1.o\n");
  242.   fprintf (mf,"#\n");
  243. }
  244.  
  245.           /***************************************************
  246.           *                                                  *
  247.           *  generate compiling entries                      *
  248.           *                                                  *
  249.           ***************************************************/
  250.  
  251. void gen_compile (mf)          /* Compiling host and node */
  252. FILE *mf;
  253. {
  254.   /* Make rules so that we don't get a problem from the implicit ones */
  255.  
  256.   fprintf (mf,"# So that we don't get the default rules\n#\n");
  257.   fprintf (mf, ".SUFFIXES:\n");
  258.   fprintf (mf, ".SUFFIXES: .f .o .stp\n");
  259.   fprintf (mf, "# Fortran compilation rule\n");
  260.   fprintf (mf,".f.o:\n");
  261. #ifdef OS2
  262.   fprintf (mf,"\tf2c -w $<\n");
  263.   fprintf (mf,"\t$(CC) $(NOPT) $<\n");
  264. #else
  265.   fprintf (mf,"\t$(NFC) $(NOPT) -c $<\n");
  266. #endif
  267.   fprintf (mf,"#\n");
  268.   fprintf (mf, "# Width stripping rule\n");
  269.   fprintf (mf,".f.stp:\n");
  270.   fprintf (mf,"\t$(FSTRIP) $< 72\n");
  271.   fprintf (mf,"\ttouch $@\n");
  272.   fprintf (mf,"#\n");
  273.  
  274.   fprintf (mf,"#\n");
  275.   fprintf (mf,"# Compilation rules: host sources, node sources\n");
  276.   fprintf (mf,"#\n");
  277. #ifdef OS2
  278.   fprintf (mf,"host.o: host.stp host.f\n");
  279.   fprintf (mf,"\t$(FC) host.f\n");
  280.   fprintf (mf,"\t$(CC) $(OPT) host.c\n");
  281.   fprintf (mf,"#\n");
  282.   fprintf (mf,"node.o: node.stp node.f\n");
  283.   fprintf (mf,"\t$(NFC) node.f\n");
  284.   fprintf (mf,"\t$(CC) $(OPT) node.c\n");
  285.   fprintf (mf,"#\n");
  286.   fprintf (mf,"cube.o: cube.stp cube.f\n");
  287.   fprintf (mf,"\t$(NFC) cube.f\n");
  288.   fprintf (mf,"\t$(CC) $(OPT) cube.c\n");
  289.   fprintf (mf,"#\n");
  290.   fprintf (mf,"node1.o: node1.stp node1.f\n");
  291.   fprintf (mf,"\t$(NFC) node1.f\n");
  292.   fprintf (mf,"\t$(CC) $(OPT) node1.c\n");
  293. #else
  294.   fprintf (mf,"host.o: host.strip host.f\n");
  295.   fprintf (mf,"\t$(FC) $(OPT) -c host.f\n");
  296.   fprintf (mf,"#\n");
  297.   fprintf (mf,"node.o: node.strip node.f\n");
  298.   fprintf (mf,"\t$(NFC) $(NOPT) -c node.f\n");
  299.   fprintf (mf,"#\n");
  300.   fprintf (mf,"cube.o: cube.strip cube.f\n");
  301.   fprintf (mf,"\t$(NFC) $(NOPT) -c cube.f\n");
  302.   fprintf (mf,"#\n");
  303.   fprintf (mf,"node1.o: node1.strip node1.f\n");
  304.   fprintf (mf,"\t$(NFC) $(NOPT) -c node1.f\n");
  305. #endif
  306.   fprintf (mf,"#\n");
  307.  
  308.   fprintf (mf,"# Target to perform adaption\n#\n");
  309.   fprintf (mf,"adapt: frc\n");
  310.   fprintf (mf,"\t$(ADAPTOR) ");
  311.   if (interactive)
  312.   {
  313.       /* Should really pull out all the relevant options */
  314.       char * p = filename + strlen(filename);
  315.  
  316.       for (; *p != '/' && p >= filename; p--)
  317.           ;
  318.       if (p != filename)
  319.           p++;
  320.  
  321.       fprintf(mf,"%s",p);
  322.   } else
  323.   {
  324.       int i;
  325.  
  326.       for (i=1; i < fad_argc; i++)
  327.           fprintf(mf,"%s ", fad_argv[i]);
  328.   }
  329.   fprintf(mf,"\n#\nfrc:\n#\n");
  330. }
  331.           /***************************************************
  332.           *                                                  *
  333.           *  generate linking entries (shared memory)        *
  334.           *                                                  *
  335.           ***************************************************/
  336.  
  337. void gen_link_shared (mf)
  338. FILE *mf;
  339. {
  340.   /* Linking the shared memory host program */
  341.  
  342.   fprintf (mf,"#\n");
  343.   fprintf (mf,"# host is the shared memory program for host+nodes \n");
  344.   fprintf (mf,"#\n");
  345. #ifdef OS2
  346.   fprintf (mf,"host.exe: $(MAIN_HOST) $(HOST_OBJ) $(NODE_OBJ) \n");
  347.   fprintf (mf,"\t${CC} $(LDFLAGS) -o host.exe $(MAIN_HOST) $(HOST_OBJ) $(NODE_OBJ) $(NLIB)\n");
  348. #else
  349.   fprintf (mf,"host: $(MAIN_HOST) $(HOST_OBJ) $(NODE_OBJ) $(NLIB)\n");
  350.   fprintf (mf,"\t${FC} $(LDFLAGS) -o host $(MAIN_HOST) $(HOST_OBJ) $(NODE_OBJ) $(NLIB)\n");
  351. #endif
  352.   fprintf (mf,"#\n");
  353.  
  354.   /* Linking the shared memory cube program */
  355.  
  356.   fprintf (mf,"#\n");
  357.   fprintf (mf,"# cube is the shared memory program for only nodes \n");
  358.   fprintf (mf,"#\n");
  359. #ifdef OS2
  360.   fprintf (mf,"cube.exe: $(MAIN_CUBE) $(CUBE_OBJ) \n");
  361.   fprintf (mf,"\t${CC} $(LDFLAGS) -o cube.exe $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  362. #else
  363.   fprintf (mf,"cube: $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  364.   fprintf (mf,"\t${FC} $(LDFLAGS) -o cube $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  365. #endif
  366.   fprintf (mf,"#\n");
  367.  
  368.   /* Linking the uniproc program */
  369.  
  370.   fprintf (mf,"#\n");
  371.   fprintf (mf,"#  node is the program for running on one processor\n");
  372.   fprintf (mf,"#\n");
  373. #ifdef OS2
  374.   fprintf (mf,"node1.exe: $(MAIN_NODE1) $(OBJ1) \n");
  375.   fprintf (mf,"\t${CC} $(LDFLAGS) -o node1.exe $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  376. #else
  377.   fprintf (mf,"node1: $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  378.   fprintf (mf,"\t${FC} $(LDFLAGS) -o node1 $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  379. #endif
  380.   fprintf (mf,"#\n");
  381. }
  382.  
  383.           /***************************************************
  384.           *                                                  *
  385.           *  Makefile for the Parsytec GC                    *
  386.           *                                                  *
  387.           ***************************************************/
  388.  
  389. void gen_makefile_GC (split_flag)
  390.  
  391. bool split_flag;     /* true: sources will be splitted for compilation */
  392.  
  393. { FILE *mf;
  394.   int i;
  395.  
  396.   mf = fopen ("Makefile","w");
  397.  
  398.   gen_header (mf, "GC");
  399.  
  400.   /* variables for compiler, pvm architecturs */
  401.  
  402.   fprintf (mf,"FC     = f77.px\n");
  403.   fprintf (mf,"NFC    = f77.px\n");
  404.   fprintf (mf,"CC     = cc.px\n");
  405.  
  406.   /* setting the compiler options for compiling generated functions */
  407.  
  408.   fprintf (mf,"#\n");
  409.   fprintf (mf,"# Compiler Options\n");
  410.   fprintf (mf,"#\n");
  411.   fprintf (mf,"OPT  = -W0,-Xextensions=1\n");
  412.   fprintf (mf,"NOPT = -W0,-Xextensions=1\n");
  413.   fprintf (mf,"#\n");
  414.  
  415.   /* Libraries */
  416.  
  417.   gen_libraries (mf);
  418.  
  419.   /* Collect all OBJ files */
  420.  
  421.   gen_OBJS (mf, split_flag);
  422.  
  423.   /* main or starting entry */
  424.  
  425.   if (target_model == HOST_NODE)
  426.      fprintf (mf,"all: host.px\n");
  427.     else if (target_model == ONLY_NODE)
  428.      fprintf (mf,"all: cube.px\n");
  429.     else
  430.      fprintf (mf,"all: node1.px\n");
  431.   fprintf (mf,"#\n");
  432.  
  433.   /* Linking the executable */
  434.  
  435.   fprintf (mf,"host.px: $(MAIN_HOST) $(HOST_OBJ) $(NODE_OBJ) $(NLIB)\n");
  436.   fprintf (mf,"\t${FC} -o host.px $(MAIN_HOST) $(HOST_OBJ) $(NODE_OBJ) $(NLIB)\n");
  437.   fprintf (mf,"#\n");
  438.   fprintf (mf,"cube.px: $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  439.   fprintf (mf,"\t${FC} -o cube.px $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  440.   fprintf (mf,"#\n");
  441.   fprintf (mf,"node1.px: $(OBJ1) $(LIB1)\n");
  442.   fprintf (mf,"\t${FC} -o node1.px $(OBJ1) $(LIB1)\n");
  443.  
  444.   /* Compiling host and node */
  445.  
  446.   gen_compile (mf);
  447.  
  448.   /* Splitting node.f and host.f to generate sources */
  449.  
  450.   if (split_flag) gen_split (mf);
  451.  
  452.   /* Running entry */
  453.  
  454.   fprintf (mf,"run:\n");
  455.   if (target_model == HOST_NODE)
  456.     fprintf (mf,"\t run -s0 -g1 1 4 host\n");
  457.    else if (target_model == ONLY_NODE)
  458.     fprintf (mf,"\t run -s0 -g1 1 4 cube\n");
  459.    else
  460.     fprintf (mf,"\t run -s0 -g1 1 1 cube\n");
  461.  
  462.   /* Cleaning entry */
  463.  
  464.   fprintf (mf,"clean:\n");
  465.   fprintf (mf,"\t rm -f *.o host.px cube.px node1.px core");
  466.   fprintf (mf," $(NSRC) $(HSRC) zzz*.f\n");
  467.   fprintf (mf,"#\n");
  468.   fclose (mf);
  469.  
  470. } /* gen_makefile_GC */
  471.  
  472.           /***************************************************
  473.           *                                                  *
  474.           *  Makefile for the iPSC/860 (distributed mem.)    *
  475.           *                                                  *
  476.           ***************************************************/
  477.  
  478. void gen_makefile_IPSC (split_flag)
  479.  
  480. bool split_flag;     /* true: sources will be splitted for compilation */
  481.  
  482. { FILE *mf;
  483.   int i;
  484.  
  485.   mf = fopen ("Makefile","w");
  486.  
  487.   gen_header (mf,"IPSC");
  488.  
  489.   /* variables for compiler, pvm architecturs */
  490.  
  491.   fprintf (mf,"FC     = f77\n");
  492.   fprintf (mf,"NFC    = if77\n");
  493.   fprintf (mf,"CC     = cc\n");
  494.  
  495.   /* setting the compiler options for compiling generated functions */
  496.   fprintf (mf,"#\n");
  497.   fprintf (mf, "# Compiler Options\n");
  498.   fprintf (mf, "OPT  = -e\n");
  499.   fprintf (mf, "NOPT = -O -Mvect -Knoieee -Mextend\n");
  500.   fprintf (mf,"#\n");
  501.  
  502.   /* Libraries */
  503.  
  504.   gen_libraries (mf);
  505.  
  506.   /* Collect all OBJ files */
  507.  
  508.   gen_OBJS (mf, split_flag);
  509.  
  510.   /* main or starting entry */
  511.  
  512. #ifdef OS2
  513.   if (target_model == HOST_NODE)
  514.       fprintf (mf,"all: host.exe node.exe\n");
  515.     else if (target_model == ONLY_NODE)
  516.       fprintf (mf,"all: cube.exe\n");
  517.     else
  518.       fprintf (mf,"all: node1.exe\n");
  519.   fprintf (mf,"#\n");
  520. #else
  521.   if (target_model == HOST_NODE)
  522.       fprintf (mf,"all: host node\n");
  523.     else if (target_model == ONLY_NODE)
  524.       fprintf (mf,"all: cube\n");
  525.     else
  526.       fprintf (mf,"all: node1\n");
  527.   fprintf (mf,"#\n");
  528. #endif
  529.  
  530.   /* Linking the host program */
  531.  
  532.   fprintf (mf,"host: $(MAIN_HOST) $(HOST_OBJ) $(HOSTLIB)\n");
  533.   fprintf (mf,"\t$(FC) -o host $(MAIN_HOST) $(HOST_OBJ) $(HOSTLIB) -host\n");
  534.   fprintf (mf,"#\n");
  535.  
  536.   /* Linking the node program */
  537.  
  538.   fprintf (mf,"node: $(MAIN_NODE) $(NODE_OBJ) $(NLIB)\n");
  539.   fprintf (mf,"\t$(NFC) -Knoieee -o node $(MAIN_NODE) $(NODE_OBJ) $(NLIB)\n");
  540.   fprintf (mf,"#\n");
  541.  
  542.   /* Linking the uniproc node program */
  543.  
  544.   fprintf (mf,"node1: $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  545.   fprintf (mf,"\t$(NFC) -Knoieee -o node1 $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  546.   fprintf (mf,"#\n");
  547.  
  548.   /* Linking the cube program */
  549.  
  550.   fprintf (mf,"cube: $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  551.   fprintf (mf,"\t$(NFC) -Knoieee -o cube $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  552.   fprintf (mf,"#\n");
  553.  
  554.   /* Compiling host and node */
  555.  
  556.   gen_compile (mf);
  557.  
  558.   /* Splitting node.f and host.f to generate sources */
  559.  
  560.   if (split_flag) gen_split (mf);
  561.  
  562.   /* Cleaning entry */
  563.  
  564.  fprintf (mf,"clean:\n");
  565.  fprintf (mf,"\t-rm -f *.o host node node1 cube core $(NSRC) $(HSRC) zzz*.f\n");
  566.  fprintf (mf,"#\n");
  567.  fclose (mf);
  568.  
  569. } /* gen_makefile_IPSC */
  570.  
  571.           /***************************************************
  572.           *                                                  *
  573.           *  Makefile for the ALLIANT (shared-memory)        *
  574.           *                                                  *
  575.           ***************************************************/
  576.  
  577. void gen_makefile_ALLIANT (split_flag)
  578.  
  579. bool split_flag;     /* true: sources will be splitted for compilation */
  580.  
  581. { FILE *mf;
  582.   int i;
  583.  
  584.   mf = fopen ("Makefile","w");
  585.  
  586.   gen_header (mf, "ALLIANT");
  587.  
  588.   /* variables for compiler, pvm architecturs */
  589.  
  590.   fprintf (mf,"FC     = fortran\n");
  591.   fprintf (mf,"NFC    = fortran\n");
  592.   fprintf (mf,"CC     = fxc\n");
  593.  
  594.   /* setting the compiler options for compiling generated functions */
  595.   fprintf (mf,"#\n");
  596.   fprintf (mf,"# Compiler Options\n");
  597.   fprintf (mf,"OPT  = -Oguv -uniproc -extend_source -w\n");
  598.   fprintf (mf,"NOPT = -Oguv -uniproc -extend_source -w\n");
  599.   fprintf (mf,"LDFLAGS = -uniproc\n");
  600.   fprintf (mf,"#\n");
  601.  
  602.   /* Libraries */
  603.  
  604.   gen_libraries (mf);
  605.  
  606.   /* Collect all OBJ files */
  607.  
  608.   gen_OBJS (mf, split_flag);
  609.  
  610.   /* main or starting entry */
  611.  
  612. #ifdef OS2
  613.   if (target_model == HOST_NODE)
  614.     { fprintf (mf,"all: host.exe\n");
  615.     }
  616.    else if (target_model == ONLY_NODE)
  617.     { fprintf (mf,"all: cube.exe\n");
  618.     }
  619.    else
  620.     fprintf (mf,"all: node1.exe\n");
  621.   fprintf (mf,"#\n");
  622. #else
  623.   if (target_model == HOST_NODE)
  624.     { fprintf (mf,"all: host\n");
  625.     }
  626.    else if (target_model == ONLY_NODE)
  627.     { fprintf (mf,"all: cube\n");
  628.     }
  629.    else
  630.     fprintf (mf,"all: node1\n");
  631.   fprintf (mf,"#\n");
  632. #endif
  633.  
  634.   /* Generate link entries */
  635.  
  636.   gen_link_shared (mf);
  637.  
  638.   /* Compiling host and node */
  639.  
  640.   gen_compile (mf);
  641.  
  642.   /* Splitting node.f and host.f to generate sources */
  643.  
  644.   if (split_flag) gen_split (mf);
  645.  
  646.   /* Cleaning entry */
  647.  
  648.   fprintf (mf,"clean:\n");
  649.   fprintf (mf,"\t-rm -f *.o host node1 cube core ");
  650.   fprintf (mf,"$(NSRC) $(HSRC) zzz*.f\n");
  651.   fprintf (mf,"#\n");
  652.   fclose (mf);
  653.  
  654. } /* gen_makefile_ALLIANT */
  655.  
  656.           /***************************************************
  657.           *                                                  *
  658.           *  Makefile for the SGI     (shared-memory)        *
  659.           *                                                  *
  660.           ***************************************************/
  661.  
  662. void gen_makefile_SGI (split_flag)
  663.  
  664. bool split_flag;     /* true: sources will be splitted for compilation */
  665.  
  666. { FILE *mf;
  667.   int i;
  668.  
  669.   mf = fopen ("Makefile","w");
  670.  
  671.   gen_header (mf, "SGI");
  672.  
  673.   /* variables for compiler, pvm architecturs */
  674.  
  675.   fprintf (mf,"FC     = f77\n");
  676.   fprintf (mf,"NFC    = f77\n");
  677.   fprintf (mf,"CC     = cc\n");
  678.  
  679.   /* setting the compiler options for compiling generated functions */
  680.   fprintf (mf,"#\n");
  681.   fprintf (mf,"# Compiler Options\n");
  682.   fprintf (mf,"OPT  = -O -extend_source -w\n");
  683.   fprintf (mf,"NOPT = -O -extend_source -w\n");
  684.   fprintf (mf,"#\n");
  685.  
  686.   /* Libraries */
  687.  
  688.   gen_libraries (mf);
  689.  
  690.   /* Collect all OBJ files */
  691.  
  692.   gen_OBJS (mf, split_flag);
  693.  
  694.   /* main or starting entry */
  695.  
  696.   if (target_model == HOST_NODE)
  697.     { fprintf (mf,"all: host\n");
  698.     }
  699.    else if (target_model == ONLY_NODE)
  700.     { fprintf (mf,"all: cube\n");
  701.     }
  702.    else
  703.     fprintf (mf,"all: node1\n");
  704.   fprintf (mf,"#\n");
  705.  
  706.   /* Generate link entries */
  707.  
  708.   gen_link_shared (mf);
  709.  
  710.   /* Compiling host and node */
  711.  
  712.   gen_compile (mf);
  713.  
  714.   /* Splitting node.f and host.f to generate sources */
  715.  
  716.   if (split_flag) gen_split (mf);
  717.  
  718.   /* Cleaning entry */
  719.  
  720.   fprintf (mf,"clean:\n");
  721.   fprintf (mf,"\t-rm -f *.o host node1 cube core ");
  722.   fprintf (mf,"$(NSRC) $(HSRC) zzz*.f\n");
  723.   fprintf (mf,"#\n");
  724.   fclose (mf);
  725.  
  726. } /* gen_makefile_SGI */
  727.  
  728.           /***************************************************
  729.           *                                                  *
  730.           *  Makefile for the KSR 1   (shared-memory)        *
  731.           *                                                  *
  732.           ***************************************************/
  733.  
  734. void gen_makefile_KSR1 (split_flag)
  735.  
  736. bool split_flag;     /* true: sources will be splitted for compilation */
  737.  
  738. { FILE *mf;
  739.   int i;
  740.  
  741.   mf = fopen ("Makefile","w");
  742.  
  743.   gen_header (mf, "KSR1");
  744.  
  745.   /* variables for compiler, pvm architecturs */
  746.  
  747.   fprintf (mf,"FC     = f77\n");
  748.   fprintf (mf,"NFC    = f77\n");
  749.   fprintf (mf,"CC     = cc\n");
  750.  
  751.   /* setting the compiler options for compiling generated functions */
  752.  
  753.   fprintf (mf,"#\n");
  754.   fprintf (mf,"# Compiler Options\n");
  755.   fprintf (mf,"OPT  = -O2 -e -i4 -r8\n");
  756.   fprintf (mf,"NOPT = -O2 -e -i4 -r8\n");
  757.   fprintf (mf,"#\n");
  758.  
  759.   /* Libraries */
  760.  
  761.   gen_libraries (mf);
  762.  
  763.   /* Collect all OBJ files */
  764.  
  765.   gen_OBJS (mf, split_flag);
  766.  
  767.   /* main or starting entry */
  768.  
  769.   if (target_model == HOST_NODE)
  770.     { fprintf (mf,"all: host\n");
  771.     }
  772.    else if (target_model == ONLY_NODE)
  773.     { fprintf (mf,"all: cube\n");
  774.     }
  775.    else
  776.     fprintf (mf,"all: node1\n");
  777.   fprintf (mf,"#\n");
  778.  
  779.   /* Generate link entries */
  780.  
  781.   gen_link_shared (mf);
  782.  
  783.   /* Compiling host and node */
  784.  
  785.   gen_compile (mf);
  786.  
  787.   /* Splitting node.f and host.f to generate sources */
  788.  
  789.   if (split_flag) gen_split (mf);
  790.  
  791.   /* Cleaning entry */
  792.  
  793.   fprintf (mf,"clean:\n");
  794.   fprintf (mf,"\t-rm -f *.o host node1 cube core ");
  795.   fprintf (mf,"$(NSRC) $(HSRC) zzz*.f\n");
  796.   fprintf (mf,"#\n");
  797.   fclose (mf);
  798.  
  799. } /* gen_makefile_KSR1 */
  800.  
  801.           /***************************************************
  802.           *                                                  *
  803.           *  Makefile for Net of Workstations (PVM version)  *
  804.           *                                                  *
  805.           ***************************************************/
  806.  
  807. void gen_makefile_PVM (mf, split_flag, arch)
  808.  
  809. bool split_flag;     /* true: sources will be splitted for compilation */
  810. FILE *mf;
  811. char arch[];
  812.  
  813. {    int i;
  814.      char *r;
  815.  
  816.   /* PHOME Directory , FC, ... is defined */
  817.  
  818.   /* variables for compiler, pvm architecturs */
  819.  
  820.   fprintf (mf,"ARCH = %s\n", arch);
  821.   if (!(r = getenv("PVM_ROOT")))
  822.      r = "/pvm3";
  823.  
  824.   fprintf (mf,"PVM = %s\n", r);
  825.  
  826.   fprintf (mf,"#\n");
  827.  
  828.   /* Libraries */
  829.  
  830.   gen_libraries (mf);
  831.  
  832.   fprintf (mf,"PVMLIB = -lpvm3\n");
  833.   fprintf (mf,"#\n");
  834.  
  835.   /* Collect all OBJ files  */
  836.  
  837.   gen_OBJS (mf, split_flag);
  838.  
  839.   /* main or starting entry */
  840.  
  841. #ifdef OS2
  842.   if (target_model == HOST_NODE)
  843.      { fprintf (mf,"all: host.exe node.exe\n");
  844.        fprintf (mf,"\tmv node.exe $(PVM)/bin/$(ARCH)\n");
  845.      }
  846.     else if (target_model == ONLY_NODE)
  847.      { /* pnode for start and load */
  848.        fprintf (mf,"all: cube.exe\n");
  849.        fprintf (mf,"\tcp cube.exe $(PVM)/bin/$(ARCH)\n");
  850.      }
  851.     else /* uniproc is executable node */
  852.      { fprintf (mf,"all: node1.exe\n");
  853.      }
  854.   fprintf (mf,"#\n");
  855. #else
  856.   if (target_model == HOST_NODE)
  857.      { fprintf (mf,"all: host node\n");
  858.        fprintf (mf,"\tmv node $(PVM)/bin/$(ARCH)\n");
  859.      }
  860.     else if (target_model == ONLY_NODE)
  861.      { /* pnode for start and load */
  862.        fprintf (mf,"all: cube\n");
  863.        fprintf (mf,"\tcp cube $(PVM)/bin/$(ARCH)\n");
  864.      }
  865.     else /* uniproc is executable node */
  866.      { fprintf (mf,"all: node1\n");
  867.      }
  868.   fprintf (mf,"#\n");
  869. #endif
  870.  
  871.   /* Linking the PVM host program */
  872.  
  873. #ifdef OS2
  874.   fprintf (mf,"host.exe: $(HOST_OBJ) $(MAIN_HOST) $(NLIB) \n");
  875.   fprintf (mf,"\t${CC} -s -o host.exe $(MAIN_HOST) $(HOST_OBJ) $(NLIB) $(PVMLIB) -lso32 -lxdr -ltcp32 -los2 -lf2c \n");
  876. #else
  877.   fprintf (mf,"host: $(HOST_OBJ) $(MAIN_HOST) $(NLIB) $(PVMLIB)\n");
  878.   fprintf (mf,"\t${FC} -o host $(MAIN_HOST) $(HOST_OBJ) $(NLIB) $(PVMLIB)\n");
  879. #endif
  880.   fprintf (mf,"#\n");
  881.  
  882.   /* Linking the PVM node program */
  883.  
  884. #ifdef OS2
  885.   fprintf (mf,"node.exe: $(NODE_OBJ) $(MAIN_NODE) $(NLIB) \n");
  886.   fprintf (mf,"\t${CC} -s -o node.exe $(MAIN_NODE) $(NODE_OBJ) $(NLIB) $(PVMLIB) -lso32 -lxdr -ltcp32 -los2 -lf2c \n");
  887. #else
  888.   fprintf (mf,"node: $(NODE_OBJ) $(MAIN_NODE) $(NLIB) $(PVMLIB)\n");
  889.   fprintf (mf,"\t${FC} -o node $(MAIN_NODE) $(NODE_OBJ) $(NLIB) $(PVMLIB)\n");
  890. #endif
  891.   fprintf (mf,"#\n");
  892.  
  893.   /* Linking the PVM cube program */
  894.  
  895. #ifdef OS2
  896.   fprintf (mf,"cube.exe: $(CUBE_OBJ) $(MAIN_CUBE) $(NLIB) \n");
  897.   fprintf (mf,"\t${CC} -s -o cube.exe $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB) $(PVMLIB) -lso32 -lxdr -ltcp32 -los2 -lf2c \n");
  898. #else
  899.   fprintf (mf,"cube: $(CUBE_OBJ) $(MAIN_CUBE) $(NLIB) $(PVMLIB)\n");
  900.   fprintf (mf,"\t${FC} -o cube $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB) $(PVMLIB)\n");
  901. #endif
  902.   fprintf (mf,"#\n");
  903.  
  904.   /* Linking the uniproc node program */
  905.  
  906. #ifdef OS2
  907.   fprintf (mf,"node1.exe: $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  908.   fprintf (mf,"\t${CC} -s -o node1.exe $(MAIN_NODE1) $(OBJ1) $(LIB1) -lf2c -los2\n");
  909. #else
  910.   fprintf (mf,"node1: $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  911.   fprintf (mf,"\t${FC} -o node1 $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  912. #endif
  913.   fprintf (mf,"#\n");
  914.  
  915.   /* Compiling host and node */
  916.  
  917.   gen_compile (mf);
  918.  
  919.   /* Splitting node.f and host.f to generate sources */
  920.  
  921.   if (split_flag) gen_split (mf);
  922.  
  923.   /* Cleaning entry */
  924.  
  925.   fprintf (mf,"clean:\n");
  926. #ifdef OS2
  927.   fprintf (mf,"\t-rm -f *.o node.exe host.exe node1.exe cube.exe core ");
  928. #else
  929.   fprintf (mf,"\t-rm -f *.o node host node1 cube core ");
  930. #endif
  931.   fprintf (mf,"$(NSRC) $(HSRC) zzz*.f\n");
  932.   fprintf (mf,"#\n");
  933.  
  934. } /* gen_makefile_PVM */
  935.  
  936.           /***************************************************
  937.           *                                                  *
  938.           *  Makefile for the ALLIANT (PVM)                  *
  939.           *                                                  *
  940.           ***************************************************/
  941.  
  942. void gen_makefile_ALL_PVM (split_flag)
  943.  
  944. bool split_flag;     /* true: sources will be splitted for compilation */
  945.  
  946. { FILE *mf;
  947.   int i;
  948.  
  949.   mf = fopen ("Makefile","w");
  950.  
  951.   gen_header (mf,"PVM3.1");
  952.  
  953.   /* variables for compiler, pvm architecturs */
  954.  
  955.   fprintf (mf,"FC     = fortran\n");
  956.   fprintf (mf,"NFC    = fortran\n");
  957.   fprintf (mf,"CC     = fxc\n");
  958.  
  959.   /* setting the compiler options for compiling generated functions */
  960.   fprintf (mf,"#\n");
  961.   fprintf (mf,"# Compiler Options\n");
  962.   fprintf (mf,"#\n");
  963.   fprintf (mf,"OPT  = -Oguv -uniproc -extend_source -w\n");
  964.   fprintf (mf,"NOPT = -Oguv -uniproc -extend_source -w\n");
  965.   fprintf (mf,"#\n");
  966.  
  967.   gen_makefile_PVM (mf, split_flag, "FX2800");
  968.  
  969.   fclose (mf);
  970.  
  971. } /* gen_makefile_ALL_PVM */
  972.  
  973.           /***************************************************
  974.           *                                                  *
  975.           *  Makefile for the KSR1    (PVM)                  *
  976.           *                                                  *
  977.           ***************************************************/
  978.  
  979. void gen_makefile_KSR1_PVM (split_flag)
  980.  
  981. bool split_flag;     /* true: sources will be splitted for compilation */
  982.  
  983. { FILE *mf;
  984.   int i;
  985.  
  986.   mf = fopen ("Makefile","w");
  987.  
  988.   gen_header (mf, "PVM3.1");
  989.  
  990.   /* variables for compiler, pvm architecturs */
  991.  
  992.   fprintf (mf,"FC     = f77\n");
  993.   fprintf (mf,"NFC    = f77\n");
  994.   fprintf (mf,"CC     = cc\n");
  995.  
  996.   /* setting the compiler options for compiling generated functions */
  997.   fprintf (mf,"#\n");
  998.   fprintf (mf,"# Compiler Options\n");
  999.   fprintf (mf,"OPT  = -O2 -e -i4 -r8");
  1000.   fprintf (mf,"NOPT = -O2 -e -i4 -r8");
  1001.   fprintf (mf,"#\n");
  1002.  
  1003.   gen_makefile_PVM (mf, split_flag, "KSR1");
  1004.  
  1005.   fclose (mf);
  1006.  
  1007. } /* gen_makefile_KSR1_PVM */
  1008.  
  1009.           /***************************************************
  1010.           *                                                  *
  1011.           *  Makefile for Net of SUN4 (PVM version)          *
  1012.           *                                                  *
  1013.           ***************************************************/
  1014.  
  1015. void gen_makefile_SUN4_PVM (split_flag)
  1016.  
  1017. bool split_flag;     /* true: sources will be splitted for compilation */
  1018.  
  1019. { FILE *mf;
  1020.   int i;
  1021.  
  1022.   mf = fopen ("Makefile","w");
  1023.  
  1024.   gen_header (mf, "PVM3.1");
  1025.  
  1026.   /* variables for compiler, pvm architecturs */
  1027.  
  1028.   fprintf (mf,"FC  = /vol/lang/f77\n");
  1029.   fprintf (mf,"NFC = /vol/lang/f77\n");
  1030.   fprintf (mf,"FSPLIT = /vol/lang/fsplit\n");
  1031.   fprintf (mf,"CC  = cc\n");
  1032.  
  1033.   /* setting the compiler options for compiling generated functions */
  1034.  
  1035.   fprintf (mf,"#\n");
  1036.   fprintf (mf,"# Compiler Options\n");
  1037.   fprintf (mf,"OPT  = %s\n", SUN4_PVM_OPTIONS);
  1038.   fprintf (mf,"NOPT = %s\n", SUN4_PVM_OPTIONS);
  1039.   fprintf (mf,"#\n");
  1040.  
  1041.   gen_makefile_PVM (mf, split_flag, "SUN4");
  1042.  
  1043.   fclose (mf);
  1044.  
  1045. } /* gen_makefile_SUN4_PVM */
  1046.  
  1047.  
  1048.           /***************************************************
  1049.           *                                                  *
  1050.           *  Makefile for Net of OS2 (PVM version)           *
  1051.           *                                                  *
  1052.           ***************************************************/
  1053.  
  1054. void gen_makefile_OS2_PVM (split_flag)
  1055.  
  1056. bool split_flag;     /* true: sources will be splitted for compilation */
  1057.  
  1058. { FILE *mf;
  1059.   int i;
  1060.  
  1061.   mf = fopen ("Makefile","w");
  1062.  
  1063.   gen_header (mf, "PVM3.2");
  1064.  
  1065.   /* variables for compiler, pvm architecturs */
  1066.  
  1067.   fprintf (mf,"FC  = f2c -w\n");
  1068.   fprintf (mf,"NFC = f2c -w\n");
  1069.   fprintf (mf,"FSPLIT = fsplit\n");
  1070.   fprintf (mf,"CC  = gcc\n");
  1071.  
  1072.   /* setting the compiler options for compiling generated functions */
  1073.  
  1074.   fprintf (mf,"#\n");
  1075.   fprintf (mf,"# Compiler Options\n");
  1076.   fprintf (mf,"OPT  = -c -O2\n");
  1077.   fprintf (mf,"NOPT = -c\n");
  1078.   fprintf (mf,"#\n");
  1079.  
  1080.   split_flag = 0;
  1081.   gen_makefile_PVM (mf, split_flag, "OS2");
  1082.  
  1083.   fclose (mf);
  1084.  
  1085. } /* gen_makefile_OS2_PVM */
  1086.  
  1087.  
  1088.           /***************************************************
  1089.           *                                                  *
  1090.           *  Makefile for Net of IBM RISC (PVM version)      *
  1091.           *                                                  *
  1092.           ***************************************************/
  1093.  
  1094. void gen_makefile_RIOS_PVM (split_flag)
  1095.  
  1096. bool split_flag;     /* true: sources will be splitted for compilation */
  1097.  
  1098. { FILE *mf;
  1099.   int i;
  1100.  
  1101.   mf = fopen ("Makefile","w");
  1102.  
  1103.   gen_header (mf, "PVM3.1");
  1104.  
  1105.   /* variables for compiler, pvm architecturs */
  1106.   fprintf (mf,"#\n");
  1107.   fprintf (mf,"FC  = xlf\n");
  1108.   fprintf (mf,"NFC = xlf\n");
  1109.   fprintf (mf,"CC  = cc\n");
  1110.  
  1111.   /* setting the compiler options for compiling generated functions */
  1112.   fprintf (mf,"#\n");
  1113.   fprintf (mf,"# Compiler Options\n");
  1114.   fprintf (mf,"OPT  = %s\n", RIOS_PVM_OPTIONS);
  1115.   fprintf (mf,"NOPT = %s\n", RIOS_PVM_OPTIONS);
  1116.   fprintf (mf,"#\n");
  1117.  
  1118.   gen_makefile_PVM (mf, split_flag, "RIOS");
  1119.  
  1120.   fclose (mf);
  1121.  
  1122. } /* gen_makefile_RIOS_PVM */
  1123.  
  1124.           /*****************************************************
  1125.           *                                                    *
  1126.           *  Makefile for the Meiko CS 1   (distributed mem.)  *
  1127.           *                                                    *
  1128.           *****************************************************/
  1129.  
  1130. void gen_makefile_MEIKO_CS1 (split_flag)
  1131.  
  1132. bool split_flag;     /* true: sources will be splitted for compilation */
  1133.  
  1134. { FILE *mf;
  1135.   int i;
  1136.  
  1137.   mf = fopen ("Makefile","w");
  1138.  
  1139.   gen_header (mf, "MEIKO-CS1");
  1140.  
  1141.   /* variables for compiler, pvm architecturs */
  1142.  
  1143.   fprintf (mf,"FC     = pgf77\n");
  1144.   fprintf (mf,"NFC    = pgf77\n");
  1145.   fprintf (mf,"FSTRIP = $(PHOME)/bin/fstrip\n");
  1146.  
  1147.   /* setting the compiler options for compiling generated functions */
  1148.   fprintf (mf,"#\n");
  1149.   fprintf (mf, "# Compiler Options\n");
  1150.   fprintf (mf, "OPT  = -Mextend\n");
  1151.   fprintf (mf, "NOPT = -Minfo=loop -O4 -Mextend -Mvect -Mnoframe\n");
  1152.   fprintf (mf,"#\n");
  1153.  
  1154.   /* Libraries */
  1155.  
  1156. /*
  1157.   fprintf (mf,"XLIB    = $(DALIB)/libadpx.a -lX11\n");
  1158. */
  1159.   fprintf (mf,"LIBS    = -lmpsc -lcs -lcsn\n");
  1160.   fprintf (mf,"NODELIB = $(DALIB)/libnode.a\n");
  1161.   fprintf (mf,"HOSTLIB = $(DALIB)/libhost.a\n");
  1162.   fprintf (mf,"#\n");
  1163.   fprintf (mf,"LIB1    = $(DALIB)/unilib.a\n");
  1164.   fprintf (mf,"MAIN_NODE   = $(DALIB)/mnode.o\n");
  1165.   fprintf (mf,"MAIN_CUBE   = $(DALIB)/mcube.o\n");
  1166.   fprintf (mf,"MAIN_HOST   = $(DALIB)/mhost.o\n");
  1167.   fprintf (mf,"MAIN_NODE1  = $(DALIB)/mnode1.o\n");
  1168.   fprintf (mf,"#\n");
  1169.  
  1170.   /* Collect all OBJ files */
  1171.  
  1172.   gen_OBJS (mf, split_flag);
  1173.  
  1174.   /* main or starting entry */
  1175.  
  1176. #ifdef OS2
  1177.   if (target_model == HOST_NODE)
  1178.       fprintf (mf,"all: host.exe node.exe\n");
  1179.     else if (target_model == ONLY_NODE)
  1180.       fprintf (mf,"all: cube.exe\n");
  1181.     else
  1182.       fprintf (mf,"all: node1.exe\n");
  1183.   fprintf (mf,"#\n");
  1184. #else
  1185.   if (target_model == HOST_NODE)
  1186.       fprintf (mf,"all: host node\n");
  1187.     else if (target_model == ONLY_NODE)
  1188.       fprintf (mf,"all: cube\n");
  1189.     else
  1190.       fprintf (mf,"all: node1\n");
  1191.   fprintf (mf,"#\n");
  1192. #endif
  1193.  
  1194.   /* Linking the host program */
  1195.  
  1196.   fprintf (mf,"host: $(MAIN_HOST) $(HOST_OBJ) $(HOSTLIB)\n");
  1197.   fprintf (mf,"\t$(FC) -o host $(MAIN_HOST) $(HOST_OBJ) $(HOSTLIB) $(LIBS)\n");
  1198.   fprintf (mf,"#\n");
  1199.  
  1200.   /* Linking the node program */
  1201.  
  1202.   fprintf (mf,"node: $(MAIN_NODE) $(NODE_OBJ) $(NODELIB)\n");
  1203.   fprintf (mf,"\t$(NFC) -o node $(MAIN_NODE) $(NODE_OBJ) $(NODELIB) $(LIBS)\n");
  1204.   fprintf (mf,"#\n");
  1205.  
  1206.   /* Linking the cube program */
  1207.  
  1208.   fprintf (mf,"cube: $(MAIN_CUBE) $(CUBE_OBJ) $(NODELIB)\n");
  1209.   fprintf (mf,"\t$(NFC) -o cube $(MAIN_CUBE) $(CUBE_OBJ) $(NODELIB) $(LIBS)\n");
  1210.   fprintf (mf,"#\n");
  1211.  
  1212.   /* Linking the uniproc node program */
  1213.  
  1214.   fprintf (mf,"node1: $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  1215.   fprintf (mf,"\t$(NFC) -o node1 $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  1216.   fprintf (mf,"#\n");
  1217.  
  1218.   /* Compiling host and node */
  1219.  
  1220.   gen_compile (mf);
  1221.  
  1222.   /* Splitting node.f and host.f to generate sources */
  1223.  
  1224.   if (split_flag) gen_split (mf);
  1225.  
  1226.   /* Cleaning entry */
  1227.  
  1228.   fprintf (mf,"clean:\n");
  1229.   fprintf (mf,"\t-/bin/rm -f *.o vpu/*.o *.strip adaptor.* *~ host node \\\n");
  1230.   fprintf (mf,"\t            cube vcube core $(NSRC) $(HSRC) zzz*.f\n");
  1231.   fprintf (mf,"#\n");
  1232.   fclose (mf);
  1233.  
  1234. } /* gen_makefile_MEIKO_CS1 */
  1235.  
  1236.           /*****************************************************
  1237.           *                                                    *
  1238.           *  Makefile for the Meiko CS 2   (distributed mem.)  *
  1239.           *                                                    *
  1240.           *****************************************************/
  1241.  
  1242. void gen_makefile_MEIKO_CS2 (split_flag)
  1243.  
  1244. bool split_flag;     /* true: sources will be splitted for compilation */
  1245.  
  1246. { FILE *mf;
  1247.   int i;
  1248.  
  1249.   mf = fopen ("Makefile","w");
  1250.  
  1251.   gen_header (mf, "MEIKO-CS2");
  1252.  
  1253.   /* variables for compiler, pvm architecturs */
  1254.  
  1255.   fprintf (mf,"FC     = f77\n");
  1256.   fprintf (mf,"NFC    = f77\n");
  1257.   fprintf (mf,"VFC    = pgf77\n");
  1258.   fprintf (mf,"MHOME  = /opt/MEIKOcs2\n");  /* Root of CS2 code */
  1259.  
  1260.   /* setting the compiler options for compiling generated functions */
  1261.   fprintf (mf,"#\n");
  1262.   fprintf (mf,"# OPT : Compiler Options for SunPRO f77\n");
  1263.   fprintf (mf,"OPT  = -Nl100 -e -w -fast\n");
  1264.   fprintf (mf,"NOPT = $(OPT)\n");
  1265.   fprintf (mf,"#\n");
  1266.   fprintf (mf,"# VOPT : Compiler Options for PGI vectorising f77\n");
  1267.   fprintf (mf,"#\n");
  1268.   fprintf (mf,"VOPT = -Mextend -O4 -Mvect -Mx,80,1 -Mx,98,2\n");
  1269.   fprintf (mf,"#\n");
  1270.  
  1271.   /* Libraries */
  1272.  
  1273. /*
  1274.   fprintf (mf,"XLIB        = $(DALIB)/libadpx.a -lX11\n");
  1275. */
  1276.   fprintf (mf,"LIBS        = -L$(MHOME)/lib -lmpsc -lew -lelan -laio\n");
  1277.   fprintf (mf,"NODELIB     = $(DALIB)/libnode.a\n");
  1278.   fprintf (mf,"HOSTLIB     = $(DALIB)/libhost.a\n");
  1279.   fprintf (mf,"LIB1        = $(DALIB)/libuni.a\n");
  1280.   fprintf (mf,"#\n");
  1281.   fprintf (mf,"# Special MAIN Needed for Sun's f77 compiler\n");
  1282.   fprintf (mf,"MAIN_SUNF77 = $(DALIB)/cubemain.o\n");
  1283.   fprintf (mf,"MAIN_NODE   = $(DALIB)/mnode.o\n");
  1284.   fprintf (mf,"MAIN_CUBE   = $(DALIB)/mcube.o\n");
  1285.   fprintf (mf,"MAIN_HOST   = $(DALIB)/mhost.o\n");
  1286.   fprintf (mf,"MAIN_NODE1  = $(DALIB)/mnode1.o\n");
  1287.   fprintf (mf,"#\n");
  1288.  
  1289.   /* Collect all OBJ files */
  1290.  
  1291.   gen_OBJS (mf, split_flag);
  1292.  
  1293.   fprintf(mf,"# Object files for the vector node\n");
  1294.   fprintf(mf,"VNODE_OBJ = $(NODE_OBJ:%%=vpu/%%)\n");
  1295.   fprintf(mf,"VCUBE_OBJ = $(CUBE_OBJ:%%=vpu/%%)\n");
  1296.   fprintf(mf,"VOBJ1     = $(OBJ1:%%=vpu/%%)\n#\n");
  1297.  
  1298.   /* main or starting entry */
  1299.  
  1300.   if (target_model == HOST_NODE)
  1301.       fprintf (mf,"all: host node\n");
  1302.     else if (target_model == ONLY_NODE)
  1303.       fprintf (mf,"all: cube\n");
  1304.     else
  1305.       fprintf (mf,"all: node1\n");
  1306.   fprintf (mf,"#\n");
  1307.  
  1308.  
  1309.   /* Linking the host program */
  1310.   fprintf (mf,"host: $(MAIN_HOST) $(HOST_OBJ) $(HOSTLIB)\n");
  1311.   fprintf (mf,"\t$(FC) $(OPT) -o $@ $(MAIN_SUNF77) $(MAIN_HOST) $(HOST_OBJ) $(HOSTLIB) $(LIBS)\n");
  1312.   fprintf (mf,"#\n");
  1313.  
  1314.   /* Linking the node program */
  1315.   fprintf (mf,"node: $(MAIN_NODE) $(NODE_OBJ) $(NODELIB)\n");
  1316.   fprintf (mf,"\t$(NFC) $(NOPT) -o $@ $(MAIN_SUNF77) $(MAIN_NODE) $(NODE_OBJ) $(NODELIB) $(LIBS)\n");
  1317.   fprintf (mf,"#\n");
  1318.   fprintf (mf,"vnode: $(MAIN_NODE) $(VNODE_OBJ) $(NODELIB)\n");
  1319.   fprintf (mf,"\t$(VFC) $(VOPT) -o $@ $(MAIN_NODE) $(VNODE_OBJ) $(NODELIB) $(LIBS)\n");
  1320.   fprintf (mf,"#\n");
  1321.  
  1322.   /* Linking the cube program */
  1323.   fprintf (mf,"cube: $(MAIN_CUBE) $(CUBE_OBJ) $(NODELIB)\n");
  1324.   fprintf (mf,"\t$(NFC) $(NOPT) -o $@ $(MAIN_SUNF77) $(MAIN_CUBE) $(CUBE_OBJ) $(NODELIB) $(LIBS)\n");
  1325.   fprintf (mf,"#\n");
  1326.   /* Linking the vectorised cube program */
  1327.   fprintf (mf,"vcube: $(MAIN_CUBE) $(VCUBE_OBJ) $(NODELIB)\n");
  1328.   fprintf (mf,"\t$(VFC) $(VOPT) -o $@ $(MAIN_CUBE) $(VCUBE_OBJ) $(NODELIB) $(LIBS)\n");
  1329.   fprintf (mf,"#\n");
  1330.  
  1331.   /* Linking the uniproc node program */
  1332.   fprintf (mf,"node1: $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  1333.   fprintf (mf,"\t$(NFC) $(NOPT) -o $@ $(MAIN_SUNF77) $(MAIN_NODE1) $(OBJ1) $(LIB1)\n");
  1334.   fprintf (mf,"#\n");
  1335.   /* Linking the vectorised uniproc node program */
  1336.   fprintf (mf,"vnode1: $(MAIN_NODE1) $(VOBJ1) $(LIB1)\n");
  1337.   fprintf (mf,"\t$(VFC) $(VOPT) -o $@ $(MAIN_NODE1) $(VOBJ1) $(LIB1)\n");
  1338.   fprintf (mf,"#\n");
  1339.  
  1340.  
  1341.   /* Compiling host and node */
  1342.   gen_compile (mf);
  1343.   /* Additional rules */
  1344.   fprintf (mf,"vpu/%%.o: %%.f\n");
  1345.   fprintf (mf,"\t$(VFC) $(VOPT) -c -o $@ $<\n#\n");
  1346.  
  1347.   /* Splitting node.f and host.f to generate sources */
  1348.   if (split_flag) gen_split (mf);
  1349.  
  1350.   fprintf (mf,"$(VNODE_OBJ) $(VCUBE_OBJ) $(VOBJ1): vpu \n");
  1351.   fprintf (mf,"#\n");
  1352.  
  1353.   fprintf (mf,"vpu: \n\tmkdir vpu\n#\n");
  1354.  
  1355.   /* Cleaning entry */
  1356.  
  1357.   fprintf (mf,"clean:\n");
  1358.   fprintf (mf,"\t-/bin/rm -f *.o vpu/*.o *.strip adaptor.* *~ host node \\\n");
  1359.   fprintf (mf,"\t            cube vcube node1 vnode1 core $(NSRC) $(HSRC) node1.f cube.f zzz*.f\n");
  1360.   fprintf (mf,"#\n");
  1361.   fclose (mf);
  1362.  
  1363. } /* gen_makefile_MEIKO_CS2 */
  1364.  
  1365.           /***************************************************
  1366.           *                                                  *
  1367.           *  Makefile for the CM 5     (distributed mem.)    *
  1368.           *                                                  *
  1369.           ***************************************************/
  1370.  
  1371. void gen_makefile_CM5 (split_flag)
  1372.  
  1373. bool split_flag;     /* true: sources will be splitted for compilation */
  1374.  
  1375. { FILE *mf;
  1376.   int i;
  1377.  
  1378.   mf = fopen ("Makefile","w");
  1379.  
  1380.   gen_header (mf, "CM5");
  1381.  
  1382.   /* variables for compiler */
  1383.  
  1384.   fprintf (mf,"FC     = f77\n");
  1385.   fprintf (mf,"NFC    = f77\n");
  1386.   fprintf (mf,"CC     = cc\n");
  1387.  
  1388.   /* setting the compiler options for compiling generated functions */
  1389.  
  1390.   fprintf (mf,"#\n");
  1391.   fprintf (mf, "# Compiler Options\n");
  1392.   fprintf (mf, "OPT  = -e -w -O\n");
  1393.   fprintf (mf, "NOPT = -e -w -O\n");
  1394.   fprintf (mf,"#\n");
  1395.  
  1396.   /* Libraries */
  1397.  
  1398.   gen_libraries (mf);
  1399.  
  1400.   /* Collect all OBJ files */
  1401.  
  1402.   gen_OBJS (mf, split_flag);
  1403.  
  1404.   /* main or starting entry */
  1405.  
  1406.   if (target_model == HOST_NODE)
  1407.       fprintf (mf,"all: host\n");
  1408.     else if (target_model == ONLY_NODE)
  1409.       fprintf (mf,"all: cube\n");
  1410.     else
  1411.       fprintf (mf,"all: node1\n");
  1412.   fprintf (mf,"#\n");
  1413.  
  1414.   /* Linking the host and node program */
  1415.  
  1416.   fprintf (mf,"host: $(MAIN_HOST) $(MAIN_NODE) $(HOST_OBJ) $(NODE_OBJ) $(HLIB) $(NLIB)\n");
  1417.   fprintf (mf,"\tcmmd-ld -comp $(FC) -v -g -o host \\\n");
  1418.   fprintf (mf,"\t-node $(MAIN_NODE) $(NODE_OBJ) $(NLIB) \\\n");
  1419.   fprintf (mf,"\t-host $(MAIN_HOST) $(HOST_OBJ) $(HLIB) \n");
  1420.   fprintf (mf,"#\n");
  1421.  
  1422.   /* Linking the uniproc node program */
  1423.  
  1424.   fprintf (mf,"node1: $(MAIN_NODE1) $(NODE_OBJ) $(LIB1)\n");
  1425.   fprintf (mf,"\t$(NFC) -o node $(MAIN_NODE1) $(NODE_OBJ) $(LIB1)\n");
  1426.   fprintf (mf,"#\n");
  1427.  
  1428.   /* Linking the cube program */
  1429.  
  1430.   fprintf (mf,"cube: $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  1431.   fprintf (mf,"\tcmmd-ld -comp f77 -o cube $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  1432.   fprintf (mf,"#\n");
  1433.  
  1434.   /* Compiling host and node */
  1435.  
  1436.   gen_compile (mf);
  1437.  
  1438.   /* Splitting node.f and host.f to generate sources */
  1439.  
  1440.   if (split_flag) gen_split (mf);
  1441.  
  1442.   /* Cleaning entry */
  1443.  
  1444.   fprintf (mf,"clean:\n");
  1445.   fprintf (mf,"\t-rm -f *.o host cube host.trace $(NSRC) $(HSRC) zzz*.f\n");
  1446.   fprintf (mf,"#\n");
  1447.   fclose (mf);
  1448.  
  1449. } /* gen_makefile_CM5 */
  1450.  
  1451.           /***************************************************
  1452.           *                                                  *
  1453.           *  Makefile for the CM 5     (distributed mem.)    *
  1454.           *                                                  *
  1455.           *  this solution is for using VECTOR UNITS         *
  1456.           *  and using the CM Fortran compiler for nodes     *
  1457.           *                                                  *
  1458.           ***************************************************/
  1459.  
  1460. void gen_makefile_CM5a (split_flag)
  1461.  
  1462. bool split_flag;     /* true: sources will be splitted for compilation */
  1463.  
  1464. { FILE *mf;
  1465.   int i;
  1466.  
  1467.   mf = fopen ("Makefile","w");
  1468.  
  1469.   gen_header (mf, "CM5a");
  1470.   fprintf (mf,"CMMD_ROOT = /usr/cmmd/3.0\n");
  1471.  
  1472.   /* variables for compiler */
  1473.  
  1474.   fprintf (mf,"FC     = cmf\n");
  1475.   fprintf (mf,"NFC    = cmf\n");
  1476.  
  1477.   /* setting the compiler options for compiling generated functions */
  1478.  
  1479.   fprintf (mf,"#\n");
  1480.   fprintf (mf, "# Compiler Options\n");
  1481.   fprintf (mf, "OPT  = -e -w -O\n");
  1482.   fprintf (mf, "NOPT = -e -w -O\n");
  1483.   fprintf (mf,"#\n");
  1484.  
  1485.   /* Libraries */
  1486.  
  1487.   gen_libraries (mf);
  1488.  
  1489.   /* Collect all OBJ files */
  1490.  
  1491.   gen_OBJS (mf, split_flag);
  1492.  
  1493.   /* main or starting entry */
  1494.  
  1495.   if (target_model == HOST_NODE)
  1496.       fprintf (mf,"all: host\n");
  1497.     else if (target_model == ONLY_NODE)
  1498.       fprintf (mf,"all: cube\n");
  1499.     else
  1500.       fprintf (mf,"all: node1\n");
  1501.   fprintf (mf,"#\n");
  1502.  
  1503.   /* Linking the uniproc node program */
  1504.  
  1505.   fprintf (mf,"node1: $(NODE_OBJ) $(LIB1)\n");
  1506.   fprintf (mf,"\t$(NFC) -o node $(NODE_OBJ) $(LIB1)\n");
  1507.   fprintf (mf,"#\n");
  1508.  
  1509.   /* Linking the cube program */
  1510.  
  1511.   fprintf (mf,"cube: $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB)\n");
  1512.   fprintf (mf,"\tcmf -node -cmmd_root $(CMMD_ROOT)  $(MAIN_CUBE) $(CUBE_OBJ) $(NLIB) -v -o cube\n");
  1513.   fprintf (mf,"#\n");
  1514.  
  1515.   /* Compiling host and node */
  1516.  
  1517.   fprintf (mf,"cube.o: cube.fcm\n");
  1518.   fprintf (mf,"\t$(NFC) $(NOPT) -c cube.fcm\n");
  1519.   fprintf (mf,"#\n");
  1520.   fprintf (mf,"cube.fcm: cube.f\n");
  1521.   fprintf (mf,"\tmv cube.f cube.fcm\n");
  1522.  
  1523.   /* Splitting node.f and host.f to generate sources */
  1524.  
  1525.   if (split_flag) gen_split (mf);
  1526.  
  1527.   /* Cleaning entry */
  1528.  
  1529.   fprintf (mf,"clean:\n");
  1530.   fprintf (mf,"\t-rm -f *.o host cube host.trace $(NSRC) $(HSRC) zzz*.f\n");
  1531.   fprintf (mf,"#\n");
  1532.   fclose (mf);
  1533.  
  1534. } /* gen_makefile_CM5 */
  1535.  
  1536. void gen_makefile ()
  1537.  
  1538. { /* split_flag is global from global.h */
  1539.  
  1540.     /* Only write a Makefile if it doesn't already exist */
  1541.  
  1542.    /*    if (access("Makefile", R_OK) != 0)   */
  1543.  
  1544.     switch(target_machine)
  1545.     {
  1546.       case OS2_PVM:     gen_makefile_OS2_PVM   (split_flag); break;
  1547.       case SUN4_PVM:    gen_makefile_SUN4_PVM  (split_flag); break;
  1548.       case RIOS_PVM:    gen_makefile_RIOS_PVM  (split_flag); break;
  1549.       case ALLIANT :    gen_makefile_ALLIANT   (split_flag); break;
  1550.       case IPSC_860:    gen_makefile_IPSC      (split_flag); break;
  1551.       case PARSYTEC_GC: gen_makefile_GC        (split_flag); break;
  1552.       case MEIKO_CS1:   gen_makefile_MEIKO_CS1 (split_flag); break;
  1553.       case MEIKO_CS2:   gen_makefile_MEIKO_CS2 (split_flag); break;
  1554.       case KSR1:        gen_makefile_KSR1      (split_flag); break;
  1555.       case KSR1_PVM:    gen_makefile_KSR1_PVM  (split_flag); break;
  1556.       case ALL_PVM:     gen_makefile_ALL_PVM   (split_flag); break;
  1557.       case CM5:         if (target_language == FORTRAN_90)
  1558.                           { gen_makefile_CM5a      (split_flag); break; }
  1559.                          else
  1560.                           { gen_makefile_CM5       (split_flag); break; }
  1561.       case SGI:         gen_makefile_SGI       (split_flag); break;
  1562.  
  1563.       default : fprintf (stderr,"gen_makefile failed, unknown machine\n");
  1564.                 break;
  1565.     }
  1566.  
  1567. } /* gen_makefile */
  1568.  
  1569.