home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume27 / dmake / part29 < prev    next >
Encoding:
Text File  |  1992-01-29  |  40.0 KB  |  1,446 lines
  1. Newsgroups: comp.sources.misc
  2. From: dvadura@plg.waterloo.edu (Dennis Vadura)
  3. Subject:  v27i130:  dmake - dmake Version 3.8, Part29/41
  4. Message-ID: <1992Jan28.214901.20152@sparky.imd.sterling.com>
  5. X-Md4-Signature: 76e348ec0071479ffadee1ac79f2ee82
  6. Date: Tue, 28 Jan 1992 21:49:01 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: dvadura@plg.waterloo.edu (Dennis Vadura)
  10. Posting-number: Volume 27, Issue 130
  11. Archive-name: dmake/part29
  12. Environment: Atari-ST, Coherent, Mac, MSDOS, OS/2, UNIX
  13. Supersedes: dmake: Volume 19, Issue 22-58
  14.  
  15. ---- Cut Here and feed the following to sh ----
  16. # this is dmake.shar.29 (part 29 of a multipart archive)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file dmake/os2/mscdos/startup.mk continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 29; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test -f _shar_wnt_.tmp; then
  33. sed 's/^X//' << 'SHAR_EOF' >> 'dmake/os2/mscdos/startup.mk' &&
  34. #       and is found in os2/mscdos/dmake.ini
  35. .INCLUDE : "os2/mscdos/dmake.ini"
  36. SHAR_EOF
  37. chmod 0640 dmake/os2/mscdos/startup.mk ||
  38. echo 'restore of dmake/os2/mscdos/startup.mk failed'
  39. Wc_c="`wc -c < 'dmake/os2/mscdos/startup.mk'`"
  40. test 132 -eq "$Wc_c" ||
  41.     echo 'dmake/os2/mscdos/startup.mk: original size 132, current size' "$Wc_c"
  42. rm -f _shar_wnt_.tmp
  43. fi
  44. # ============= dmake/os2/mscdos/tempnam.c ==============
  45. if test -f 'dmake/os2/mscdos/tempnam.c' -a X"$1" != X"-c"; then
  46.     echo 'x - skipping dmake/os2/mscdos/tempnam.c (File already exists)'
  47.     rm -f _shar_wnt_.tmp
  48. else
  49. > _shar_wnt_.tmp
  50. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/mscdos/tempnam.c' &&
  51. /*LINTLIBRARY*/
  52. #include <stdio.h>
  53. #include <string.h>
  54. #include <stdlib.h>
  55. #include <dos.h>
  56. X
  57. #if defined(max)
  58. #   undef  max
  59. #endif
  60. #define max(A,B) (((A)<(B))?(B):(A))
  61. X
  62. extern int access();
  63. int _access();
  64. X
  65. /* MSC stdio.h defines P_tmpdir, so let's undo it here */
  66. /* Under DOS leave the default tmpdir pointing here!        */
  67. #ifdef P_tmpdir
  68. #undef P_tmpdir
  69. #endif
  70. static char *P_tmpdir = "";
  71. X
  72. char *
  73. tempnam(dir, prefix)
  74. char *dir;        /* use this directory please (if non-NULL) */
  75. char *prefix;        /* use this (if non-NULL) as filename prefix */
  76. {
  77. X   static         int count = 0;
  78. X   register char *p, *q, *tmpdir;
  79. X   int            tl=0, dl=0, pl;
  80. X   char          buf[30];
  81. X
  82. X   pl = strlen(P_tmpdir);
  83. X
  84. X   if( (tmpdir = getenv("TMPDIR")) != NULL )
  85. X      tl = strlen(tmpdir);
  86. X   else if( (tmpdir = getenv("TMP")) != NULL )
  87. X      tl = strlen(tmpdir);
  88. X   if( dir != NULL ) dl = strlen(dir);
  89. X
  90. X   if( (p = malloc((unsigned)(max(max(dl,tl),pl)+13))) == NULL )
  91. X     return(NULL);
  92. X
  93. X   *p = '\0';
  94. X
  95. X   if( (tl == 0) || (_access( strcpy(p, tmpdir), 0) != 0) )
  96. X     if( (dl == 0) || (_access( strcpy(p, dir), 0) != 0) )
  97. X    if( _access( strcpy(p, P_tmpdir), 0) != 0 )
  98. X       if( !prefix )
  99. X          prefix = "tp";
  100. X
  101. X   if(prefix)
  102. X   {
  103. X      *(p+strlen(p)+2) = '\0';
  104. X      (void)strncat(p, prefix, 2);
  105. X   }
  106. X
  107. #ifdef OS2
  108. X   sprintf( buf, "%08x", getpid() );
  109. #else
  110. X   sprintf( buf, "%08x", _psp );
  111. #endif
  112. X   buf[6]='\0';
  113. X   (void)strcat(p, buf );
  114. X   sprintf( buf, "%04d", count++ );
  115. X   q=p+strlen(p)-6;
  116. X   *q++ = buf[0]; *q++ = buf[1];
  117. X   *q++ = buf[2]; *q++ = buf[3];
  118. X
  119. X   if( (q = strrchr(p,'.')) != NULL ) *q = '\0';
  120. X
  121. X   return strlwr(p);
  122. }
  123. X
  124. X
  125. X
  126. _access( name, flag )
  127. char *name;
  128. int  flag;
  129. {
  130. X   char *p;
  131. X   int r;
  132. X
  133. X   if( name == NULL || !*name ) return(1);  /* NULL dir means current dir */
  134. X   p = name+strlen(name)-1;
  135. X   if(*p == ':' ) strcat( p++, "\\" );
  136. X   r = access( name, flag );
  137. X   if(*p != '/' && *p != '\\') strcat( p, "\\" );
  138. X
  139. X   return( r );
  140. }
  141. SHAR_EOF
  142. chmod 0640 dmake/os2/mscdos/tempnam.c ||
  143. echo 'restore of dmake/os2/mscdos/tempnam.c failed'
  144. Wc_c="`wc -c < 'dmake/os2/mscdos/tempnam.c'`"
  145. test 1919 -eq "$Wc_c" ||
  146.     echo 'dmake/os2/mscdos/tempnam.c: original size 1919, current size' "$Wc_c"
  147. rm -f _shar_wnt_.tmp
  148. fi
  149. # ============= dmake/os2/optoff.h ==============
  150. if test -f 'dmake/os2/optoff.h' -a X"$1" != X"-c"; then
  151.     echo 'x - skipping dmake/os2/optoff.h (File already exists)'
  152.     rm -f _shar_wnt_.tmp
  153. else
  154. > _shar_wnt_.tmp
  155. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/optoff.h' &&
  156. #if _MSC_VER < 600
  157. # pragma loop_opt(off)
  158. #endif
  159. SHAR_EOF
  160. chmod 0640 dmake/os2/optoff.h ||
  161. echo 'restore of dmake/os2/optoff.h failed'
  162. Wc_c="`wc -c < 'dmake/os2/optoff.h'`"
  163. test 49 -eq "$Wc_c" ||
  164.     echo 'dmake/os2/optoff.h: original size 49, current size' "$Wc_c"
  165. rm -f _shar_wnt_.tmp
  166. fi
  167. # ============= dmake/os2/ruletab.c ==============
  168. if test -f 'dmake/os2/ruletab.c' -a X"$1" != X"-c"; then
  169.     echo 'x - skipping dmake/os2/ruletab.c (File already exists)'
  170.     rm -f _shar_wnt_.tmp
  171. else
  172. > _shar_wnt_.tmp
  173. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/ruletab.c' &&
  174. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/os2/ruletab.c,v 1.1 1992/01/24 03:29:18 dvadura Exp $
  175. -- SYNOPSIS -- Default initial configuration of dmake.
  176. -- 
  177. -- DESCRIPTION
  178. --     Define here the initial set of rules that are defined before
  179. --    dmake performs any processing.
  180. --
  181. -- AUTHOR
  182. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  183. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  184. --
  185. -- COPYRIGHT
  186. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  187. -- 
  188. --      This program is free software; you can redistribute it and/or
  189. --      modify it under the terms of the GNU General Public License
  190. --      (version 1), as published by the Free Software Foundation, and
  191. --      found in the file 'LICENSE' included with this distribution.
  192. -- 
  193. --      This program is distributed in the hope that it will be useful,
  194. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  195. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  196. --      GNU General Public License for more details.
  197. -- 
  198. --      You should have received a copy of the GNU General Public License
  199. --      along with this program;  if not, write to the Free Software
  200. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  201. --
  202. -- LOG
  203. --     $Log: ruletab.c,v $
  204. X * Revision 1.1  1992/01/24  03:29:18  dvadura
  205. X * dmake Version 3.8, Initial revision
  206. X *
  207. */
  208. X
  209. /* These are control macros for dmake that MUST be defined at some point
  210. X * if they are NOT dmake will not work!  These are default definitions.  They
  211. X * may be overridden inside the .STARTUP makefile, they are here
  212. X * strictly so that dmake can parse the STARTUP makefile */
  213. /*
  214. X * For OS/2 these are close to the Unix definitions in terms of limits.
  215. X * We dont need the two different cases of Makefile, so only keep the
  216. X * pretty one.
  217. X */
  218. static char *_rules[] = {
  219. X    "MAXLINELENGTH := 2046",
  220. X    "MAXPROCESSLIMIT := 16",
  221. X    ".IMPORT .IGNORE: ROOTDIR INIT",
  222. X    ".MAKEFILES : makefile.mk Makefile",
  223. X    ".SOURCE    : .NULL",
  224. #include "startup.h"
  225. X    0 };
  226. X
  227. char **Rule_tab = _rules; /* for sundry reasons in Get_environment() */
  228. X
  229. SHAR_EOF
  230. chmod 0640 dmake/os2/ruletab.c ||
  231. echo 'restore of dmake/os2/ruletab.c failed'
  232. Wc_c="`wc -c < 'dmake/os2/ruletab.c'`"
  233. test 2107 -eq "$Wc_c" ||
  234.     echo 'dmake/os2/ruletab.c: original size 2107, current size' "$Wc_c"
  235. rm -f _shar_wnt_.tmp
  236. fi
  237. # ============= dmake/os2/runargv.c ==============
  238. if test -f 'dmake/os2/runargv.c' -a X"$1" != X"-c"; then
  239.     echo 'x - skipping dmake/os2/runargv.c (File already exists)'
  240.     rm -f _shar_wnt_.tmp
  241. else
  242. > _shar_wnt_.tmp
  243. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/runargv.c' &&
  244. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/os2/runargv.c,v 1.1 1992/01/24 03:29:19 dvadura Exp $
  245. -- SYNOPSIS -- invoke a sub process, modified unix/runargv.c for OS/2.
  246. -- 
  247. -- DESCRIPTION
  248. --     Use the standard methods of executing a sub process.
  249. --
  250. -- AUTHOR
  251. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  252. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  253. --
  254. -- COPYRIGHT
  255. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  256. -- 
  257. --      This program is free software; you can redistribute it and/or
  258. --      modify it under the terms of the GNU General Public License
  259. --      (version 1), as published by the Free Software Foundation, and
  260. --      found in the file 'LICENSE' included with this distribution.
  261. -- 
  262. --      This program is distributed in the hope that it will be useful,
  263. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  264. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  265. --      GNU General Public License for more details.
  266. -- 
  267. --      You should have received a copy of the GNU General Public License
  268. --      along with this program;  if not, write to the Free Software
  269. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  270. --
  271. -- LOG
  272. --     $Log: runargv.c,v $
  273. X * Revision 1.1  1992/01/24  03:29:19  dvadura
  274. X * dmake Version 3.8, Initial revision
  275. X *
  276. */
  277. X
  278. #define INCL_DOSPROCESS
  279. #include <os2.h>
  280. X
  281. #include <process.h>
  282. #include <stdlib.h>
  283. #include <signal.h>
  284. #include "extern.h"
  285. #include "sysintf.h"
  286. X
  287. typedef struct prp {
  288. X   char *prp_cmd;
  289. X   int   prp_group;
  290. X   int   prp_ignore;
  291. X   int   prp_last;
  292. X   int     prp_shell;
  293. X   struct prp *prp_next;
  294. } RCP, *RCPPTR;
  295. X
  296. typedef struct pr {
  297. X   int        pr_valid;
  298. X   int        pr_pid;
  299. X   CELLPTR    pr_target;
  300. X   int        pr_ignore;
  301. X   int        pr_last;
  302. X   RCPPTR      pr_recipe;
  303. X   RCPPTR      pr_recipe_end;
  304. X   char        *pr_dir;
  305. } PR;
  306. X
  307. static PR  *_procs    = NIL(PR);
  308. static int  _proc_cnt = 0;
  309. static int  _abort_flg= FALSE;
  310. static int  _use_i    = -1;
  311. static int  _do_upd   = 0;
  312. X
  313. extern unsigned int _far _pascal DosSmSetTitle(char _far *s);
  314. static  void    SetSessionTitle (char *s);
  315. static  void    _add_child ANSI((int, CELLPTR, int, int));
  316. static  void    _attach_cmd ANSI((char *, int, int, CELLPTR, int, int));
  317. static  void    _finished_child ANSI((int, int));
  318. static  int     _running ANSI((CELLPTR));
  319. X
  320. PUBLIC int
  321. runargv(target, ignore, group, last, shell, cmd)
  322. CELLPTR target;
  323. int     ignore;
  324. int    group;
  325. int    last;
  326. int     shell;
  327. char    *cmd;
  328. {
  329. X   int          pid;
  330. X   char         **argv;
  331. X
  332. X   if( _running(target) /*&& Max_proc != 1*/ ) {
  333. X      /* The command will be executed when the previous recipe
  334. X       * line completes. */
  335. X      _attach_cmd( cmd, group, ignore, target, last, shell );
  336. X      return(1);
  337. X   }
  338. X
  339. X   while( _proc_cnt == Max_proc )
  340. X      if( Wait_for_child(FALSE, -1) == -1 )  Fatal( "Lost a child" );
  341. X
  342. #ifdef SESSTITLE
  343. X   SetSessionTitle(target->CE_NAME);
  344. #endif
  345. X   argv = Pack_argv( group, shell, cmd );
  346. X
  347. X   if((pid=spawnvp((_osmode == DOS_MODE)?P_WAIT:P_NOWAIT,argv[0],argv)) == -1){
  348. X      Error("%s: %s", argv[0], sys_errlist[errno]);
  349. X      Handle_result(-1, ignore, _abort_flg, target);
  350. X      return(-1);
  351. X   }
  352. X   else if( _osmode == DOS_MODE ) {
  353. X     _add_child(4711, target, ignore, last);
  354. X     _finished_child(4711, pid);
  355. X   }
  356. X   else
  357. X     _add_child(pid, target, ignore, last);
  358. X
  359. X   return(1);
  360. }
  361. X
  362. X
  363. #ifdef SESSTITLE
  364. /* N.B. The system call used below is undocumented and therefore possibly
  365. X * subject to change. It sets the session title even from a full screen
  366. X * session, so you can see which target is being built.
  367. X * If dubious about undocumented calls simply remove it.
  368. X */
  369. PUBLIC void
  370. SetSessionTitle(char *s)
  371. {
  372. X   char buff[128];
  373. X   strncpy(buff, Pname, sizeof(buff));
  374. X   buff[sizeof(buff)-1] = 0;
  375. X   strncat(buff, " - ", sizeof(buff));
  376. X   strncat(buff, s, sizeof(buff));
  377. X   buff[sizeof(buff)-1] = 0;
  378. X   DosSmSetTitle(buff);
  379. }
  380. #endif
  381. X
  382. X
  383. PUBLIC int
  384. Wait_for_child( abort_flg, pid )
  385. int abort_flg;
  386. int pid;
  387. {
  388. X   int wid;
  389. X   int status;
  390. X   int waitchild;
  391. X
  392. X   if( _osmode == DOS_MODE ) return(1);
  393. X
  394. X   waitchild = (pid == -1)? FALSE : Wait_for_completion;
  395. X
  396. X   do {
  397. X      if( (wid = wait(&status)) == -1 ) return(-1);
  398. X
  399. X      _abort_flg = abort_flg;
  400. X      _finished_child(wid, status);
  401. X      _abort_flg = FALSE;
  402. X   }
  403. X   while( waitchild && pid != wid );
  404. X
  405. X   return(0);
  406. }
  407. X
  408. X
  409. PUBLIC void
  410. Clean_up_processes()
  411. {
  412. X   register int i;
  413. X
  414. X   if( _osmode == DOS_MODE ) {
  415. X      _abort_flg = TRUE;
  416. X      _finished_child(4711, -1);
  417. X      return;
  418. X   }
  419. X
  420. X   if( _procs != NIL(PR) ) {
  421. X      for( i=0; i<Max_proc; i++ )
  422. X     if( _procs[i].pr_valid )
  423. X        DosKillProcess(DKP_PROCESSTREE, _procs[i].pr_pid);
  424. X
  425. X      while( Wait_for_child(TRUE, -1) != -1 );
  426. X   }
  427. }
  428. X
  429. X
  430. static void
  431. _add_child( pid, target, ignore, last )
  432. int    pid;
  433. CELLPTR target;
  434. int    ignore;
  435. int     last;
  436. {
  437. X   register int i;
  438. X   register PR *pp;
  439. X
  440. X   if( _procs == NIL(PR) ) {
  441. X      TALLOC( _procs, Max_proc, PR );
  442. X   }
  443. X
  444. X   if( (i = _use_i) == -1 )
  445. X      for( i=0; i<Max_proc; i++ )
  446. X     if( !_procs[i].pr_valid )
  447. X        break;
  448. X
  449. X   pp = _procs+i;
  450. X
  451. X   pp->pr_valid  = 1;
  452. X   pp->pr_pid    = pid;
  453. X   pp->pr_target = target;
  454. X   pp->pr_ignore = ignore;
  455. X   pp->pr_last   = last;
  456. X   pp->pr_dir    = _strdup(Get_current_dir());
  457. X
  458. X   Current_target = NIL(CELL);
  459. X
  460. X   _proc_cnt++;
  461. X
  462. X   if( Wait_for_completion ) Wait_for_child( FALSE, pid );
  463. }
  464. X
  465. X
  466. static void
  467. _finished_child(pid, status)
  468. int    pid;
  469. int    status;
  470. {
  471. X   register int i;
  472. X   register PR *pp;
  473. X   char     *dir;
  474. X
  475. X   for( i=0; i<Max_proc; i++ )
  476. X      if( _procs[i].pr_valid && _procs[i].pr_pid == pid )
  477. X     break;
  478. X
  479. X   /* Some children we didn't make esp true if using /bin/sh to execute a
  480. X    * a pipe and feed the output as a makefile into dmake. */
  481. X   if( i == Max_proc ) return;
  482. X   _procs[i].pr_valid = 0;
  483. X   _proc_cnt--;
  484. X   dir = _strdup(Get_current_dir());
  485. X   Set_dir( _procs[i].pr_dir );
  486. X
  487. X   if( _procs[i].pr_recipe != NIL(RCP) && !_abort_flg ) {
  488. X      RCPPTR rp = _procs[i].pr_recipe;
  489. X
  490. X
  491. X      Current_target = _procs[i].pr_target;
  492. X      Handle_result( status, _procs[i].pr_ignore, FALSE, _procs[i].pr_target );
  493. X      Current_target = NIL(CELL);
  494. X
  495. X      _procs[i].pr_recipe = rp->prp_next;
  496. X
  497. X      _use_i = i;
  498. X      runargv( _procs[i].pr_target, rp->prp_ignore, rp->prp_group,
  499. X           rp->prp_last, rp->prp_shell, rp->prp_cmd );
  500. X      _use_i = -1;
  501. X
  502. X      FREE( rp->prp_cmd );
  503. X      FREE( rp );
  504. X
  505. X      if( _proc_cnt == Max_proc ) Wait_for_child( FALSE, -1 );
  506. X   }
  507. X   else {
  508. X      Unlink_temp_files( _procs[i].pr_target );
  509. X      Handle_result(status,_procs[i].pr_ignore,_abort_flg,_procs[i].pr_target);
  510. X
  511. X      if( _procs[i].pr_last ) {
  512. X     FREE(_procs[i].pr_dir );
  513. X
  514. X     if( !Doing_bang ) Update_time_stamp( _procs[i].pr_target );
  515. X      }
  516. X   }
  517. X
  518. X   Set_dir(dir);
  519. X   FREE(dir);
  520. }
  521. X
  522. X
  523. static int
  524. _running( cp )
  525. CELLPTR cp;
  526. {
  527. X   register int i;
  528. X
  529. X   if( !_procs ) return(FALSE);
  530. X
  531. X   for( i=0; i<Max_proc; i++ )
  532. X      if( _procs[i].pr_valid &&
  533. X      _procs[i].pr_target == cp  )
  534. X     break;
  535. X     
  536. X   return( i != Max_proc );
  537. }
  538. X
  539. X
  540. static void
  541. _attach_cmd( cmd, group, ignore, cp, last, shell )
  542. char    *cmd;
  543. int    group;
  544. int     ignore;
  545. CELLPTR cp;
  546. int     last;
  547. int     shell;
  548. {
  549. X   register int i;
  550. X   RCPPTR rp;
  551. X
  552. X   for( i=0; i<Max_proc; i++ )
  553. X      if( _procs[i].pr_valid &&
  554. X      _procs[i].pr_target == cp  )
  555. X     break;
  556. X
  557. X   TALLOC( rp, 1, RCP );
  558. X   rp->prp_cmd   = _strdup(cmd);
  559. X   rp->prp_group = group;
  560. X   rp->prp_ignore= ignore;
  561. X   rp->prp_last  = last;
  562. X   rp->prp_shell = shell;
  563. X
  564. X   if( _procs[i].pr_recipe == NIL(RCP) )
  565. X      _procs[i].pr_recipe = _procs[i].pr_recipe_end = rp;
  566. X   else {
  567. X      _procs[i].pr_recipe_end->prp_next = rp;
  568. X      _procs[i].pr_recipe_end = rp;
  569. X   }
  570. }
  571. SHAR_EOF
  572. chmod 0640 dmake/os2/runargv.c ||
  573. echo 'restore of dmake/os2/runargv.c failed'
  574. Wc_c="`wc -c < 'dmake/os2/runargv.c'`"
  575. test 7573 -eq "$Wc_c" ||
  576.     echo 'dmake/os2/runargv.c: original size 7573, current size' "$Wc_c"
  577. rm -f _shar_wnt_.tmp
  578. fi
  579. # ============= dmake/os2/startup.h ==============
  580. if test -f 'dmake/os2/startup.h' -a X"$1" != X"-c"; then
  581.     echo 'x - skipping dmake/os2/startup.h (File already exists)'
  582.     rm -f _shar_wnt_.tmp
  583. else
  584. > _shar_wnt_.tmp
  585. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/startup.h' &&
  586. /* This file contains the default value of the MAKESTARTUP variable.
  587. X * You must set the quoted string below to the default path to the startup
  588. X * variable, so that it gets compiled in.  LEAVE ROOTDIR at the front of
  589. X * the path.  This allows the user to customize his environment for dmake
  590. X * by setting up a new ROOTDIR environment variable. */
  591. X
  592. "MAKESTARTUP := $(INIT)/dmake.ini",
  593. SHAR_EOF
  594. chmod 0640 dmake/os2/startup.h ||
  595. echo 'restore of dmake/os2/startup.h failed'
  596. Wc_c="`wc -c < 'dmake/os2/startup.h'`"
  597. test 384 -eq "$Wc_c" ||
  598.     echo 'dmake/os2/startup.h: original size 384, current size' "$Wc_c"
  599. rm -f _shar_wnt_.tmp
  600. fi
  601. # ============= dmake/os2/stdarg.h ==============
  602. if test -f 'dmake/os2/stdarg.h' -a X"$1" != X"-c"; then
  603.     echo 'x - skipping dmake/os2/stdarg.h (File already exists)'
  604.     rm -f _shar_wnt_.tmp
  605. else
  606. > _shar_wnt_.tmp
  607. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/stdarg.h' &&
  608. /*
  609. X * stdarg.h
  610. X *
  611. X * defines ANSI style macros for accessing arguments of a function which takes
  612. X * a variable number of arguments
  613. X *
  614. X */
  615. X
  616. #if !defined(__STDARG)
  617. #define __STDARG
  618. X
  619. typedef char *va_list;
  620. X
  621. #define va_dcl int va_alist
  622. #define va_start(ap,v)  ap = (va_list)&va_alist
  623. #define va_arg(ap,t)    ((t*)(ap += sizeof(t)))[-1]
  624. #define va_end(ap)      ap = NULL
  625. #endif
  626. SHAR_EOF
  627. chmod 0640 dmake/os2/stdarg.h ||
  628. echo 'restore of dmake/os2/stdarg.h failed'
  629. Wc_c="`wc -c < 'dmake/os2/stdarg.h'`"
  630. test 373 -eq "$Wc_c" ||
  631.     echo 'dmake/os2/stdarg.h: original size 373, current size' "$Wc_c"
  632. rm -f _shar_wnt_.tmp
  633. fi
  634. # ============= dmake/os2/switchar.c ==============
  635. if test -f 'dmake/os2/switchar.c' -a X"$1" != X"-c"; then
  636.     echo 'x - skipping dmake/os2/switchar.c (File already exists)'
  637.     rm -f _shar_wnt_.tmp
  638. else
  639. > _shar_wnt_.tmp
  640. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/switchar.c' &&
  641. /*
  642. ** return switch char
  643. */
  644. #if defined(OS2) || defined(_MSC_VER)
  645. #include <stdlib.h>
  646. #endif
  647. #if !defined(OS2)
  648. #include <dos.h>
  649. #endif /* !OS2 */
  650. #include <stdio.h>
  651. #include "stdmacs.h"
  652. X
  653. getswitchar()/*
  654. ===============
  655. X   Try the environment first.  If you don't find SWITCHAR there, then use
  656. X   the DOS call.  The call is undocumented, and doesn't work for DOS versions
  657. X   4.0 and up, so the check of the environment will fix that. */
  658. {
  659. #if defined(M_I86)
  660. #if !defined(OS2)
  661. X   union REGS rg;
  662. #endif /* ! OS2 */
  663. X   static char *_env_switchar = NIL(char);
  664. X
  665. X   if( _env_switchar != NIL(char) ||
  666. X       (_env_switchar = (char *)getenv("SWITCHAR")) != NIL(char) )
  667. X      return(*_env_switchar);
  668. X
  669. #if !defined(OS2)
  670. X   rg.h.ah = 0x37;      /* switch char request */
  671. X   rg.h.al = 0;         /* get (not set) */
  672. X
  673. X   intdos(&rg, &rg);
  674. X   return (rg.h.dl);
  675. #endif /* ! OS2 */
  676. #endif /* M_I86 */
  677. X
  678. X   return ('/');
  679. }
  680. SHAR_EOF
  681. chmod 0640 dmake/os2/switchar.c ||
  682. echo 'restore of dmake/os2/switchar.c failed'
  683. Wc_c="`wc -c < 'dmake/os2/switchar.c'`"
  684. test 904 -eq "$Wc_c" ||
  685.     echo 'dmake/os2/switchar.c: original size 904, current size' "$Wc_c"
  686. rm -f _shar_wnt_.tmp
  687. fi
  688. # ============= dmake/os2/sysintf.h ==============
  689. if test -f 'dmake/os2/sysintf.h' -a X"$1" != X"-c"; then
  690.     echo 'x - skipping dmake/os2/sysintf.h (File already exists)'
  691.     rm -f _shar_wnt_.tmp
  692. else
  693. > _shar_wnt_.tmp
  694. sed 's/^X//' << 'SHAR_EOF' > 'dmake/os2/sysintf.h' &&
  695. /*
  696. ** assorted bits of system interface
  697. */
  698. X
  699. #define STAT stat
  700. #define VOID_LCACHE(l,m)
  701. #define Hook_std_writes(A)
  702. #define GETPID getpid()
  703. X
  704. extern char * tempnam();
  705. extern char * getcwd();
  706. X
  707. /*
  708. ** standard C items
  709. */
  710. X
  711. /*
  712. ** DOS interface standard items
  713. */
  714. #define    chdir(p) _chdir(p)
  715. X
  716. /*
  717. ** make parameters
  718. */
  719. #define    MAX_PATH_LEN    256
  720. X
  721. SHAR_EOF
  722. chmod 0640 dmake/os2/sysintf.h ||
  723. echo 'restore of dmake/os2/sysintf.h failed'
  724. Wc_c="`wc -c < 'dmake/os2/sysintf.h'`"
  725. test 333 -eq "$Wc_c" ||
  726.     echo 'dmake/os2/sysintf.h: original size 333, current size' "$Wc_c"
  727. rm -f _shar_wnt_.tmp
  728. fi
  729. # ============= dmake/parse.c ==============
  730. if test -f 'dmake/parse.c' -a X"$1" != X"-c"; then
  731.     echo 'x - skipping dmake/parse.c (File already exists)'
  732.     rm -f _shar_wnt_.tmp
  733. else
  734. > _shar_wnt_.tmp
  735. sed 's/^X//' << 'SHAR_EOF' > 'dmake/parse.c' &&
  736. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/parse.c,v 1.1 1992/01/24 03:26:53 dvadura Exp $
  737. -- SYNOPSIS -- parse the input, and perform semantic analysis
  738. -- 
  739. -- DESCRIPTION
  740. --     This file contains the routines that parse the input makefile and
  741. --    call the appropriate routines to perform the semantic analysis and
  742. --    build the internal dag.
  743. --
  744. -- AUTHOR
  745. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  746. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  747. --
  748. -- COPYRIGHT
  749. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  750. -- 
  751. --      This program is free software; you can redistribute it and/or
  752. --      modify it under the terms of the GNU General Public License
  753. --      (version 1), as published by the Free Software Foundation, and
  754. --      found in the file 'LICENSE' included with this distribution.
  755. -- 
  756. --      This program is distributed in the hope that it will be useful,
  757. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  758. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  759. --      GNU General Public License for more details.
  760. -- 
  761. --      You should have received a copy of the GNU General Public License
  762. --      along with this program;  if not, write to the Free Software
  763. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  764. --
  765. -- LOG
  766. --     $Log: parse.c,v $
  767. X * Revision 1.1  1992/01/24  03:26:53  dvadura
  768. X * dmake Version 3.8, Initial revision
  769. X *
  770. */
  771. X
  772. #include "extern.h"
  773. X
  774. X
  775. PUBLIC void
  776. Parse( fil )/*
  777. ==============  Parse the makefile input */
  778. FILE *fil;
  779. {
  780. X   int  rule  = FALSE;                 /* have seen a recipe line        */
  781. X   char *p;                   /* termporary pointer into Buffer */
  782. X
  783. X   DB_ENTER( "Parse" );
  784. X
  785. X   State = NORMAL_SCAN;
  786. X   Group = FALSE;                 /* true if scanning a group rcpe  */
  787. X   while( TRUE ) {
  788. X      if( Get_line( Buffer, fil ) ) {
  789. X     if( fil != NIL( FILE ) )               /* end of parsable input */
  790. X        Closefile();
  791. X
  792. X     Bind_rules_to_targets( F_DEFAULT );
  793. X         if( Group )  Fatal( "Incomplete rule recipe group detected" );
  794. X
  795. X     DB_VOID_RETURN;
  796. X      }
  797. X      else {
  798. X         switch( State ) {
  799. X        case RULE_SCAN:
  800. X
  801. X           /* Check for the `[' that starts off a group rule definition.  It
  802. X            * must appear as the first non-white space
  803. X        * character in the line. */
  804. X
  805. X           p = _strspn( Buffer, " \t\r\n" );
  806. X               if( Set_group_attributes( p ) ) {
  807. X                  if( rule && Group )
  808. X                     Fatal( "Cannot mix single and group recipe lines" );
  809. X                  else
  810. X                     Group = TRUE;
  811. X
  812. X                  rule = TRUE;
  813. X
  814. X                  break;                     /* ignore the group start  */
  815. X               }
  816. X
  817. X               if( Group ) {
  818. X                  if( *p != ']' ) {
  819. X                     Add_recipe_to_list( Buffer, TRUE, TRUE );
  820. X                     rule = TRUE;
  821. X                  }
  822. X                  else
  823. X                     State = NORMAL_SCAN;
  824. X               }
  825. X               else {
  826. X                  if(    *Buffer == '\t'
  827. X              || (Notabs && *Buffer == ' ') ) {
  828. X                     Add_recipe_to_list( Buffer, FALSE, FALSE );
  829. X                     rule = TRUE;
  830. X                  }
  831. X                  else if( *p == ']' )
  832. X                     Fatal( "Found unmatched ']'" );
  833. X                  else if( *Buffer && *p || (Notabs && !*Buffer && !*p))
  834. X             State = NORMAL_SCAN;
  835. X               }
  836. X 
  837. X               if( State == RULE_SCAN ) break;     /* ie. keep going    */
  838. X               
  839. X           Bind_rules_to_targets( (Group) ? F_GROUP: F_DEFAULT );
  840. X
  841. X               rule = FALSE;
  842. X               if( Group ) {
  843. X                  Group = FALSE;
  844. X                  break;
  845. X               }
  846. X           /*FALLTRHOUGH*/
  847. X
  848. X               /* In this case we broke out of the rule scan because we do not
  849. X                * have a recipe line that begins with a <TAB>, so lets
  850. X        * try to scan the thing as a macro or rule definition. */
  851. X               
  852. X
  853. X        case NORMAL_SCAN:
  854. X           if( !*Buffer ) continue;         /* we have null input line */
  855. X
  856. X           /* STUPID AUGMAKE uses "include" at the start of a line as
  857. X            * a signal to include a new file, so let's look for it.
  858. X        * if we see it replace it by .INCLUDE: and stick this back
  859. X        * into the buffer. */
  860. X           if( !strncmp( "include", Buffer, 7 ) &&
  861. X           (Buffer[7] == ' ' || Buffer[7] == '\t') )
  862. X           {
  863. X          char *tmp;
  864. X
  865. X          tmp = _strjoin( ".INCLUDE:", Buffer+7, -1, FALSE );
  866. X          strcpy( Buffer, tmp );
  867. X          FREE( tmp );
  868. X           }
  869. X
  870. X               /* look for a macro definition, they all contain an = sign
  871. X            * if we fail to recognize it as a legal macro op then try to
  872. X        * parse the same line as a rule definition, it's one or the
  873. X        * other */
  874. X        
  875. X           if( Parse_macro(Buffer, M_DEFAULT) ) break;/* it's a macro def */
  876. X           if( Parse_rule_def( &State ) )         break;/* it's a rule def  */
  877. X
  878. X           /* if just blank line then ignore it */
  879. X           if( *_strspn( Buffer, " \t\r\n" ) == '\0' ) break;
  880. X           
  881. X           /* otherwise assume it was a line of unrecognized input, or a
  882. X            * recipe line out of place so print a message */
  883. X        
  884. X           Fatal( "Expecting macro or rule defn, found neither" );
  885. X           break;
  886. X
  887. X        default:
  888. X           Fatal( "Internal -- UNKNOWN Parser state %d", State );
  889. X     }
  890. X      }
  891. X   }
  892. }
  893. X
  894. SHAR_EOF
  895. chmod 0640 dmake/parse.c ||
  896. echo 'restore of dmake/parse.c failed'
  897. Wc_c="`wc -c < 'dmake/parse.c'`"
  898. test 5291 -eq "$Wc_c" ||
  899.     echo 'dmake/parse.c: original size 5291, current size' "$Wc_c"
  900. rm -f _shar_wnt_.tmp
  901. fi
  902. # ============= dmake/patchlvl.h ==============
  903. if test -f 'dmake/patchlvl.h' -a X"$1" != X"-c"; then
  904.     echo 'x - skipping dmake/patchlvl.h (File already exists)'
  905.     rm -f _shar_wnt_.tmp
  906. else
  907. > _shar_wnt_.tmp
  908. sed 's/^X//' << 'SHAR_EOF' > 'dmake/patchlvl.h' &&
  909. /* dmake patch level, reset to 0 for each new version release. */
  910. X
  911. #define PATCHLEVEL 0
  912. SHAR_EOF
  913. chmod 0640 dmake/patchlvl.h ||
  914. echo 'restore of dmake/patchlvl.h failed'
  915. Wc_c="`wc -c < 'dmake/patchlvl.h'`"
  916. test 88 -eq "$Wc_c" ||
  917.     echo 'dmake/patchlvl.h: original size 88, current size' "$Wc_c"
  918. rm -f _shar_wnt_.tmp
  919. fi
  920. # ============= dmake/path.c ==============
  921. if test -f 'dmake/path.c' -a X"$1" != X"-c"; then
  922.     echo 'x - skipping dmake/path.c (File already exists)'
  923.     rm -f _shar_wnt_.tmp
  924. else
  925. > _shar_wnt_.tmp
  926. sed 's/^X//' << 'SHAR_EOF' > 'dmake/path.c' &&
  927. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/path.c,v 1.1 1992/01/24 03:27:54 dvadura Exp $
  928. -- SYNOPSIS -- pathname manipulation code
  929. -- 
  930. -- DESCRIPTION
  931. --    Pathname routines to handle building and pulling appart
  932. --    pathnames.
  933. -- 
  934. -- AUTHOR
  935. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  936. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  937. --
  938. -- COPYRIGHT
  939. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  940. -- 
  941. --      This program is free software; you can redistribute it and/or
  942. --      modify it under the terms of the GNU General Public License
  943. --      (version 1), as published by the Free Software Foundation, and
  944. --      found in the file 'LICENSE' included with this distribution.
  945. -- 
  946. --      This program is distributed in the hope that it will be useful,
  947. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  948. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  949. --      GNU General Public License for more details.
  950. -- 
  951. --      You should have received a copy of the GNU General Public License
  952. --      along with this program;  if not, write to the Free Software
  953. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  954. --
  955. -- LOG
  956. --     $Log: path.c,v $
  957. X * Revision 1.1  1992/01/24  03:27:54  dvadura
  958. X * dmake Version 3.8, Initial revision
  959. X *
  960. */
  961. X
  962. #include "extern.h"
  963. X
  964. /*
  965. ** Return the suffix portion of a filename, assumed to begin with a `.'.
  966. */
  967. PUBLIC char *
  968. Get_suffix(name)
  969. char *name;
  970. {
  971. X   char *suff;
  972. X
  973. X   if(name == NIL(char)  || (suff = strrchr(name, '.')) == NIL(char))
  974. X      suff = ".NULL";
  975. X
  976. X   return (suff);
  977. }
  978. X
  979. X
  980. X
  981. /*
  982. ** Take dir and name, and return a path which has dir as the directory
  983. ** and name afterwards.
  984. **
  985. ** N.B. Assumes that the dir separator string is in DirSepStr.
  986. **      Return path is built in a static buffer, if you need to use it
  987. **      again you must _strdup the result returned by Build_path.
  988. */
  989. PUBLIC char *
  990. Build_path(dir, name)
  991. char *dir;
  992. char *name;
  993. {
  994. X   register char *p;
  995. X   register char *q;
  996. X   static char     *path  = NIL(char);
  997. X   static unsigned buflen = 0;
  998. X   int  plen = 0;
  999. X   int  dlen = 0;
  1000. X   int  len;
  1001. X
  1002. X   if( dir  != NIL(char) ) dlen = strlen( dir  );
  1003. X   if( name != NIL(char) ) plen = strlen( name );
  1004. X   len = plen+dlen+strlen(DirSepStr)+1;
  1005. X
  1006. X   if( len > buflen ) {
  1007. X      buflen = (len+16) & ~0xf;        /* buf is always multiple of 16 */
  1008. X
  1009. X      if( path == NIL(char) )
  1010. X         path = MALLOC( buflen, char );
  1011. X      else
  1012. X         path = realloc( path, (unsigned) (buflen*sizeof(char)) );
  1013. X   }
  1014. X   
  1015. X   *path = '\0';
  1016. X
  1017. X   if( dlen ) {
  1018. X      strcpy( path, dir );
  1019. X      if( *path && strchr(DirBrkStr, dir[dlen-1]) == NIL(char) )
  1020. X     strcat( path, DirSepStr );
  1021. X   }
  1022. X   strcat( path, name );
  1023. X
  1024. X   q=path;
  1025. X   while( *q ) {
  1026. X      char *t;
  1027. X
  1028. X      p=_strpbrk(q,DirBrkStr);
  1029. X      t=_strpbrk(p+1,DirBrkStr);
  1030. X      if( !*p || !*t ) break;
  1031. X
  1032. X      if(    !(p-q == 2 && strncmp(q,"..",2) == 0)
  1033. X          && t-p-1 == 2 && strncmp(p+1,"..",2) == 0 ) {
  1034. X     t = _strspn(t,DirBrkStr);
  1035. X     strcpy(q,t);
  1036. X      }
  1037. X      else
  1038. X     q = p+1;
  1039. X   }
  1040. X
  1041. X   return( path );
  1042. }
  1043. SHAR_EOF
  1044. chmod 0640 dmake/path.c ||
  1045. echo 'restore of dmake/path.c failed'
  1046. Wc_c="`wc -c < 'dmake/path.c'`"
  1047. test 3076 -eq "$Wc_c" ||
  1048.     echo 'dmake/path.c: original size 3076, current size' "$Wc_c"
  1049. rm -f _shar_wnt_.tmp
  1050. fi
  1051. # ============= dmake/percent.c ==============
  1052. if test -f 'dmake/percent.c' -a X"$1" != X"-c"; then
  1053.     echo 'x - skipping dmake/percent.c (File already exists)'
  1054.     rm -f _shar_wnt_.tmp
  1055. else
  1056. > _shar_wnt_.tmp
  1057. sed 's/^X//' << 'SHAR_EOF' > 'dmake/percent.c' &&
  1058. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/percent.c,v 1.1 1992/01/24 03:29:34 dvadura Exp $
  1059. -- SYNOPSIS -- handle building or %-rule meta-target nfa.
  1060. -- 
  1061. -- DESCRIPTION
  1062. --    Builds the NFA used by dmake to match targets against %-meta
  1063. --    rule constructs.  The NFA is built as a set of DFA's.
  1064. -- 
  1065. -- AUTHOR
  1066. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  1067. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  1068. --
  1069. -- COPYRIGHT
  1070. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  1071. -- 
  1072. --      This program is free software; you can redistribute it and/or
  1073. --      modify it under the terms of the GNU General Public License
  1074. --      (version 1), as published by the Free Software Foundation, and
  1075. --      found in the file 'LICENSE' included with this distribution.
  1076. -- 
  1077. --      This program is distributed in the hope that it will be useful,
  1078. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  1079. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1080. --      GNU General Public License for more details.
  1081. -- 
  1082. --      You should have received a copy of the GNU General Public License
  1083. --      along with this program;  if not, write to the Free Software
  1084. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1085. --
  1086. -- LOG
  1087. --     $Log: percent.c,v $
  1088. X * Revision 1.1  1992/01/24  03:29:34  dvadura
  1089. X * dmake Version 3.8, Initial revision
  1090. X *
  1091. */
  1092. X
  1093. #include "extern.h"
  1094. X
  1095. static DFAPTR _build_dfa ANSI((char *));
  1096. static char   _shift_dfa ANSI((DFAPTR, char *));
  1097. X
  1098. X
  1099. #define NO_ACTION    0
  1100. #define START_PERCENT    1
  1101. #define END_PERCENT    2
  1102. #define ACCEPT        4
  1103. #define FAIL           -1
  1104. X
  1105. static  NFAPTR _nfa = NIL( NFA );
  1106. X
  1107. X
  1108. PUBLIC DFALINKPTR
  1109. Match_dfa( buf )/*
  1110. ==================
  1111. X   This routines runs all DFA's in parrallel and selects the one that best
  1112. X   matches the string.  If no match then it returns NIL( DFA ) */
  1113. char *buf;
  1114. {
  1115. X   register NFAPTR nfa;
  1116. X   int         adv;
  1117. X   DFALINKPTR       dfa_list = NIL(DFALINK);
  1118. X
  1119. X   DB_ENTER( "Match_dfa" );
  1120. X   DB_PRINT( "dfa", ("Matching %s", buf) );
  1121. X
  1122. X   /* Run each of the DFA's on the input string in parallel, we terminate
  1123. X    * when all DFA's have either failed or ACCEPTED, if more than one DFA
  1124. X    * accepts we build a list of all accepting DFA's sorted on states with
  1125. X    * those matching in a higher numbered state heading the list. */
  1126. X
  1127. X   do {
  1128. X      adv = FALSE;
  1129. X
  1130. X      for( nfa = _nfa; nfa != NIL( NFA ); nfa = nfa->next )
  1131. X     if( nfa->status != (char) FAIL && nfa->status != (char) ACCEPT ) {
  1132. X        adv++;
  1133. X        nfa->status = _shift_dfa( nfa->dfa, buf );
  1134. X
  1135. X        /* Construct the list of matching DFA's */
  1136. X        if( nfa->status == (char) ACCEPT ) {
  1137. X           DFALINKPTR dl;
  1138. X
  1139. X           TALLOC( dl, 1, DFALINK );
  1140. X           dl->dl_meta  = nfa->dfa->node;
  1141. X           dl->dl_per   = _substr( nfa->dfa->pstart, nfa->dfa->pend );
  1142. X           dl->dl_state = nfa->dfa->states - nfa->dfa->c_state;
  1143. X
  1144. X           if( dfa_list == NIL(DFALINK) )
  1145. X              dfa_list = dl;
  1146. X           else {
  1147. X          DFALINKPTR tdli = dfa_list;
  1148. X          DFALINKPTR tdlp = NIL(DFALINK);
  1149. X
  1150. X          for( ; tdli != NIL(DFALINK); tdli = tdli->dl_next ) {
  1151. X             if( dl->dl_state >= tdli->dl_state )
  1152. X            break;
  1153. X             tdlp = tdli;
  1154. X          }
  1155. X
  1156. X          if( tdli != NIL(DFALINK) ) {
  1157. X             tdli->dl_prev = dl;
  1158. X             dl->dl_next   = tdli;
  1159. X          }
  1160. X
  1161. X          if( tdlp != NIL(DFALINK) ) {
  1162. X             tdlp->dl_next = dl;
  1163. X             dl->dl_prev   = tdlp;
  1164. X          }
  1165. X          else
  1166. X             dfa_list = dl;
  1167. X           }
  1168. X
  1169. X           DB_PRINT( "dfa", ("Matched [%s]", dl->dl_meta->CE_NAME) );
  1170. X        }
  1171. X     }
  1172. X
  1173. X      buf++;
  1174. X   }
  1175. X   while ( adv );
  1176. X
  1177. X   for( nfa = _nfa; nfa != NIL( NFA ); nfa = nfa->next ) {
  1178. X      nfa->status = 0;
  1179. X      nfa->dfa->c_state = nfa->dfa->states;
  1180. X   }
  1181. X
  1182. X   DB_RETURN( dfa_list );
  1183. }
  1184. X
  1185. X
  1186. PUBLIC void
  1187. Check_circle_dfa()/*
  1188. ====================
  1189. X   This function is called to test for circularities in the DFA lists
  1190. X   constructed from %-meta targets. */
  1191. {
  1192. X   register NFAPTR nfa;
  1193. X
  1194. X   for( nfa = _nfa; nfa != NIL(NFA); nfa = nfa->next )
  1195. X      if( Test_circle( nfa->dfa->node, FALSE ) )
  1196. X     Fatal( "Detected circular dependency in inference graph at [%s]",
  1197. X        nfa->dfa->node->CE_NAME );
  1198. }
  1199. X
  1200. X
  1201. PUBLIC void
  1202. Add_nfa( name )/*
  1203. =================
  1204. X   Given name, build a DFA and add it to the NFA.  The NFA is maintained as
  1205. X   a singly linked list of DFA's. */
  1206. char *name;
  1207. {
  1208. X   NFAPTR nfa;
  1209. X
  1210. X   TALLOC(nfa, 1, NFA);
  1211. X   nfa->dfa = _build_dfa(name);
  1212. X
  1213. X   if( _nfa != NIL(NFA) ) nfa->next = _nfa;
  1214. X
  1215. X   _nfa = nfa;
  1216. }
  1217. X
  1218. X
  1219. static DFAPTR
  1220. _build_dfa( name )/*
  1221. ====================
  1222. X   Construct a dfa for the passed in cell name.  The routine returns a struct
  1223. X   that represents a finite state machine that can recognize a regular
  1224. X   expression with exactly one '%' sign in it.  The '%' symbol is used as a
  1225. X   wildcard character that will match anything except the character that
  1226. X   immediately follows it or NUL.
  1227. X
  1228. X   The Construction of DFA's is well know and can be found in Hopcroft and
  1229. X   Ullman or any other book discussing formal language theory.
  1230. X   A more practical treatise can be found in Compilers, Aho, Sethi and Ullman.
  1231. */
  1232. char *name;
  1233. {
  1234. X   DFAPTR   dfa;
  1235. X   int      nstates;
  1236. X   register STATEPTR sp;
  1237. X   STATEPTR per_state = NIL(STATE);
  1238. X   int      pcount=0;
  1239. X   int      end_percent=FALSE;
  1240. X
  1241. X   nstates = strlen(name)+2;
  1242. X
  1243. X   /* Allocate a DFA node and the right number of states. */
  1244. X   TALLOC(dfa, 1, DFA);
  1245. X   TALLOC(sp=dfa->c_state=dfa->states, nstates, STATE);
  1246. X   dfa->node = Def_cell( name );
  1247. X
  1248. X   /* Now construct the state table for the DFA */
  1249. X   do {
  1250. X      if( *name == '%' ) {
  1251. X     if( pcount++ > 0 )
  1252. X        Error( "Only one %% allowed within a %%-meta target" );
  1253. X
  1254. X     sp->symbol   = 0;
  1255. X     sp->action   = START_PERCENT;
  1256. X     sp->no_match = sp->match = per_state = sp+1;
  1257. X     end_percent  = TRUE;
  1258. X      }
  1259. X      else {
  1260. X     sp->symbol   = *name;
  1261. X     sp->no_match = per_state;
  1262. X
  1263. X     if( *name == '\0' ) {
  1264. X        sp->action = ACCEPT;
  1265. X        sp->match  = dfa->states;
  1266. X     }
  1267. X     else {
  1268. X        sp->action = NO_ACTION;
  1269. X        sp->match  = sp+1;
  1270. X     }
  1271. X
  1272. X     if( end_percent ) {
  1273. X        sp->action |= END_PERCENT;
  1274. X        end_percent = FALSE;
  1275. X     }
  1276. X      }
  1277. X      
  1278. X      sp++; 
  1279. X   }
  1280. X   while( *name++ );
  1281. X
  1282. X   return(dfa);
  1283. }
  1284. X
  1285. X
  1286. static char
  1287. _shift_dfa( dfa, data )/*
  1288. =========================
  1289. X   Take a given dfa and advance it based on the current state, the shift
  1290. X   action in that state, and the current data value. */
  1291. DFAPTR dfa;
  1292. char   *data;
  1293. {
  1294. X   register STATEPTR sp = dfa->c_state;
  1295. X   char c = *data;
  1296. X
  1297. X   /* Check if it is a START_PERCENT action if so then we need to save
  1298. X    * a pointer to the start of the string and advance to the next state. */
  1299. X   if( sp->action & START_PERCENT ) {
  1300. X      dfa->pstart = data;
  1301. X      sp++;
  1302. X   }
  1303. X
  1304. X   /* Now check if the current char matches the character expected in the
  1305. X    * current state.  If it does then perform the specified action, otherwise
  1306. X    * either shift it or fail.  We fail if the next state on no-match is
  1307. X    * NIL. */
  1308. X   if( sp->symbol == c ) {
  1309. X      if( sp->action & END_PERCENT ) dfa->pend = data;
  1310. X      if( sp->action & ACCEPT ) return(ACCEPT);
  1311. X      dfa->c_state = sp->match;
  1312. X   }
  1313. X   else if( (dfa->c_state = sp->no_match) == NIL(STATE) || !c )
  1314. X      return(FAIL);
  1315. X
  1316. X   return(NO_ACTION);
  1317. }
  1318. SHAR_EOF
  1319. chmod 0640 dmake/percent.c ||
  1320. echo 'restore of dmake/percent.c failed'
  1321. Wc_c="`wc -c < 'dmake/percent.c'`"
  1322. test 7063 -eq "$Wc_c" ||
  1323.     echo 'dmake/percent.c: original size 7063, current size' "$Wc_c"
  1324. rm -f _shar_wnt_.tmp
  1325. fi
  1326. # ============= dmake/quit.c ==============
  1327. if test -f 'dmake/quit.c' -a X"$1" != X"-c"; then
  1328.     echo 'x - skipping dmake/quit.c (File already exists)'
  1329.     rm -f _shar_wnt_.tmp
  1330. else
  1331. > _shar_wnt_.tmp
  1332. sed 's/^X//' << 'SHAR_EOF' > 'dmake/quit.c' &&
  1333. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/quit.c,v 1.1 1992/01/24 03:27:53 dvadura Exp $
  1334. -- SYNOPSIS -- end the dmake session.
  1335. -- 
  1336. -- DESCRIPTION
  1337. --     Handles dmake termination.
  1338. --
  1339. -- AUTHOR
  1340. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  1341. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  1342. --
  1343. -- COPYRIGHT
  1344. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  1345. -- 
  1346. --      This program is free software; you can redistribute it and/or
  1347. --      modify it under the terms of the GNU General Public License
  1348. --      (version 1), as published by the Free Software Foundation, and
  1349. --      found in the file 'LICENSE' included with this distribution.
  1350. -- 
  1351. --      This program is distributed in the hope that it will be useful,
  1352. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  1353. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1354. --      GNU General Public License for more details.
  1355. -- 
  1356. --      You should have received a copy of the GNU General Public License
  1357. --      along with this program;  if not, write to the Free Software
  1358. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  1359. --
  1360. -- LOG
  1361. --     $Log: quit.c,v $
  1362. X * Revision 1.1  1992/01/24  03:27:53  dvadura
  1363. X * dmake Version 3.8, Initial revision
  1364. X *
  1365. */
  1366. X
  1367. #include "extern.h"
  1368. X
  1369. static    void    _handle_quit ANSI((char*));
  1370. static    int    _dont_quit = 0;
  1371. X
  1372. X
  1373. PUBLIC void
  1374. Quit()/*
  1375. ======== Error or quit */
  1376. {
  1377. X   if( _dont_quit ) return;
  1378. X
  1379. X   while( Closefile() != NIL( FILE ) );
  1380. X   Clean_up_processes();
  1381. X
  1382. X   if( Current_target != NIL(CELL) )
  1383. X      Unlink_temp_files(Current_target);
  1384. X
  1385. X   if( _dont_quit == 0 ) _handle_quit( ".ERROR" );
  1386. X
  1387. X   Set_dir( Makedir );        /* No Error message if we can't do it */
  1388. X   Epilog( ERROR_EXIT_VALUE );
  1389. }
  1390. X
  1391. X
  1392. static void
  1393. _handle_quit( err_target )/*
  1394. ============================
  1395. X   Called by quit and the others to handle the execution of termination code
  1396. X   from within make */
  1397. char *err_target;
  1398. {
  1399. X   HASHPTR hp;
  1400. X   CELLPTR cp;
  1401. X
  1402. X   if( (hp = Get_name(err_target, Defs, FALSE)) != NIL(HASH) ) {
  1403. X      cp = hp->CP_OWNR;
  1404. X      Glob_attr |= A_IGNORE;
  1405. X
  1406. X      _dont_quit = 1;
  1407. X      cp->ce_flag |= F_TARGET;
  1408. X      Make( cp, NIL(CELL) );
  1409. X   }
  1410. }
  1411. SHAR_EOF
  1412. chmod 0640 dmake/quit.c ||
  1413. echo 'restore of dmake/quit.c failed'
  1414. Wc_c="`wc -c < 'dmake/quit.c'`"
  1415. test 2196 -eq "$Wc_c" ||
  1416.     echo 'dmake/quit.c: original size 2196, current size' "$Wc_c"
  1417. rm -f _shar_wnt_.tmp
  1418. fi
  1419. # ============= dmake/readme/apple.mac ==============
  1420. if test ! -d 'dmake/readme'; then
  1421.     mkdir 'dmake/readme'
  1422. fi
  1423. if test -f 'dmake/readme/apple.mac' -a X"$1" != X"-c"; then
  1424.     echo 'x - skipping dmake/readme/apple.mac (File already exists)'
  1425.     rm -f _shar_wnt_.tmp
  1426. else
  1427. > _shar_wnt_.tmp
  1428. sed 's/^X//' << 'SHAR_EOF' > 'dmake/readme/apple.mac' &&
  1429. Notes on the Macintosh implementation of dmake:
  1430. X
  1431. This port for the Macintosh is specifically designed to be run
  1432. under MPW.
  1433. X
  1434. I had to make a couple of changes to dmake in order to get it to work
  1435. on the Mac.  First, MPW provides no documented way to run a
  1436. subprocess, so when you use dmake, you MUST use the -n option and
  1437. execute the output.  Typically, you will probably want to write a
  1438. simple script file to do these operations for you.
  1439. SHAR_EOF
  1440. true || echo 'restore of dmake/readme/apple.mac failed'
  1441. fi
  1442. echo 'End of part 29, continue with part 30'
  1443. echo 30 > _shar_seq_.tmp
  1444. exit 0
  1445. exit 0 # Just in case...
  1446.