Better ANSI C compatibility and portability:
+ Addition of function prototypes and include files. + Change function definitions to ANSI C style. + Initial support for CMake
This commit is contained in:
carl
parent
10717cc791
commit
910643ccbb
23
util/make/CMakeLists.txt
Normal file
23
util/make/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
cmake_minimum_required (VERSION 2.6)
|
||||
project (ack-make)
|
||||
|
||||
set(SRC
|
||||
check.c
|
||||
input.c
|
||||
macro.c
|
||||
make.c
|
||||
main.c
|
||||
reader.c
|
||||
rules.c
|
||||
h.h
|
||||
)
|
||||
|
||||
# The following should be added if utime.h and unistd.h are
|
||||
# available.
|
||||
|
||||
# add_definitions(-Dunix)
|
||||
|
||||
add_executable(${PROJECT_NAME} ${SRC})
|
||||
|
||||
install(TARGETS ${PROJECT_NAME} DESTINATION bin)
|
||||
|
||||
|
|
@ -40,3 +40,6 @@ xi) $? added. (see UNIX manual)
|
|||
Hacked further by Ceriel Jacobs to make it work better. Use this "make" to
|
||||
install ACK under Microsoft Xenix V3.2. Some of the makefiles are just too
|
||||
big for the Xenix "make". Strange, they work on a PDP-11 ...
|
||||
|
||||
Made it almost ISO C90 and POSIX portable by Carl Eric Codere, and
|
||||
also made it safer by using correct datatypes on some library calls.
|
||||
|
|
|
|||
|
|
@ -7,13 +7,32 @@
|
|||
#include <stdio.h>
|
||||
#include "h.h"
|
||||
|
||||
/*
|
||||
* Recursive routine that does the actual checking.
|
||||
*/
|
||||
static void check(struct name *np)
|
||||
{
|
||||
register struct depend * dp;
|
||||
register struct line * lp;
|
||||
|
||||
if (np->n_flag & N_MARK)
|
||||
fatal("Circular dependency from %s", np->n_name);
|
||||
|
||||
np->n_flag |= N_MARK;
|
||||
|
||||
for (lp = np->n_line; lp; lp = lp->l_next)
|
||||
for (dp = lp->l_dep; dp; dp = dp->d_next)
|
||||
check(dp->d_name);
|
||||
|
||||
np->n_flag &= (uchar)~N_MARK;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Prints out the structures as defined in memory. Good for check
|
||||
* that you make file does what you want (and for debugging make).
|
||||
*/
|
||||
void
|
||||
prt()
|
||||
void prt(void)
|
||||
{
|
||||
register struct name * np;
|
||||
register struct depend * dp;
|
||||
|
|
@ -21,7 +40,6 @@ prt()
|
|||
register struct cmd * cp;
|
||||
register struct macro * mp;
|
||||
|
||||
|
||||
for (mp = macrohead; mp; mp = mp->m_next)
|
||||
fprintf(stderr, "%s = %s\n", mp->m_name, mp->m_val);
|
||||
|
||||
|
|
@ -43,40 +61,12 @@ prt()
|
|||
fputc('\n', stderr);
|
||||
|
||||
for (cp = lp->l_cmd; cp; cp = cp->c_next)
|
||||
#ifdef os9
|
||||
fprintf(stderr, "- %s\n", cp->c_cmd);
|
||||
#else
|
||||
fprintf(stderr, "-\t%s\n", cp->c_cmd);
|
||||
#endif
|
||||
fputc('\n', stderr);
|
||||
}
|
||||
fputc('\n', stderr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Recursive routine that does the actual checking.
|
||||
*/
|
||||
void
|
||||
check(np)
|
||||
struct name * np;
|
||||
{
|
||||
register struct depend * dp;
|
||||
register struct line * lp;
|
||||
|
||||
|
||||
if (np->n_flag & N_MARK)
|
||||
fatal("Circular dependency from %s", np->n_name);
|
||||
|
||||
np->n_flag |= N_MARK;
|
||||
|
||||
for (lp = np->n_line; lp; lp = lp->l_next)
|
||||
for (dp = lp->l_dep; dp; dp = dp->d_next)
|
||||
check(dp->d_name);
|
||||
|
||||
np->n_flag &= ~N_MARK;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -86,28 +76,23 @@ struct name * np;
|
|||
* b: a
|
||||
* is a circular dep
|
||||
*/
|
||||
void
|
||||
circh()
|
||||
void circh(void)
|
||||
{
|
||||
register struct name * np;
|
||||
|
||||
|
||||
for (np = namehead.n_next; np; np = np->n_next)
|
||||
check(np);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Check the target .PRECIOUS, and mark its dependentd as precious
|
||||
*/
|
||||
void
|
||||
precious()
|
||||
void precious(void)
|
||||
{
|
||||
register struct depend * dp;
|
||||
register struct line * lp;
|
||||
register struct name * np;
|
||||
|
||||
|
||||
if (!((np = newname(".PRECIOUS"))->n_flag & N_TARG))
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,29 +6,17 @@
|
|||
|
||||
|
||||
#ifndef uchar
|
||||
#ifdef os9
|
||||
#define uchar char
|
||||
#define void int
|
||||
#define fputc putc
|
||||
#else
|
||||
#define uchar unsigned char
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <time.h>
|
||||
|
||||
#define bool int
|
||||
#define time_t long
|
||||
#define TRUE (1)
|
||||
#define FALSE (0)
|
||||
#define max(a,b) ((a)>(b)?(a):(b))
|
||||
|
||||
#define DEFN1 "makefile" /* Default names */
|
||||
#ifdef unix
|
||||
#define DEFN2 "Makefile"
|
||||
#endif
|
||||
#ifdef eon
|
||||
#define DEFN2 "Makefile"
|
||||
#endif
|
||||
/* os9 is case insensitive */
|
||||
|
||||
#define LZ (2048) /* Line size */
|
||||
|
||||
|
|
@ -116,30 +104,24 @@ extern char str1[];
|
|||
extern char str2[];
|
||||
extern int lineno;
|
||||
|
||||
char * fgets();
|
||||
char * index();
|
||||
char * rindex();
|
||||
char * malloc();
|
||||
char * strcpy();
|
||||
char * strcat();
|
||||
extern int errno;
|
||||
|
||||
void circh();
|
||||
char * getmacro();
|
||||
struct macro * setmacro();
|
||||
void input();
|
||||
void error();
|
||||
void expand();
|
||||
void fatal();
|
||||
int make();
|
||||
void modtime();
|
||||
struct name * newname();
|
||||
struct depend * newdep();
|
||||
struct cmd * newcmd();
|
||||
void newline();
|
||||
void prt();
|
||||
char * suffix();
|
||||
void touch();
|
||||
void makerules();
|
||||
char * gettok();
|
||||
void precious();
|
||||
void circh(void);
|
||||
char * getmacro(char* name);
|
||||
struct macro * setmacro(char* name, char* val, int prio);
|
||||
void input(FILE *fd);
|
||||
void error(char *msg, char* a1);
|
||||
void expand(char *str);
|
||||
void fatal(char* msg, char* value);
|
||||
bool dyndep(struct name *np);
|
||||
int make(struct name *np, int level);
|
||||
void modtime(struct name *np);
|
||||
struct name *newname(char *name);
|
||||
struct depend *newdep(struct name *np, struct depend *dp);
|
||||
struct cmd *newcmd(char *str, struct cmd *cp);
|
||||
void newline(struct name *np, struct depend *dp, struct cmd *cp, int flag);
|
||||
void prt(void);
|
||||
char *suffix(char *name);
|
||||
void touch(struct name *np);
|
||||
void makerules(void);
|
||||
char *gettok(char **ptr);
|
||||
void precious(void);
|
||||
bool mgetline(char* str, FILE* fd);
|
||||
|
|
|
|||
|
|
@ -4,77 +4,64 @@
|
|||
* $Header$
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include "h.h"
|
||||
|
||||
|
||||
struct name namehead;
|
||||
struct name * firstname;
|
||||
|
||||
char str1[LZ]; /* General store */
|
||||
char str2[LZ];
|
||||
|
||||
|
||||
/*
|
||||
* Intern a name. Return a pointer to the name struct
|
||||
*/
|
||||
struct name *
|
||||
newname(name)
|
||||
char * name;
|
||||
struct name *newname(char *name)
|
||||
{
|
||||
|
||||
register struct name * rp;
|
||||
register struct name * rrp;
|
||||
register char * cp;
|
||||
|
||||
|
||||
for
|
||||
(
|
||||
rp = namehead.n_next, rrp = &namehead;
|
||||
rp;
|
||||
rp = rp->n_next, rrp = rrp->n_next
|
||||
)
|
||||
for (rp = namehead.n_next, rrp = &namehead; rp;
|
||||
rp = rp->n_next, rrp = rrp->n_next)
|
||||
if (strcmp(name, rp->n_name) == 0)
|
||||
return rp;
|
||||
|
||||
if ((rp = (struct name *)malloc(sizeof (struct name)))
|
||||
== (struct name *)0)
|
||||
fatal("No memory for name");
|
||||
if ((rp = (struct name *) malloc(sizeof(struct name))) == (struct name *) 0)
|
||||
fatal("No memory for name",NULL);
|
||||
rrp->n_next = rp;
|
||||
rp->n_next = (struct name *)0;
|
||||
if ((cp = malloc((unsigned)(strlen(name)+1))) == (char *)0)
|
||||
fatal("No memory for name");
|
||||
rp->n_next = (struct name *) 0;
|
||||
if ((cp = malloc((unsigned) (strlen(name) + 1))) == (char *) 0)
|
||||
fatal("No memory for name",NULL);
|
||||
strcpy(cp, name);
|
||||
rp->n_name = cp;
|
||||
rp->n_line = (struct line *)0;
|
||||
rp->n_time = (time_t)0;
|
||||
rp->n_line = (struct line *) 0;
|
||||
rp->n_time = (time_t) 0;
|
||||
rp->n_flag = 0;
|
||||
|
||||
return rp;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Add a dependant to the end of the supplied list of dependants.
|
||||
* Return the new head pointer for that list.
|
||||
*/
|
||||
struct depend *
|
||||
newdep(np, dp)
|
||||
struct name * np;
|
||||
struct depend * dp;
|
||||
struct depend *newdep(struct name *np, struct depend *dp)
|
||||
{
|
||||
register struct depend * rp;
|
||||
register struct depend * rrp;
|
||||
|
||||
|
||||
if ((rp = (struct depend *)malloc(sizeof (struct depend)))
|
||||
== (struct depend *)0)
|
||||
fatal("No memory for dependant");
|
||||
rp->d_next = (struct depend *)0;
|
||||
if ((rp = (struct depend *) malloc(sizeof(struct depend)))
|
||||
== (struct depend *) 0)
|
||||
fatal("No memory for dependant",NULL);
|
||||
rp->d_next = (struct depend *) 0;
|
||||
rp->d_name = np;
|
||||
|
||||
if (dp == (struct depend *)0)
|
||||
if (dp == (struct depend *) 0)
|
||||
return rp;
|
||||
|
||||
for (rrp = dp; rrp->d_next; rrp = rrp->d_next)
|
||||
|
|
@ -85,22 +72,17 @@ struct depend * dp;
|
|||
return dp;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Add a command to the end of the supplied list of commands.
|
||||
* Return the new head pointer for that list.
|
||||
*/
|
||||
struct cmd *
|
||||
newcmd(str, cp)
|
||||
char * str;
|
||||
struct cmd * cp;
|
||||
struct cmd *newcmd(char *str, struct cmd *cp)
|
||||
{
|
||||
register struct cmd * rp;
|
||||
register struct cmd * rrp;
|
||||
register char * rcp;
|
||||
|
||||
|
||||
if (rcp = rindex(str, '\n'))
|
||||
if ((rcp = strrchr(str, '\n')))
|
||||
*rcp = '\0'; /* Loose newline */
|
||||
|
||||
while (isspace(*str))
|
||||
|
|
@ -109,16 +91,15 @@ struct cmd * cp;
|
|||
if (*str == '\0') /* If nothing left, the exit */
|
||||
return 0;
|
||||
|
||||
if ((rp = (struct cmd *)malloc(sizeof (struct cmd)))
|
||||
== (struct cmd *)0)
|
||||
fatal("No memory for command");
|
||||
rp->c_next = (struct cmd *)0;
|
||||
if ((rcp = malloc((unsigned)(strlen(str)+1))) == (char *)0)
|
||||
fatal("No memory for command");
|
||||
if ((rp = (struct cmd *) malloc(sizeof(struct cmd))) == (struct cmd *) 0)
|
||||
fatal("No memory for command",NULL);
|
||||
rp->c_next = (struct cmd *) 0;
|
||||
if ((rcp = malloc((unsigned) (strlen(str) + 1))) == (char *) 0)
|
||||
fatal("No memory for command",NULL);
|
||||
strcpy(rcp, str);
|
||||
rp->c_cmd = rcp;
|
||||
|
||||
if (cp == (struct cmd *)0)
|
||||
if (cp == (struct cmd *) 0)
|
||||
return rp;
|
||||
|
||||
for (rrp = cp; rrp->c_next; rrp = rrp->c_next)
|
||||
|
|
@ -129,7 +110,6 @@ struct cmd * cp;
|
|||
return cp;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Add a new 'line' of stuff to a target. This check to see
|
||||
* if commands already exist for the target. If flag is set,
|
||||
|
|
@ -144,43 +124,34 @@ struct cmd * cp;
|
|||
* Neither of these free the space used by dependents or commands,
|
||||
* since they could be used by another target.
|
||||
*/
|
||||
void
|
||||
newline(np, dp, cp, flag)
|
||||
struct name * np;
|
||||
struct depend * dp;
|
||||
struct cmd * cp;
|
||||
void newline(struct name *np, struct depend *dp, struct cmd *cp, int flag)
|
||||
{
|
||||
bool hascmds = FALSE; /* Target has commands */
|
||||
register struct line * rp;
|
||||
register struct line * rrp;
|
||||
|
||||
|
||||
/* Handle the .SUFFIXES case */
|
||||
if (! strcmp(np->n_name, ".SUFFIXES") && !dp && !cp)
|
||||
if (!strcmp(np->n_name, ".SUFFIXES") && !dp && !cp)
|
||||
{
|
||||
for (rp = np->n_line; rp; rp = rrp)
|
||||
{
|
||||
rrp = rp->l_next;
|
||||
free((char *)rp);
|
||||
free((char *) rp);
|
||||
}
|
||||
np->n_line = (struct line *)0;
|
||||
np->n_flag &= ~N_TARG;
|
||||
np->n_line = (struct line *) 0;
|
||||
np->n_flag &= (uchar)~N_TARG;
|
||||
return;
|
||||
}
|
||||
|
||||
/* This loop must happen since rrp is used later. */
|
||||
for
|
||||
(
|
||||
rp = np->n_line, rrp = (struct line *)0;
|
||||
rp;
|
||||
rrp = rp, rp = rp->l_next
|
||||
)
|
||||
for (rp = np->n_line, rrp = (struct line *) 0; rp;
|
||||
rrp = rp, rp = rp->l_next)
|
||||
if (rp->l_cmd)
|
||||
hascmds = TRUE;
|
||||
|
||||
if (hascmds && cp && !(np->n_flag & N_DOUBLE))
|
||||
/* Handle the implicit rules redefinition case */
|
||||
if (np->n_name[0] == '.' && dp == (struct depend *)0)
|
||||
if (np->n_name[0] == '.' && dp == (struct depend *) 0)
|
||||
{
|
||||
np->n_line->l_cmd = cp;
|
||||
return;
|
||||
|
|
@ -191,10 +162,9 @@ struct cmd * cp;
|
|||
if (!(np->n_flag & N_DOUBLE) != !flag) /* like xor */
|
||||
error("Inconsistent rules for target %s", np->n_name);
|
||||
|
||||
if ((rp = (struct line *)malloc(sizeof (struct line)))
|
||||
== (struct line *)0)
|
||||
fatal("No memory for line");
|
||||
rp->l_next = (struct line *)0;
|
||||
if ((rp = (struct line *) malloc(sizeof(struct line))) == (struct line *) 0)
|
||||
fatal("No memory for line",NULL);
|
||||
rp->l_next = (struct line *) 0;
|
||||
rp->l_dep = dp;
|
||||
rp->l_cmd = cp;
|
||||
|
||||
|
|
@ -208,14 +178,11 @@ struct cmd * cp;
|
|||
np->n_flag |= N_DOUBLE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Parse input from the makefile, and construct a tree structure
|
||||
* of it.
|
||||
*/
|
||||
void
|
||||
input(fd)
|
||||
FILE * fd;
|
||||
void input(FILE *fd)
|
||||
{
|
||||
char * p; /* General */
|
||||
char * q;
|
||||
|
|
@ -224,52 +191,47 @@ FILE * fd;
|
|||
struct cmd * cp;
|
||||
bool dbl;
|
||||
|
||||
|
||||
if (getline(str1, fd)) /* Read the first line */
|
||||
if (mgetline(str1, fd)) /* Read the first line */
|
||||
return;
|
||||
|
||||
for(;;)
|
||||
for (;;)
|
||||
{
|
||||
#ifdef os9
|
||||
if (*str1 == ' ') /* Rules without targets */
|
||||
#else
|
||||
if (*str1 == '\t') /* Rules without targets */
|
||||
#endif
|
||||
error("Rules not allowed here");
|
||||
error("Rules not allowed here", NULL );
|
||||
|
||||
p = str1;
|
||||
|
||||
while (isspace(*p)) /* Find first target */
|
||||
p++;
|
||||
|
||||
while (((q = index(p, '=')) != (char *)0) &&
|
||||
(p != q) && (q[-1] == '\\')) /* Find value */
|
||||
while (((q = strchr(p, '=')) != (char *) 0) && (p != q)
|
||||
&& (q[-1] == '\\')) /* Find value */
|
||||
{
|
||||
register char * a;
|
||||
|
||||
a = q - 1; /* Del \ chr; move rest back */
|
||||
p = q;
|
||||
while(*a++ = *q++)
|
||||
while ((*a++ = *q++))
|
||||
;
|
||||
}
|
||||
|
||||
if (q != (char *)0)
|
||||
if (q != (char *) 0)
|
||||
{
|
||||
register char * a;
|
||||
|
||||
*q++ = '\0'; /* Separate name and val */
|
||||
while (isspace(*q))
|
||||
q++;
|
||||
if (p = rindex(q, '\n'))
|
||||
if ((p = strrchr(q, '\n')))
|
||||
*p = '\0';
|
||||
|
||||
p = str1;
|
||||
if ((a = gettok(&p)) == (char *)0)
|
||||
error("No macro name");
|
||||
if ((a = gettok(&p)) == (char *) 0)
|
||||
error("No macro name", NULL );
|
||||
|
||||
setmacro(a, q, 2);
|
||||
|
||||
if (getline(str1, fd))
|
||||
if (mgetline(str1, fd))
|
||||
return;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -277,19 +239,19 @@ FILE * fd;
|
|||
expand(str1);
|
||||
p = str1;
|
||||
|
||||
while (((q = index(p, ':')) != (char *)0) &&
|
||||
(p != q) && (q[-1] == '\\')) /* Find dependents */
|
||||
while (((q = strchr(p, ':')) != (char *) 0) && (p != q)
|
||||
&& (q[-1] == '\\')) /* Find dependents */
|
||||
{
|
||||
register char * a;
|
||||
|
||||
a = q - 1; /* Del \ chr; move rest back */
|
||||
p = q;
|
||||
while(*a++ = *q++)
|
||||
while ((*a++ = *q++))
|
||||
;
|
||||
}
|
||||
|
||||
if (q == (char *)0)
|
||||
error("No targets provided");
|
||||
if (q == (char *) 0)
|
||||
error("No targets provided", NULL );
|
||||
|
||||
*q++ = '\0'; /* Separate targets and dependents */
|
||||
|
||||
|
|
@ -301,7 +263,7 @@ FILE * fd;
|
|||
else
|
||||
dbl = 0;
|
||||
|
||||
for (dp = (struct depend *)0; ((p = gettok(&q)) != (char *)0);)
|
||||
for (dp = (struct depend *) 0; ((p = gettok(&q)) != (char *) 0);)
|
||||
/* get list of dep's */
|
||||
{
|
||||
np = newname(p); /* Intern name */
|
||||
|
|
@ -311,22 +273,18 @@ FILE * fd;
|
|||
*((q = str1) + strlen(str1) + 1) = '\0';
|
||||
/* Need two nulls for gettok (Remember separation) */
|
||||
|
||||
cp = (struct cmd *)0;
|
||||
if (getline(str2, fd) == FALSE) /* Get commands */
|
||||
cp = (struct cmd *) 0;
|
||||
if (mgetline(str2, fd) == FALSE) /* Get commands */
|
||||
{
|
||||
#ifdef os9
|
||||
while (*str2 == ' ')
|
||||
#else
|
||||
while (*str2 == '\t')
|
||||
#endif
|
||||
{
|
||||
cp = newcmd(&str2[0], cp);
|
||||
if (getline(str2, fd))
|
||||
if (mgetline(str2, fd))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
while ((p = gettok(&q)) != (char *)0) /* Get list of targ's */
|
||||
while ((p = gettok(&q)) != (char *) 0) /* Get list of targ's */
|
||||
{
|
||||
np = newname(p); /* Intern name */
|
||||
newline(np, dp, cp, dbl);
|
||||
|
|
|
|||
|
|
@ -5,15 +5,16 @@
|
|||
*/
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "h.h"
|
||||
|
||||
|
||||
struct macro * macrohead;
|
||||
|
||||
|
||||
struct macro *
|
||||
getmp(name)
|
||||
char * name;
|
||||
static struct macro *getmp(char *name)
|
||||
{
|
||||
register struct macro * rp;
|
||||
|
||||
|
|
@ -24,23 +25,18 @@ char * name;
|
|||
}
|
||||
|
||||
|
||||
char *
|
||||
getmacro(name)
|
||||
char * name;
|
||||
char * getmacro(char* name)
|
||||
{
|
||||
struct macro * mp;
|
||||
|
||||
if (mp = getmp(name))
|
||||
if ((mp = getmp(name)))
|
||||
return mp->m_val;
|
||||
else
|
||||
return "";
|
||||
}
|
||||
|
||||
|
||||
struct macro *
|
||||
setmacro(name, val, prio)
|
||||
char * name;
|
||||
char * val;
|
||||
struct macro * setmacro(char* name, char* val, int prio)
|
||||
{
|
||||
register struct macro * rp;
|
||||
register char * cp;
|
||||
|
|
@ -60,23 +56,23 @@ char * val;
|
|||
{
|
||||
if ((rp = (struct macro *)malloc(sizeof (struct macro)))
|
||||
== (struct macro *)0)
|
||||
fatal("No memory for macro");
|
||||
fatal("No memory for macro",NULL);
|
||||
|
||||
rp->m_next = macrohead;
|
||||
macrohead = rp;
|
||||
rp->m_flag = FALSE;
|
||||
|
||||
if ((cp = malloc((unsigned)(strlen(name)+1))) == (char *)0)
|
||||
fatal("No memory for macro");
|
||||
fatal("No memory for macro",NULL);
|
||||
strcpy(cp, name);
|
||||
rp->m_name = cp;
|
||||
}
|
||||
|
||||
if ((cp = malloc((unsigned)(strlen(val)+1))) == (char *)0)
|
||||
fatal("No memory for macro");
|
||||
fatal("No memory for macro",NULL);
|
||||
strcpy(cp, val); /* Copy in new value */
|
||||
rp->m_val = cp;
|
||||
rp->m_prio = prio;
|
||||
rp->m_prio = (uchar)prio;
|
||||
|
||||
return rp;
|
||||
}
|
||||
|
|
@ -86,12 +82,7 @@ char * val;
|
|||
/*
|
||||
* Do the dirty work for expand
|
||||
*/
|
||||
void
|
||||
doexp(to, from, len, buf)
|
||||
char ** to;
|
||||
char * from;
|
||||
int * len;
|
||||
char * buf;
|
||||
static void doexp(char **to, char* from, int* len, char* buf)
|
||||
{
|
||||
register char * rp;
|
||||
register char * p;
|
||||
|
|
@ -140,7 +131,7 @@ char * buf;
|
|||
mp->m_flag = FALSE;
|
||||
}
|
||||
if (*len <= 0)
|
||||
error("Expanded line too line");
|
||||
error("Expanded line too line", NULL);
|
||||
}
|
||||
*p = '\0';
|
||||
*to = p;
|
||||
|
|
@ -150,9 +141,7 @@ char * buf;
|
|||
/*
|
||||
* Expand any macros in str.
|
||||
*/
|
||||
void
|
||||
expand(str)
|
||||
char * str;
|
||||
void expand(char *str)
|
||||
{
|
||||
char *a;
|
||||
static char b[MBUFSIZ]; /* temp storage for macroname */
|
||||
|
|
@ -160,7 +149,7 @@ char * str;
|
|||
int len = LZ-1;
|
||||
|
||||
a = malloc((unsigned)(strlen(str)+1));
|
||||
if (!a) fatal("No memory for expand");
|
||||
if (!a) fatal("No memory for expand",NULL);
|
||||
strcpy(a, str);
|
||||
doexp(&p, a, &len, b);
|
||||
free(a);
|
||||
|
|
|
|||
101
util/make/main.c
101
util/make/main.c
|
|
@ -18,24 +18,10 @@
|
|||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "h.h"
|
||||
|
||||
#ifdef unix
|
||||
#include <errno.h>
|
||||
#endif
|
||||
#ifdef eon
|
||||
#include <sys/err.h>
|
||||
#endif
|
||||
#ifdef os9
|
||||
#include <errno.h>
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef eon
|
||||
#define MEMSPACE (16384)
|
||||
#endif
|
||||
|
||||
|
||||
char * myname;
|
||||
char * makefile; /* The make file */
|
||||
#ifdef eon
|
||||
|
|
@ -51,11 +37,10 @@ bool rules = TRUE; /* Use inbuilt rules */
|
|||
bool dotouch = FALSE;/* Touch files instead of making */
|
||||
bool quest = FALSE; /* Question up-to-dateness of file */
|
||||
|
||||
static void usage(void);
|
||||
|
||||
void
|
||||
main(argc, argv)
|
||||
int argc;
|
||||
char ** argv;
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
register char * p; /* For argument processing */
|
||||
int estat = 0; /* For question */
|
||||
|
|
@ -80,17 +65,6 @@ char ** argv;
|
|||
case 'f': /* Alternate file name */
|
||||
fflag = 1;
|
||||
break;
|
||||
#ifdef eon
|
||||
case 'm': /* Change space requirements */
|
||||
if (*++p == '\0')
|
||||
{
|
||||
if (argc-- <= 0)
|
||||
usage();
|
||||
p = *argv++;
|
||||
}
|
||||
memspace = atoi(p);
|
||||
goto end_of_args;
|
||||
#endif
|
||||
case 'n': /* Pretend mode */
|
||||
domake = FALSE;
|
||||
break;
|
||||
|
|
@ -134,42 +108,26 @@ char ** argv;
|
|||
argv = nargv - nargc;
|
||||
argc = nargc;
|
||||
|
||||
#ifdef eon
|
||||
if (initalloc(memspace) == 0xffff) /* Must get memory for alloc */
|
||||
fatal("Cannot initalloc memory");
|
||||
#endif
|
||||
|
||||
if (makefile && strcmp(makefile, "-") == 0) /* Can use stdin as makefile */
|
||||
ifd = stdin;
|
||||
else
|
||||
if (!makefile) /* If no file, then use default */
|
||||
{
|
||||
if ((ifd = fopen(DEFN1, "r")) == (FILE *)0)
|
||||
#ifdef eon
|
||||
if (errno != ER_NOTF)
|
||||
fatal("Can't open %s; error %02x", DEFN1, errno);
|
||||
#endif
|
||||
#ifdef unix
|
||||
if (errno != ENOENT)
|
||||
fatal("Can't open %s; error %02x", DEFN1, errno);
|
||||
#endif
|
||||
#ifndef os9
|
||||
if ((ifd == (FILE *)0)
|
||||
&& ((ifd = fopen(DEFN2, "r")) == (FILE *)0))
|
||||
if ((ifd = fopen(DEFN1, "r")) == NULL)
|
||||
if ((ifd == NULL)
|
||||
&& ((ifd = fopen(DEFN2, "r")) == NULL))
|
||||
fatal("Can't open %s", DEFN2);
|
||||
#else
|
||||
fatal("Can't open %s", DEFN1);
|
||||
#endif
|
||||
}
|
||||
else
|
||||
if ((ifd = fopen(makefile, "r")) == (FILE *)0)
|
||||
if ((ifd = fopen(makefile, "r")) == NULL)
|
||||
fatal("Can't open %s", makefile);
|
||||
|
||||
makerules();
|
||||
|
||||
setmacro("$", "$", 4);
|
||||
|
||||
while (argc && (p = index(*argv, '=')))
|
||||
while (argc && (p = strchr(*argv, '=')))
|
||||
{
|
||||
char c;
|
||||
|
||||
|
|
@ -200,7 +158,7 @@ char ** argv;
|
|||
precious();
|
||||
|
||||
if (!firstname)
|
||||
fatal("No targets defined");
|
||||
fatal("No targets defined",NULL);
|
||||
|
||||
circh(); /* Check circles in target definitions */
|
||||
|
||||
|
|
@ -217,10 +175,11 @@ char ** argv;
|
|||
exit(estat);
|
||||
else
|
||||
exit(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
usage()
|
||||
static void usage(void)
|
||||
{
|
||||
fprintf(stderr, "Usage: %s [-f makefile] [-inpqrst] [macro=val ...] [target(s) ...]\n", myname);
|
||||
exit(1);
|
||||
|
|
@ -228,34 +187,18 @@ usage()
|
|||
|
||||
|
||||
/*VARARGS1*/
|
||||
void
|
||||
fatal(msg, a1, a2, a3, a4, a5, a6)
|
||||
char *msg;
|
||||
void fatal(char *msg, char* value)
|
||||
{
|
||||
if (value != NULL)
|
||||
{
|
||||
fprintf(stderr, "%s: ", myname);
|
||||
fprintf(stderr, msg, a1, a2, a3, a4, a5, a6);
|
||||
fprintf(stderr, msg, value);
|
||||
} else
|
||||
{
|
||||
fprintf(stderr, "%s: ", myname);
|
||||
fprintf(stderr, msg);
|
||||
}
|
||||
fputc('\n', stderr);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
char *
|
||||
index(s, c)
|
||||
register char *s, c;
|
||||
{
|
||||
while (*s)
|
||||
if (*s++ == c)
|
||||
return --s;
|
||||
return (char *)0;
|
||||
}
|
||||
|
||||
char *
|
||||
rindex(str, chr)
|
||||
register char *str, chr;
|
||||
{
|
||||
register char *retptr = 0;
|
||||
|
||||
while (*str)
|
||||
if (*str++ == chr)
|
||||
retptr = &str[-1];
|
||||
return retptr;
|
||||
}
|
||||
|
|
|
|||
306
util/make/make.c
306
util/make/make.c
|
|
@ -5,24 +5,38 @@
|
|||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#ifdef unix
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <errno.h>
|
||||
/* UNIX specific */
|
||||
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)))
|
||||
#ifndef unix
|
||||
#define unix
|
||||
#endif
|
||||
#ifdef eon
|
||||
#include <sys/stat.h>
|
||||
#include <sys/err.h>
|
||||
#endif
|
||||
#ifdef os9
|
||||
#include <time.h>
|
||||
#include <os9.h>
|
||||
#include <modes.h>
|
||||
#include <direct.h>
|
||||
#include <errno.h>
|
||||
|
||||
#if defined(__MINGW32__) || defined(__MINGW64__)
|
||||
#ifndef unix
|
||||
#define unix
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#ifdef unix
|
||||
#include <unistd.h>
|
||||
#include <utime.h>
|
||||
#endif
|
||||
#include "h.h"
|
||||
|
||||
void docmds(struct name *np);
|
||||
|
||||
#ifndef max
|
||||
#define max(a,b) ((a)>(b)?(a):(b))
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -31,45 +45,16 @@
|
|||
* async command, used by the debugger (ugg).
|
||||
* [exec on eon is like a fork+exec on unix]
|
||||
*/
|
||||
int
|
||||
dosh(string, shell)
|
||||
char * string;
|
||||
char * shell;
|
||||
static int dosh(char *string, char *shell)
|
||||
{
|
||||
int number;
|
||||
|
||||
#ifdef unix
|
||||
return system(string);
|
||||
#endif
|
||||
#ifdef eon
|
||||
return ((number = execl(shell, shell,"-c", string, 0)) == -1) ?
|
||||
-1: /* couldn't start the shell */
|
||||
wait(number); /* return its exit status */
|
||||
#endif
|
||||
#ifdef os9
|
||||
int status, pid;
|
||||
|
||||
strcat(string, "\n");
|
||||
if ((number = os9fork(shell, strlen(string), string, 0, 0, 0)) == -1)
|
||||
return -1; /* Couldn't start a shell */
|
||||
do
|
||||
{
|
||||
if ((pid = wait(&status)) == -1)
|
||||
return -1; /* child already died!?!? */
|
||||
} while (pid != number);
|
||||
|
||||
return status;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Do commands to make a target
|
||||
*/
|
||||
void
|
||||
docmds1(np, lp)
|
||||
struct name * np;
|
||||
struct line * lp;
|
||||
static void docmds1(struct name *np, struct line *lp)
|
||||
{
|
||||
bool ssilent;
|
||||
bool signore;
|
||||
|
|
@ -81,16 +66,9 @@ struct line * lp;
|
|||
|
||||
|
||||
if (*(shell = getmacro("SHELL")) == '\0')
|
||||
#ifdef eon
|
||||
shell = ":bin/esh";
|
||||
#endif
|
||||
#ifdef unix
|
||||
shell = "/bin/sh";
|
||||
#endif
|
||||
#ifdef os9
|
||||
shell = "shell";
|
||||
#endif
|
||||
|
||||
for (cp = lp->l_cmd; cp; cp = cp->c_next)
|
||||
{
|
||||
strcpy(str1, cp->c_cmd);
|
||||
|
|
@ -144,7 +122,7 @@ struct line * lp;
|
|||
{
|
||||
putchar('\n');
|
||||
if (!(np->n_flag & N_PREC))
|
||||
if (unlink(np->n_name) == 0)
|
||||
if (remove(np->n_name) == 0)
|
||||
printf("%s: '%s' removed.\n", myname, np->n_name);
|
||||
exit(1);
|
||||
}
|
||||
|
|
@ -156,8 +134,7 @@ struct line * lp;
|
|||
}
|
||||
|
||||
|
||||
docmds(np)
|
||||
struct name * np;
|
||||
void docmds(struct name *np)
|
||||
{
|
||||
register struct line * lp;
|
||||
|
||||
|
|
@ -167,189 +144,76 @@ struct name * np;
|
|||
}
|
||||
|
||||
|
||||
#ifdef os9
|
||||
/*
|
||||
* Some stuffing around to get the modified time of a file
|
||||
* in an os9 file system
|
||||
*/
|
||||
getmdate(fd, tbp)
|
||||
struct sgtbuf * tbp;
|
||||
{
|
||||
struct registers regs;
|
||||
static struct fildes fdbuf;
|
||||
|
||||
|
||||
regs.rg_a = fd;
|
||||
regs.rg_b = SS_FD;
|
||||
regs.rg_x = &fdbuf;
|
||||
regs.rg_y = sizeof (fdbuf);
|
||||
|
||||
if (_os9(I_GETSTT, ®s) == -1)
|
||||
{
|
||||
errno = regs.rg_b & 0xff;
|
||||
return -1;
|
||||
}
|
||||
if (tbp)
|
||||
{
|
||||
_strass(tbp, fdbuf.fd_date, sizeof (fdbuf.fd_date));
|
||||
tbp->t_second = 0; /* Files are only acurate to mins */
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Kludge routine to return an aproximation of how many
|
||||
* seconds since 1980. Dates will be in order, but will not
|
||||
* be lineer
|
||||
*/
|
||||
time_t
|
||||
cnvtime(tbp)
|
||||
struct sgtbuf *tbp;
|
||||
{
|
||||
long acc;
|
||||
|
||||
|
||||
acc = tbp->t_year - 80; /* Baseyear is 1980 */
|
||||
acc = acc * 12 + tbp->t_month;
|
||||
acc = acc * 31 + tbp->t_day;
|
||||
acc = acc * 24 + tbp->t_hour;
|
||||
acc = acc * 60 + tbp->t_minute;
|
||||
acc = acc * 60 + tbp->t_second;
|
||||
|
||||
return acc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Get the current time in the internal format
|
||||
*/
|
||||
time(tp)
|
||||
time_t * tp;
|
||||
{
|
||||
struct sgtbuf tbuf;
|
||||
|
||||
|
||||
if (getime(&tbuf) < 0)
|
||||
return -1;
|
||||
|
||||
if (tp)
|
||||
*tp = cnvtime(&tbuf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Get the modification time of a file. If the first
|
||||
* doesn't exist, it's modtime is set to 0.
|
||||
*/
|
||||
void
|
||||
modtime(np)
|
||||
struct name * np;
|
||||
void modtime(struct name *np)
|
||||
{
|
||||
#ifdef unix
|
||||
struct stat info;
|
||||
|
||||
|
||||
if (stat(np->n_name, &info) < 0)
|
||||
{
|
||||
if (errno != ENOENT)
|
||||
fatal("Can't open %s; error %d", np->n_name, errno);
|
||||
fatal("Can't open %s", np->n_name);
|
||||
|
||||
np->n_time = 0L;
|
||||
}
|
||||
else
|
||||
np->n_time = info.st_mtime;
|
||||
#endif
|
||||
#ifdef eon
|
||||
struct stat info;
|
||||
int fd;
|
||||
|
||||
|
||||
if ((fd = open(np->n_name, 0)) < 0)
|
||||
{
|
||||
if (errno != ER_NOTF)
|
||||
fatal("Can't open %s; error %02x", np->n_name, errno);
|
||||
|
||||
np->n_time = 0L;
|
||||
}
|
||||
else if (getstat(fd, &info) < 0)
|
||||
fatal("Can't getstat %s; error %02x", np->n_name, errno);
|
||||
else
|
||||
np->n_time = info.st_mod;
|
||||
|
||||
close(fd);
|
||||
#endif
|
||||
#ifdef os9
|
||||
struct sgtbuf info;
|
||||
int fd;
|
||||
|
||||
|
||||
if ((fd = open(np->n_name, 0)) < 0)
|
||||
{
|
||||
if (errno != E_PNNF)
|
||||
fatal("Can't open %s; error %02x", np->n_name, errno);
|
||||
|
||||
np->n_time = 0L;
|
||||
}
|
||||
else if (getmdate(fd, &info) < 0)
|
||||
fatal("Can't getstat %s; error %02x", np->n_name, errno);
|
||||
else
|
||||
np->n_time = cnvtime(&info);
|
||||
|
||||
close(fd);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Update the mod time of a file to now.
|
||||
*/
|
||||
void
|
||||
touch(np)
|
||||
struct name * np;
|
||||
void touch(struct name *np)
|
||||
{
|
||||
char c;
|
||||
int fd;
|
||||
|
||||
|
||||
#ifdef unix
|
||||
if (!domake || !silent)
|
||||
printf(" touch(%s)\n", np->n_name);
|
||||
|
||||
if (domake)
|
||||
{
|
||||
#ifdef unix
|
||||
long a[2];
|
||||
long time();
|
||||
struct utimbuf a;
|
||||
time_t timeval;
|
||||
|
||||
a[0] = a[1] = time((long *)0);
|
||||
if (utime(np->n_name, &a[0]) < 0)
|
||||
a.actime = a.modtime = time(&timeval);
|
||||
if (utime(np->n_name, &a) < 0)
|
||||
printf("%s: '%s' not touched - non-existant\n",
|
||||
myname, np->n_name);
|
||||
}
|
||||
#endif
|
||||
#ifdef eon
|
||||
if ((fd = open(np->n_name, 0)) < 0)
|
||||
printf("%s: '%s' not touched - non-existant\n",
|
||||
myname, np->n_name);
|
||||
}
|
||||
|
||||
static void make1(struct name *np, struct line *lp, struct depend *qdp)
|
||||
{
|
||||
register struct depend * dp;
|
||||
register char *p;
|
||||
|
||||
if (dotouch)
|
||||
touch(np);
|
||||
else
|
||||
{
|
||||
uread(fd, &c, 1, 0);
|
||||
uwrite(fd, &c, 1);
|
||||
strcpy(str1, "");
|
||||
for (dp = qdp; dp; dp = qdp)
|
||||
{
|
||||
if (strlen(str1))
|
||||
strcat(str1, " ");
|
||||
strcat(str1, dp->d_name->n_name);
|
||||
qdp = dp->d_next;
|
||||
free((char *)dp);
|
||||
}
|
||||
close(fd);
|
||||
#endif
|
||||
#ifdef os9
|
||||
/*
|
||||
* Strange that something almost as totally useless
|
||||
* as this is easy to do in os9!
|
||||
*/
|
||||
if ((fd = open(np->n_name, S_IWRITE)) < 0)
|
||||
printf("%s: '%s' not touched - non-existant\n",
|
||||
myname, np->n_name);
|
||||
close(fd);
|
||||
#endif
|
||||
setmacro("?", str1, 4);
|
||||
setmacro("@", np->n_name, 4);
|
||||
p = strrchr(np->n_name, '.');
|
||||
if (p) *p = 0;
|
||||
setmacro("*", np->n_name, 4);
|
||||
if (p) *p = '.';
|
||||
if (lp) /* lp set if doing a :: rule */
|
||||
docmds1(np, lp);
|
||||
else
|
||||
docmds(np);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -357,10 +221,7 @@ struct name * np;
|
|||
/*
|
||||
* Recursive routine to make a target.
|
||||
*/
|
||||
int
|
||||
make(np, level)
|
||||
struct name * np;
|
||||
int level;
|
||||
int make(struct name *np, int level)
|
||||
{
|
||||
register struct depend * dp;
|
||||
register struct line * lp;
|
||||
|
|
@ -401,7 +262,7 @@ int level;
|
|||
if (s) {
|
||||
sv = malloc((unsigned)(strlen(s)+1));
|
||||
if (!sv) {
|
||||
fatal("no space for saved $<");
|
||||
fatal("no space for saved $<",NULL);
|
||||
}
|
||||
strcpy(sv, s);
|
||||
}
|
||||
|
|
@ -445,38 +306,3 @@ int level;
|
|||
}
|
||||
|
||||
|
||||
make1(np, lp, qdp)
|
||||
register struct depend * qdp;
|
||||
struct line * lp;
|
||||
struct name * np;
|
||||
{
|
||||
register struct depend * dp;
|
||||
register char *p;
|
||||
char *rindex();
|
||||
|
||||
|
||||
if (dotouch)
|
||||
touch(np);
|
||||
else
|
||||
{
|
||||
strcpy(str1, "");
|
||||
for (dp = qdp; dp; dp = qdp)
|
||||
{
|
||||
if (strlen(str1))
|
||||
strcat(str1, " ");
|
||||
strcat(str1, dp->d_name->n_name);
|
||||
qdp = dp->d_next;
|
||||
free((char *)dp);
|
||||
}
|
||||
setmacro("?", str1, 4);
|
||||
setmacro("@", np->n_name, 4);
|
||||
p = rindex(np->n_name, '.');
|
||||
if (p) *p = 0;
|
||||
setmacro("*", np->n_name, 4);
|
||||
if (p) *p = '.';
|
||||
if (lp) /* lp set if doing a :: rule */
|
||||
docmds1(np, lp);
|
||||
else
|
||||
docmds(np);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,6 +5,8 @@
|
|||
*/
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include "h.h"
|
||||
|
|
@ -17,12 +19,17 @@ int lineno;
|
|||
* Syntax error handler. Print message, with line number, and exits.
|
||||
*/
|
||||
/*VARARGS1*/
|
||||
void
|
||||
error(msg, a1, a2, a3)
|
||||
char * msg;
|
||||
void error(char *msg, char* a1)
|
||||
{
|
||||
fprintf(stderr, "%s: ", myname);
|
||||
fprintf(stderr, msg, a1, a2, a3);
|
||||
if (a1 != NULL)
|
||||
{
|
||||
fprintf(stderr, msg, a1);
|
||||
} else
|
||||
{
|
||||
fprintf(stderr, "%s",msg);
|
||||
}
|
||||
|
||||
if (lineno)
|
||||
fprintf(stderr, " near line %d", lineno);
|
||||
fputc('\n', stderr);
|
||||
|
|
@ -35,10 +42,7 @@ char * msg;
|
|||
* comments, ignore blank lines. Deal with quoted (\) #, and
|
||||
* quoted newlines. If EOF return TRUE.
|
||||
*/
|
||||
bool
|
||||
getline(str, fd)
|
||||
char * str;
|
||||
FILE * fd;
|
||||
bool mgetline(char* str, FILE* fd)
|
||||
{
|
||||
register char * p;
|
||||
char * q;
|
||||
|
|
@ -52,8 +56,8 @@ FILE * fd;
|
|||
|
||||
lineno++;
|
||||
|
||||
if ((p = index(str+pos, '\n')) == (char *)0)
|
||||
error("Line too long");
|
||||
if ((p = strchr(str+pos, '\n')) == (char *)0)
|
||||
error("Line too long", NULL);
|
||||
|
||||
if (p[-1] == '\\')
|
||||
{
|
||||
|
|
@ -63,14 +67,14 @@ FILE * fd;
|
|||
}
|
||||
|
||||
p = str;
|
||||
while (((q = index(p, '#')) != (char *)0) &&
|
||||
while (((q = strchr(p, '#')) != (char *)0) &&
|
||||
(p != q) && (q[-1] == '\\'))
|
||||
{
|
||||
char *a;
|
||||
|
||||
a = q - 1; /* Del \ chr; move rest back */
|
||||
p = q;
|
||||
while (*a++ = *q++)
|
||||
while ((*a++ = *q++))
|
||||
;
|
||||
}
|
||||
if (q != (char *)0)
|
||||
|
|
@ -95,9 +99,7 @@ FILE * fd;
|
|||
* return a pointer to it. String returned has no white spaces
|
||||
* in it.
|
||||
*/
|
||||
char *
|
||||
gettok(ptr)
|
||||
char **ptr;
|
||||
char *gettok(char **ptr)
|
||||
{
|
||||
register char * p;
|
||||
|
||||
|
|
|
|||
|
|
@ -4,18 +4,17 @@
|
|||
* $Header$
|
||||
*/
|
||||
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "h.h"
|
||||
|
||||
|
||||
/*
|
||||
* Return a pointer to the suffix of a name
|
||||
*/
|
||||
char *
|
||||
suffix(name)
|
||||
char * name;
|
||||
char *suffix(char *name)
|
||||
{
|
||||
return rindex(name, '.');
|
||||
return strrchr(name, '.');
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -26,9 +25,7 @@ char * name;
|
|||
* source name, and rules. Returns TRUE if np was made into
|
||||
* a target.
|
||||
*/
|
||||
bool
|
||||
dyndep(np)
|
||||
struct name * np;
|
||||
bool dyndep(struct name *np)
|
||||
{
|
||||
register char * p;
|
||||
register char * q;
|
||||
|
|
@ -58,14 +55,14 @@ struct name * np;
|
|||
{
|
||||
newsuff = dp->d_name->n_name;
|
||||
if (strlen(suff)+strlen(newsuff)+1 >= LZ)
|
||||
fatal("Suffix rule too long");
|
||||
fatal("Suffix rule too long",NULL);
|
||||
p = str1;
|
||||
q = newsuff;
|
||||
while (*p++ = *q++)
|
||||
while ((*p++ = *q++))
|
||||
;
|
||||
p--;
|
||||
q = suff;
|
||||
while (*p++ = *q++)
|
||||
while ((*p++ = *q++))
|
||||
;
|
||||
sp = newname(str1);
|
||||
if (sp->n_flag & N_TARG)
|
||||
|
|
@ -73,12 +70,12 @@ struct name * np;
|
|||
p = str1;
|
||||
q = basename;
|
||||
if (strlen(basename) + strlen(newsuff)+1 >= LZ)
|
||||
fatal("Implicit name too long");
|
||||
while (*p++ = *q++)
|
||||
fatal("Implicit name too long",NULL);
|
||||
while ((*p++ = *q++))
|
||||
;
|
||||
p--;
|
||||
q = newsuff;
|
||||
while (*p++ = *q++)
|
||||
while ((*p++ = *q++))
|
||||
;
|
||||
op = newname(str1);
|
||||
if (!op->n_time)
|
||||
|
|
@ -99,8 +96,7 @@ struct name * np;
|
|||
/*
|
||||
* Make the default rules
|
||||
*/
|
||||
void
|
||||
makerules()
|
||||
void makerules(void)
|
||||
{
|
||||
struct cmd * cp;
|
||||
struct name * np;
|
||||
|
|
@ -158,7 +154,7 @@ makerules()
|
|||
#else
|
||||
cp = newcmd("$(CC) $(CFLAGS) -c $<", (struct cmd *)0);
|
||||
np = newname(".c.o");
|
||||
#endif MINIX
|
||||
#endif /* MINIX */
|
||||
newline(np, (struct depend *)0, cp, 0);
|
||||
|
||||
setmacro("AS", "as", 0);
|
||||
|
|
|
|||
Loading…
Reference in a new issue