Home
Manual
Packages
Global Index
Keywords
Quick Reference
|
/*
MAKE.I
Yorick automatic Makefile generator.
$Id$
*/
/* Copyright (c) 1996. The Regents of the University of California.
All rights reserved. */
func make (args)
/* DOCUMENT make, args
or make
makes a Makefile for ARGS(1) in the current working directory.
args is a list of strings that looks like this:
[code_name, new1, new2, ..., "+", old1, old2, ...]
(Without ARGS, checks to be sure that existing Makefile has
correct MAKE_TEMPLATE for this platform.)
Each NEWi is a Yorick include file in the current working
directory, which will become a startup file for the new custom
version of Yorick you want to build. Each OLDi file is a
startup file for a previously built package; these must be in
either the Y_SITE/i0 or Y_SITE/contrib directories (or
have softlinks in the current working directory).
The matrix.i and fft.i packages are included by default; if you
want to override that default, specify "-matrix" and/or "-fft"
as part of the list of OLDi.
All the startup files must contain a MAKE-INSTRUCTIONS comment.
It should be placed near the top of each startup file.
This comment consists of a line containing slash* followed by
MAKE-INSTRUCTIONS then a number of lines with various keywords,
then the closing *slash on its own line. The recognized keywords
are:
SRCS = src1.c src2.c src3.f ...
LIB = pkg
DEPLIBS = dep1 dep2
NO-WRAPPERS
The SRCS keyword is mandatory; the others are all optional.
The SRCS are the source files which produce the compiled functions
referenced by the extern statements in the startup file which
contains this MAKE-INSTRUCTIONS comment. The extension ".f" or
".F" implies Fortran source code, which has some special configuration
fiddles (see Y_HOME/Maketmpl). You can continue the list by placing
a backslash \ at the end of a line; the list of SRCS stops after the
first line which does not end with \.
The LIB keyword specifies the name of the library for this package.
The library will actually be called libpkg.a and the load option will
be -lpkg (don't try to include these decoration in the name pkg you
supply). If the LIB keyword is not present, you will get no library,
and you won't be able to use this startup file as one of the OLDi in
any new custom versions of Yorick you may build in the future.
DEPLIBS is a list of any dependent libraries which the compiled
functions in SRCS may need. Do not include m (the libm math library)
or any Fortran libraries or other libraries related to or used by
Yorick itself here. Hopefully, you won't need DEPLIBS at all -- if
you do, you will probably need to tweek the Makefile to add correct
-L options so that libdep1, libdep2, etc can be found.
If none of the extern functions in this startup file has a
PROTOTYPE comment, add the NO-WRAPPERS keyword, otherwise don't.
See Y_HOME/Maketmpl for more information (start yorick and type
Y_HOME to find the directory name at your site).
To run this program in batch mode:
yorick -batch make.i
type this after you've moved to a new platform in order to
set the MAKE_TEMPLATE in the Makefile to the correct value
for this platform (Y_HOME is probably different)
yorick -batch make.i code_name new1 new2 ...
yorick -batch make.i code_name new1 new2 ... + old1 old2 ...
type this to construct a new Makefile for code_name
if a Makefile already exists, it simply performs the check as
above; if you want to rebuild a new Makefile, you need to
remove or change the name of the old one by hand
*/
{
if (check_makefile()) return;
if (numberof(args)<1)
error, "Usage: code_name new1 new2 ... + old1 old2 ...";
code_name= args(1);
if (numberof(args)<2) args= [];
else args= args(2:0);
if (numberof(args)) {
list= where(args=="+");
if (numberof(list)) {
list= list(1);
if (list>1) new_pkgs= args(1:list-1);
else new_pkgs= [];
if (list<numberof(args)) old_pkgs= args(list+1:0);
else old_pkgs= [];
} else {
new_pkgs= args;
old_pkgs= [];
}
}
dflt_pkgs= [];
list= where(old_pkgs!="-matrix");
if (numberof(list)<numberof(old_pkgs)) old_pkgs= old_pkgs(list);
else grow, dflt_pkgs, "matrix.i";
list= where(old_pkgs!="-fft");
if (numberof(list)<numberof(old_pkgs)) old_pkgs= old_pkgs(list);
else grow, dflt_pkgs, "fft.i";
old_pkgs= undup_names(grow(old_pkgs, dflt_pkgs));
new_makefile, code_name, new_pkgs, old_pkgs;
}
func check_makefile (void)
{
/* check an existing makefile for MAKE_TEMPLATE
* also, check for an outdated Makefile and try to update to
* the modern form
* returns 1 if (possibly modified) Makefile is usable,
* returns 0 if new Makefile must be built from scratch */
f= open("Makefile", "r", 1);
if (is_void(f)) return 0;
/* read the whole Makefile into memory as an array of strings */
list= array(pointer, 200);
len= array(0, 200);
obsolete= [];
i0= 0;
for (i=1 ; i<=200 ; ++i) {
lines= rdline(f, 100);
if (is_void(obsolete)) {
token= strtok(lines," \t=");
test= where(token(1,)=="MAKE_TEMPLATE");
if (numberof(test)) {
obsolete= 0;
test= test(1); /* should there be a warning if more than one? */
token= strtok(token(2,test)," \t=")(1);
n= -strlen(token);
for (j=-1 ; j>n ; --j) if (strpart(token,j:j)=="/") break;
if (strpart(token,1:j)==Y_HOME) return 1;
lines(test)= "MAKE_TEMPLATE = "+Y_HOME+strpart(token,j+1:0);
} else {
token= token(1,);
test= where((token=="exec_prefix") | (token=="Y_HOME"));
if (numberof(test)) {
obsolete= sum(len)+test(1);
lines(test)= "#"+lines(test);
i0= i;
}
}
}
if (obsolete) {
if (i0!=i) {
token= strtok(lines," \t=")(1,);
test= where((token=="exec_prefix") | (token=="Y_HOME"));
if (numberof(test)) lines(test)= "#"+lines(test);
}
test= where(strmatch(lines,"-END-CODE-SPECIFIC-SECTION-"));
if (numberof(test)) {
test= test(1);
if (test<3) {
if (i>1) {
list(i-1)= (*list(i-1))(1:-1);
lines= [string(0)];
} else {
/* this is not really a Makefile at all */
close, f;
rename, "Makefile", "Makefile.old";
return 0;
}
} else {
lines= lines(1:test-2);
}
/* since lines shortened, this will be final pass */
}
}
lines= lines(where(lines));
list(i)= &lines;
len(i)= numberof(lines);
if (numberof(lines)<100) break;
}
n= sum(len);
lines= n? array(string, n) : [];
for (i=1,j=0 ; j<n ; j+=len(i++)) {
if (!len(i)) continue;
lines(j+1:j+len(i))= *list(i);
}
list= len= [];
/* Makefile usable, but needs to be modified */
close, f;
rename, "Makefile", "Makefile.old";
if (obsolete) {
lines2= lines(obsolete:0);
if (obsolete>1) lines= lines(1:obsolete-1);
else lines= [];
grow, lines, ["MAKE_TEMPLATE = "+Y_HOME+"Maketmpl"],
lines2, ["# to set MAKE_TEMPLATE properly, run yorick -batch make.i",
"include $(MAKE_TEMPLATE)"];
}
write, create("Makefile"), format="%s\n", lines;
return 1;
}
func new_makefile (code_name, new_pkgs, old_pkgs)
{
n= numberof(new_pkgs);
if (!n) {
new_pkgs= code_name+".i";
n= 1;
}
srcs= lib= deplibs= s= d= [];
nowrap= 0;
for (i=1 ; i<=n ; ++i) {
f= open(new_pkgs(i), "r", 1);
if (is_void(f)) { f=new_pkgs(i); goto oops; }
instrucs= get_keys(new_pkgs(i), f, s, l, d);
if (is_void(lib))
lib= l;
else if (!is_void(l) && anyof(lib!=l))
error, "new pacakges must all specify same LIB in MAKE-INSTRUCTIONS";
grow, srcs, s;
grow, deplibs, d;
list= where(instrucs(1,)=="NO-WRAPPERS");
if (numberof(list)) nowrap++;
}
deplibs= grow(lib, deplibs);
if (numberof(lib)>1)
error, "new packages may specify at most one LIB in MAKE-INSTRUCTIONS";
else if (numberof(lib)==1)
lib= lib(1);
code_library= lib;
nsrcs= numberof(srcs);
if (nowrap==n) nowrap= "";
else nowrap= " ywrap.o";
n= numberof(old_pkgs);
for (i=1 ; i<=n ; ++i) {
/* note: . is assumed to be Y_LAUNCH */
f= find_file(old_pkgs(i),
["./",Y_SITE+"i0/",Y_SITE+"contrib/"]);
if (is_void(f)) { f=old_pkgs(i); goto oops; }
get_keys, old_pkgs(i), f, s, l, d;
if (is_void(l) && old_pkgs(i)!="matrix.i" && old_pkgs(i)!="fft.i")
error,"package "+old_pkgs(i)+" specifies no LIB in MAKE-INSTRUCTIONS";
grow, srcs, s;
grow, deplibs, l, d;
}
srcs= strtok(srcs,".");
ext= srcs(2,);
srcs= srcs(1,);
list= where((ext=="f") | (ext=="F"));
fortran= (numberof(list)!=0);
objs= srcs(1:nsrcs)+".o";
if (!is_void(deplibs))
deplibs= "-l"+undup_names(deplibs);
if (open("Makefile","r",1)) rename, "Makefile", "Makefile.old";
f= create("Makefile");
write,f,format="# Makefile for %s\n",code_name;
write,f,format="# generated by make.i %s\n\n",timestamp();
write,f,format="%s\n",
"######################################################################";
write,f,format="# %s\n\n","First section is definitions for Maketmpl";
write,f,format="MAKE_TEMPLATE = %s%s\n\n",Y_HOME,"Maketmpl";
write,f,format="C_OPTIMIZE = %s\nLD_OPTIMIZE = $(C_OPTIMIZE)\n","-O";
if (fortran) write,f,format="F_OPTIMIZE = %s\n","-O";
if (!is_void(code_library)) {
write,f,format="\nCODE_NAME = %s\n", code_name;
write,f,format="CODE_LIBRARY = lib%s.a\n", code_library;
write,f,format="NON_SHARABLE = %s\n", "unused";
} else {
write,f,format="\nNON_SHARABLE = %s\n", code_name;
write,f,format="CODE_NAME = %s\n", "unused";
write,f,format="CODE_LIBRARY = %s\n", "unused2";
}
write,f,format="YWRAP_O =%s\n\n",nowrap;
objlist= ["OBJS ="];
tot= strlen(objlist(1));
for (i=i0=1 ; i<=numberof(objs) ; ++i) {
obj= objs(i);
len= strlen(obj);
if (tot+len+1 > 70) {
objlist(i0)+= " \\";
grow, objlist, [" "];
tot= strlen(objlist(0));
++i0;
}
objlist(i0)+= " "+obj;
tot+= len+1;
}
write,f,format="%s",objlist;
lib= "";
for (i=1 ; i<=numberof(deplibs) ; ++i) lib+= " "+deplibs(i);
write,f,format="\nPKG_LIBS =%s\n",lib;
if (is_void(code_library))
write,f,format="PKG_OBJS = %s\n","$(OBJS) $(YWRAP_O)"
pkg= "";
for (i=1 ; i<=numberof(new_pkgs) ; ++i) pkg+= " "+new_pkgs(i);
write,f,format="\nY_INCLUDE =%s\n",pkg;
pkg= "";
for (i=1 ; i<=numberof(old_pkgs) ; ++i) pkg+= " "+old_pkgs(i);
write,f,format="Y_OTHERS =%s\n\n",pkg;
lib= fortran? " $(FORTRAN_LIBS)" : "";
write,f,format="SYS_LIBS =%s\n", lib;
if (fortran) write,f,format="FORTRAN_STYLE =%s\n", " $(WKS_FORTRAN)";
write,f,format="\nCLEAN_UP = %s\n\n",code_name;
write,f,format="%s\n",
"######################################################################";
write,f,format="# %s\n\n","Second section is targets for new package/code";
if (is_void(code_library)) lib= "$(NON_SHARABLE)";
else lib= "$(CODE_LIBRARY) $(CODE_NAME)";
write,f,format="all:: %s\n\n", lib;
write,f,format="%s\n%s\n%s\n%s\n%s\n\n",
"# Add header dependencies or special compile instructions here, e.g.-",
"#my_code1.o: my_code1.h my_code.h",
"#my_code2.o: my_code2.c my_code.h",
"#\t$(CC) $(CFLAGS) -DSPECIAL_SWITCH -c my_code2.c",
"#my_code3.o: my_code3.h my_code1.h my_code.h";
write,f,format="%s\n",
"######################################################################";
write,f,format="\n%s\n","include $(MAKE_TEMPLATE)";
close,f;
return;
oops:
write, "new packages must be in current directory";
write, "old packages must be in "+Y_SITE+"{i0,contrib}";
error, "unable to find package: "+f;
}
func undup_names (names)
{
/* remove duplicates from a list of names (or numbers) */
if (numberof(names)<2) return names;
require, "msort.i";
order= msort(names);
sorted= names(order);
list= where(sorted(1:-1)==sorted(2:0));
if (numberof(list)) {
names(order(list))= structof(names)(0);
names= names(where(names));
}
return names;
}
func get_keys (name, f, &srcs, &lib, &deplibs)
{
instrucs= get_instructions(f);
if (is_void(instrucs))
error, "no MAKE-INSTRUCTIONS comment found in "+name;
srcs= get_list(instrucs, "SRCS");
if (is_void(srcs))
error, "no SRCS in MAKE-INSTRUCTIONS comment found in "+name;
lib= get_list(instrucs, "LIB");
deplibs= get_list(instrucs, "DEPLIBS");
return instrucs;
}
func get_list (instrucs, keyword)
{
/* get keyword= from instruction lines returned by get_instructions
* return value is array of token strings
* -- allow for \ continuation of long lines */
list= where(instrucs(,1)==keyword);
if (!numberof(list)) return [];
i= list(1);
instrucs= instrucs(i:0,2);
list= array(pointer, numberof(instrucs));
len= array(0, numberof(list));
line= tokenize_line(instrucs(1), " \t=");
if (numberof(line)<2) return [];
line= line(2:0);
for (i=1 ; numberof(line)>=1 ; ++i) {
cont= (line(0)=="\\");
len(i)= n= numberof(line)-cont;
if (n) list(i)= &line(1:n);
if (!cont || i+1>=numberof(instrucs)) break;
line= tokenize_line(instrucs(i+1), " \t=");
}
n= sum(len);
if (!n) return [];
line= array(string, n);
for (i=1,j=0 ; j<n ; j+=len(i++)) {
if (!len(i)) continue;
line(j+1:j+len(i))= *list(i);
}
return line;
}
func tokenize_line (line, delim)
{
len= strlen(line);
if (!len) return [];
list= array(string, len);
len= 0;
do {
token= strtok(line, delim);
line= token(2);
token= token(1);
if (!token) break;
list(++len)= token;
} while (line);
if (!len) return [];
return list(1:len);
}
func get_instructions (f)
{
/* locate MAKE-INSTRUCTIONS comment and return 2xnlines
* array of [[first token, full line]] */
if (is_void(f)) return [];
do {
lines= rdline(f, 30);
token= strtok(lines);
list= where(token(1,)=="/*");
if (numberof(list)) {
starts= token(2,list);
list= list(where(strtok(starts)(1,)=="MAKE-INSTRUCTIONS"));
if (numberof(list)) {
list= list(1);
if (list>20) {
if (lines(0)) grow, lines, rdline(f, 10);
else grow, lines, array(string, 10);
}
lines= lines(list+1:list+10);
token= strtok(lines," \t=")(1,);
list= where(token=="*/");
if (!numberof(list) || list(1)<2) return [];
list= list(1)-1;
return [token(1:list), lines(1:list)];
}
}
} while (lines(0));
return [];
}
func find_file (name, path)
{
/* open file, which may be anywhere on optional supplied path */
if (is_void(path) ||
anyof(strpart(name,1:1)==["/","~","$"])) return open(name, "r", 1);
list= where(strpart(path,0:0)!="/");
if (numberof(list)) {
if (numberof(path)>1) path(list)+= "/";
else path+= "/";
}
for (i=1 ; i<numberof(path) ; ++i) {
f= open(path(i)+name, "r", 1);
if (!is_void(f)) return f;
}
return [];
}
if (batch()) {
command_line= get_argv();
if (numberof(command_line)>1) command_line= command_line(2:0);
else command_line= [];
make, command_line;
quit;
}
|
