home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume7 / patch2 / part01 next >
Text File  |  1986-11-30  |  51KB  |  2,112 lines
  1. Subject:  v07i038:  Release 2.0 of patch, Part01/03
  2. Newsgroups: mod.sources
  3. Approved: mirror!rs
  4.  
  5. Submitted by: sdcrdcf!lwall (Larry Wall)
  6. Mod.sources: Volume 7, Issue 38
  7. Archive-name: patch2/Part01
  8.  
  9. Here is the official 2.0 release of patch.  It supersedes the 1.5 beta
  10. version posted to net.sources, and the version that comes with 4.3bsd.
  11.  
  12. Larry Wall
  13. sdcrdcf!lwall
  14.  
  15. --------------------------CUT HERE---------------------------
  16. #! /bin/sh
  17.  
  18. # Make a new directory for the patch sources, cd to it, and run kits 1 thru 3 
  19. # through sh.  When all 3 kits have been run, read README.
  20.  
  21. echo "This is patch kit 1 (of 3).  If kit 1 is complete, the line"
  22. echo '"'"End of kit 1 (of 3)"'" will echo at the end.'
  23. echo ""
  24. export PATH || (echo "You didn't use sh, you clunch." ; kill $$)
  25. echo Extracting pch.c
  26. sed >pch.c <<'!STUFFY!FUNK!' -e 's/X//'
  27. X/* $Header: pch.c,v 2.0 86/09/17 15:39:37 lwall Exp $
  28. X *
  29. X * $Log:    pch.c,v $
  30. X * Revision 2.0  86/09/17  15:39:37  lwall
  31. X * Baseline for netwide release.
  32. X * 
  33. X */
  34. X
  35. X#include "EXTERN.h"
  36. X#include "common.h"
  37. X#include "util.h"
  38. X#include "INTERN.h"
  39. X#include "pch.h"
  40. X
  41. X/* Patch (diff listing) abstract type. */
  42. X
  43. Xstatic long p_filesize;            /* size of the patch file */
  44. Xstatic LINENUM p_first;            /* 1st line number */
  45. Xstatic LINENUM p_newfirst;        /* 1st line number of replacement */
  46. Xstatic LINENUM p_ptrn_lines;        /* # lines in pattern */
  47. Xstatic LINENUM p_repl_lines;        /* # lines in replacement text */
  48. Xstatic LINENUM p_end = -1;        /* last line in hunk */
  49. Xstatic LINENUM p_max;            /* max allowed value of p_end */
  50. Xstatic LINENUM p_context = 3;        /* # of context lines */
  51. Xstatic LINENUM p_input_line = 0;    /* current line # from patch file */
  52. Xstatic char **p_line = Null(char**);    /* the text of the hunk */
  53. Xstatic short *p_len = Null(short*);    /* length of each line */
  54. Xstatic char *p_char = Nullch;        /* +, -, and ! */
  55. Xstatic int hunkmax = INITHUNKMAX;    /* size of above arrays to begin with */
  56. Xstatic int p_indent;            /* indent to patch */
  57. Xstatic LINENUM p_base;            /* where to intuit this time */
  58. Xstatic LINENUM p_start;            /* where intuit found a patch */
  59. X
  60. X/* Prepare to look for the next patch in the patch file. */
  61. X
  62. Xvoid
  63. Xre_patch()
  64. X{
  65. X    p_first = Nulline;
  66. X    p_newfirst = Nulline;
  67. X    p_ptrn_lines = Nulline;
  68. X    p_repl_lines = Nulline;
  69. X    p_end = (LINENUM)-1;
  70. X    p_max = Nulline;
  71. X    p_indent = 0;
  72. X}
  73. X
  74. X/* Open the patch file at the beginning of time. */
  75. X
  76. Xvoid
  77. Xopen_patch_file(filename)
  78. Xchar *filename;
  79. X{
  80. X    if (filename == Nullch || !*filename || strEQ(filename, "-")) {
  81. X    pfp = fopen(TMPPATNAME, "w");
  82. X    if (pfp == Nullfp)
  83. X        fatal2("patch: can't create %s.\n", TMPPATNAME);
  84. X    while (fgets(buf, sizeof buf, stdin) != Nullch)
  85. X        fputs(buf, pfp);
  86. X    Fclose(pfp);
  87. X    filename = TMPPATNAME;
  88. X    }
  89. X    pfp = fopen(filename, "r");
  90. X    if (pfp == Nullfp)
  91. X    fatal2("patch file %s not found\n", filename);
  92. X    Fstat(fileno(pfp), &filestat);
  93. X    p_filesize = filestat.st_size;
  94. X    next_intuit_at(0L);            /* start at the beginning */
  95. X    set_hunkmax();
  96. X}
  97. X
  98. X/* Make sure our dynamically realloced tables are malloced to begin with. */
  99. X
  100. Xvoid
  101. Xset_hunkmax()
  102. X{
  103. X#ifndef lint
  104. X    if (p_line == Null(char**))
  105. X    p_line = (char**) malloc((MEM)hunkmax * sizeof(char *));
  106. X    if (p_len == Null(short*))
  107. X    p_len  = (short*) malloc((MEM)hunkmax * sizeof(short));
  108. X#endif
  109. X    if (p_char == Nullch)
  110. X    p_char = (char*)  malloc((MEM)hunkmax * sizeof(char));
  111. X}
  112. X
  113. X/* Enlarge the arrays containing the current hunk of patch. */
  114. X
  115. Xvoid
  116. Xgrow_hunkmax()
  117. X{
  118. X    hunkmax *= 2;
  119. X    /* 
  120. X     * Note that on most systems, only the p_line array ever gets fresh memory
  121. X     * since p_len can move into p_line's old space, and p_char can move into
  122. X     * p_len's old space.  Not on PDP-11's however.  But it doesn't matter.
  123. X     */
  124. X    assert(p_line != Null(char**) && p_len != Null(short*) && p_char != Nullch);
  125. X#ifndef lint
  126. X    p_line = (char**) realloc((char*)p_line, (MEM)hunkmax * sizeof(char *));
  127. X    p_len  = (short*) realloc((char*)p_len,  (MEM)hunkmax * sizeof(short));
  128. X    p_char = (char*)  realloc((char*)p_char, (MEM)hunkmax * sizeof(char));
  129. X#endif
  130. X    if (p_line != Null(char**) && p_len != Null(short*) && p_char != Nullch)
  131. X    return;
  132. X    if (!using_plan_a)
  133. X    fatal1("patch: out of memory (grow_hunkmax)\n");
  134. X    out_of_mem = TRUE;        /* whatever is null will be allocated again */
  135. X                /* from within plan_a(), of all places */
  136. X}
  137. X
  138. X/* True if the remainder of the patch file contains a diff of some sort. */
  139. X
  140. Xbool
  141. Xthere_is_another_patch()
  142. X{
  143. X    if (p_base != 0L && p_base >= p_filesize) {
  144. X    if (verbose)
  145. X        say1("done\n");
  146. X    return FALSE;
  147. X    }
  148. X    if (verbose)
  149. X    say1("Hmm...");
  150. X    diff_type = intuit_diff_type();
  151. X    if (!diff_type) {
  152. X    if (p_base != 0L) {
  153. X        if (verbose)
  154. X        say1("  Ignoring the trailing garbage.\ndone\n");
  155. X    }
  156. X    else
  157. X        say1("  I can't seem to find a patch in there anywhere.\n");
  158. X    return FALSE;
  159. X    }
  160. X    if (verbose)
  161. X    say3("  %sooks like %s to me...\n",
  162. X        (p_base == 0L ? "L" : "The next patch l"),
  163. X        diff_type == CONTEXT_DIFF ? "a context diff" :
  164. X        diff_type == NEW_CONTEXT_DIFF ? "a new-style context diff" :
  165. X        diff_type == NORMAL_DIFF ? "a normal diff" :
  166. X        "an ed script" );
  167. X    if (p_indent && verbose)
  168. X    say3("(Patch is indented %d space%s.)\n", p_indent, p_indent==1?"":"s");
  169. X    skip_to(p_start);
  170. X    while (filearg[0] == Nullch) {
  171. X    if (force) {
  172. X        say1("No file to patch.  Skipping...\n");
  173. X        filearg[0] = savestr(bestguess);
  174. X        return TRUE;
  175. X    }
  176. X    ask1("File to patch: ");
  177. X    if (*buf != '\n') {
  178. X        if (bestguess)
  179. X        free(bestguess);
  180. X        bestguess = savestr(buf);
  181. X        filearg[0] = fetchname(buf, 0, FALSE);
  182. X    }
  183. X    if (filearg[0] == Nullch) {
  184. X        ask1("No file found--skip this patch? [n] ");
  185. X        if (*buf != 'y') {
  186. X        continue;
  187. X        }
  188. X        if (verbose)
  189. X        say1("Skipping patch...\n");
  190. X        filearg[0] = fetchname(bestguess, 0, TRUE);
  191. X        skip_rest_of_patch = TRUE;
  192. X        return TRUE;
  193. X    }
  194. X    }
  195. X    return TRUE;
  196. X}
  197. X
  198. X/* Determine what kind of diff is in the remaining part of the patch file. */
  199. X
  200. Xint
  201. Xintuit_diff_type()
  202. X{
  203. X    Reg4 long this_line = 0;
  204. X    Reg5 long previous_line;
  205. X    Reg6 long first_command_line = -1;
  206. X    Reg7 bool last_line_was_command = FALSE;
  207. X    Reg8 bool this_is_a_command = FALSE;
  208. X    Reg9 bool stars_last_line = FALSE;
  209. X    Reg10 bool stars_this_line = FALSE;
  210. X    Reg3 int indent;
  211. X    Reg1 char *s;
  212. X    Reg2 char *t;
  213. X    char *indtmp = Nullch;
  214. X    char *oldtmp = Nullch;
  215. X    char *newtmp = Nullch;
  216. X    char *indname = Nullch;
  217. X    char *oldname = Nullch;
  218. X    char *newname = Nullch;
  219. X    Reg11 int retval;
  220. X    bool no_filearg = (filearg[0] == Nullch);
  221. X
  222. X    ok_to_create_file = FALSE;
  223. X    Fseek(pfp, p_base, 0);
  224. X    for (;;) {
  225. X    previous_line = this_line;
  226. X    last_line_was_command = this_is_a_command;
  227. X    stars_last_line = stars_this_line;
  228. X    this_line = ftell(pfp);
  229. X    indent = 0;
  230. X    if (fgets(buf, sizeof buf, pfp) == Nullch) {
  231. X        if (first_command_line >= 0L) {
  232. X                    /* nothing but deletes!? */
  233. X        p_start = first_command_line;
  234. X        retval = ED_DIFF;
  235. X        goto scan_exit;
  236. X        }
  237. X        else {
  238. X        p_start = this_line;
  239. X        retval = 0;
  240. X        goto scan_exit;
  241. X        }
  242. X    }
  243. X    for (s = buf; *s == ' ' || *s == '\t'; s++) {
  244. X        if (*s == '\t')
  245. X        indent += 8 - (indent % 8);
  246. X        else
  247. X        indent++;
  248. X    }
  249. X    for (t=s; isdigit(*t) || *t == ','; t++) ; 
  250. X    this_is_a_command = (isdigit(*s) &&
  251. X      (*t == 'd' || *t == 'c' || *t == 'a') );
  252. X    if (first_command_line < 0L && this_is_a_command) { 
  253. X        first_command_line = this_line;
  254. X        p_indent = indent;        /* assume this for now */
  255. X    }
  256. X    if (!stars_last_line && strnEQ(s, "*** ", 4))
  257. X        oldtmp = savestr(s+4);
  258. X    else if (strnEQ(s, "--- ", 4))
  259. X        newtmp = savestr(s+4);
  260. X    else if (strnEQ(s, "Index:", 6))
  261. X        indtmp = savestr(s+6);
  262. X    else if (strnEQ(s, "Prereq:", 7)) {
  263. X        for (t=s+7; isspace(*t); t++) ;
  264. X        revision = savestr(t);
  265. X        for (t=revision; *t && !isspace(*t); t++) ;
  266. X        *t = '\0';
  267. X        if (!*revision) {
  268. X        free(revision);
  269. X        revision = Nullch;
  270. X        }
  271. X    }
  272. X    if ((!diff_type || diff_type == ED_DIFF) &&
  273. X      first_command_line >= 0L &&
  274. X      strEQ(s, ".\n") ) {
  275. X        p_indent = indent;
  276. X        p_start = first_command_line;
  277. X        retval = ED_DIFF;
  278. X        goto scan_exit;
  279. X    }
  280. X    stars_this_line = strnEQ(s, "********", 8);
  281. X    if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line &&
  282. X         strnEQ(s, "*** ", 4)) {
  283. X        if (!atol(s+4))
  284. X        ok_to_create_file = TRUE;
  285. X        /* if this is a new context diff the character just before */
  286. X        /* the newline is a '*'. */
  287. X        while (*s != '\n')
  288. X        s++;
  289. X        p_indent = indent;
  290. X        p_start = previous_line;
  291. X        retval = (*(s-1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF);
  292. X        goto scan_exit;
  293. X    }
  294. X    if ((!diff_type || diff_type == NORMAL_DIFF) && 
  295. X      last_line_was_command &&
  296. X      (strnEQ(s, "< ", 2) || strnEQ(s, "> ", 2)) ) {
  297. X        p_start = previous_line;
  298. X        p_indent = indent;
  299. X        retval = NORMAL_DIFF;
  300. X        goto scan_exit;
  301. X    }
  302. X    }
  303. X  scan_exit:
  304. X    if (no_filearg) {
  305. X    if (indtmp != Nullch)
  306. X        indname = fetchname(indtmp, strippath, ok_to_create_file);
  307. X    if (oldtmp != Nullch)
  308. X        oldname = fetchname(oldtmp, strippath, ok_to_create_file);
  309. X    if (newtmp != Nullch)
  310. X        newname = fetchname(newtmp, strippath, ok_to_create_file);
  311. X    if (oldname && newname) {
  312. X        if (strlen(oldname) < strlen(newname))
  313. X        filearg[0] = savestr(oldname);
  314. X        else
  315. X        filearg[0] = savestr(newname);
  316. X    }
  317. X    else if (oldname)
  318. X        filearg[0] = savestr(oldname);
  319. X    else if (newname)
  320. X        filearg[0] = savestr(newname);
  321. X    else if (indname)
  322. X        filearg[0] = savestr(indname);
  323. X    }
  324. X    if (bestguess) {
  325. X    free(bestguess);
  326. X    bestguess = Nullch;
  327. X    }
  328. X    if (filearg[0] != Nullch)
  329. X    bestguess = savestr(filearg[0]);
  330. X    else if (indtmp != Nullch)
  331. X    bestguess = fetchname(indtmp, strippath, TRUE);
  332. X    else {
  333. X    if (oldtmp != Nullch)
  334. X        oldname = fetchname(oldtmp, strippath, TRUE);
  335. X    if (newtmp != Nullch)
  336. X        newname = fetchname(newtmp, strippath, TRUE);
  337. X    if (oldname && newname) {
  338. X        if (strlen(oldname) < strlen(newname))
  339. X        bestguess = savestr(oldname);
  340. X        else
  341. X        bestguess = savestr(newname);
  342. X    }
  343. X    else if (oldname)
  344. X        bestguess = savestr(oldname);
  345. X    else if (newname)
  346. X        bestguess = savestr(newname);
  347. X    }
  348. X    if (indtmp != Nullch)
  349. X    free(indtmp);
  350. X    if (oldtmp != Nullch)
  351. X    free(oldtmp);
  352. X    if (newtmp != Nullch)
  353. X    free(newtmp);
  354. X    if (indname != Nullch)
  355. X    free(indname);
  356. X    if (oldname != Nullch)
  357. X    free(oldname);
  358. X    if (newname != Nullch)
  359. X    free(newname);
  360. X    return retval;
  361. X}
  362. X
  363. X/* Remember where this patch ends so we know where to start up again. */
  364. X
  365. Xvoid
  366. Xnext_intuit_at(file_pos)
  367. Xlong file_pos;
  368. X{
  369. X    p_base = file_pos;
  370. X}
  371. X
  372. X/* Basically a verbose fseek() to the actual diff listing. */
  373. X
  374. Xvoid
  375. Xskip_to(file_pos)
  376. Xlong file_pos;
  377. X{
  378. X    char *ret;
  379. X
  380. X    assert(p_base <= file_pos);
  381. X    if (verbose && p_base < file_pos) {
  382. X    Fseek(pfp, p_base, 0);
  383. X    say1("The text leading up to this was:\n--------------------------\n");
  384. X    while (ftell(pfp) < file_pos) {
  385. X        ret = fgets(buf, sizeof buf, pfp);
  386. X        assert(ret != Nullch);
  387. X        say2("|%s", buf);
  388. X    }
  389. X    say1("--------------------------\n");
  390. X    }
  391. X    else
  392. X    Fseek(pfp, file_pos, 0);
  393. X}
  394. X
  395. X/* True if there is more of the current diff listing to process. */
  396. X
  397. Xbool
  398. Xanother_hunk()
  399. X{
  400. X    Reg1 char *s;
  401. X    Reg8 char *ret;
  402. X    Reg2 int context = 0;
  403. X
  404. X    while (p_end >= 0) {
  405. X    free(p_line[p_end]);        /* Changed from postdecrement */
  406. X    p_end--;            /* by Keenan Ross for BSD2.9  */
  407. X    }
  408. X    assert(p_end == -1);
  409. X
  410. X    p_max = hunkmax;            /* gets reduced when --- found */
  411. X    if (diff_type == CONTEXT_DIFF || diff_type == NEW_CONTEXT_DIFF) {
  412. X    long line_beginning = ftell(pfp);
  413. X                    /* file pos of the current line */
  414. X    LINENUM repl_beginning = 0;    /* index of --- line */
  415. X    Reg4 LINENUM fillcnt = 0;    /* #lines of missing ptrn or repl */
  416. X    Reg5 LINENUM fillsrc;        /* index of first line to copy */
  417. X    Reg6 LINENUM filldst;        /* index of first missing line */
  418. X    bool ptrn_spaces_eaten = FALSE;    /* ptrn was slightly misformed */
  419. X    Reg9 bool repl_could_be_missing = TRUE;
  420. X                    /* no + or ! lines in this hunk */
  421. X    bool repl_missing = FALSE;    /* we are now backtracking */
  422. X    long repl_backtrack_position = 0;
  423. X                    /* file pos of first repl line */
  424. X    Reg7 LINENUM ptrn_copiable = 0;
  425. X                    /* # of copiable lines in ptrn */
  426. X
  427. X    ret = pgets(buf, sizeof buf, pfp);
  428. X    if (ret == Nullch || strnNE(buf, "********", 8)) {
  429. X        next_intuit_at(line_beginning);
  430. X        return FALSE;
  431. X    }
  432. X    p_context = 100;
  433. X    while (p_end < p_max) {
  434. X        line_beginning = ftell(pfp);
  435. X        ret = pgets(buf, sizeof buf, pfp);
  436. X        if (ret == Nullch) {
  437. X        if (p_max - p_end < 4)
  438. X            Strcpy(buf, "  \n");  /* assume blank lines got chopped */
  439. X        else {
  440. X            if (repl_beginning && repl_could_be_missing) {
  441. X            repl_missing = TRUE;
  442. X            goto hunk_done;
  443. X            }
  444. X            fatal1("Unexpected end of file in patch.\n");
  445. X        }
  446. X        }
  447. X        p_input_line++;
  448. X        p_char[++p_end] = *buf;
  449. X        p_line[p_end] = Nullch;
  450. X        switch (*buf) {
  451. X        case '*':
  452. X        if (strnEQ(buf, "********", 8)) {
  453. X            if (repl_beginning && repl_could_be_missing) {
  454. X            repl_missing = TRUE;
  455. X            goto hunk_done;
  456. X            }
  457. X            else
  458. X            fatal2("Unexpected end of hunk at line %ld.\n",
  459. X                p_input_line);
  460. X        }
  461. X        if (p_end != 0) {
  462. X            if (repl_beginning && repl_could_be_missing) {
  463. X            repl_missing = TRUE;
  464. X            goto hunk_done;
  465. X            }
  466. X            fatal3("Unexpected *** at line %ld: %s", p_input_line, buf);
  467. X        }
  468. X        context = 0;
  469. X        p_line[p_end] = savestr(buf);
  470. X        if (out_of_mem) {
  471. X            p_end--;
  472. X            return FALSE;
  473. X        }
  474. X        for (s=buf; *s && !isdigit(*s); s++) ;
  475. X        if (!*s)
  476. X            goto malformed;
  477. X        p_first = (LINENUM) atol(s);
  478. X        while (isdigit(*s)) s++;
  479. X        if (*s == ',') {
  480. X            for (; *s && !isdigit(*s); s++) ;
  481. X            if (!*s)
  482. X            goto malformed;
  483. X            p_ptrn_lines = ((LINENUM)atol(s)) - p_first + 1;
  484. X        }
  485. X        else if (p_first)
  486. X            p_ptrn_lines = 1;
  487. X        else {
  488. X            p_ptrn_lines = 0;
  489. X            p_first = 1;
  490. X        }
  491. X        break;
  492. X        case '-':
  493. X        if (buf[1] == '-') {
  494. X            if (p_end != p_ptrn_lines + 1 &&
  495. X            p_end != p_ptrn_lines + 2) {
  496. X            if (p_end == 1) {
  497. X                /* `old' lines were omitted - set up to fill */
  498. X                /* them in from 'new' context lines. */
  499. X                p_end = p_ptrn_lines + 1;
  500. X                fillsrc = p_end + 1;
  501. X                filldst = 1;
  502. X                fillcnt = p_ptrn_lines;
  503. X            }
  504. X            else {
  505. X                if (repl_beginning && repl_could_be_missing){
  506. X                repl_missing = TRUE;
  507. X                goto hunk_done;
  508. X                }
  509. X                fatal3("Unexpected --- at line %ld: %s",
  510. X                p_input_line, buf);
  511. X            }
  512. X            }
  513. X            repl_beginning = p_end;
  514. X            repl_backtrack_position = ftell(pfp);
  515. X            p_line[p_end] = savestr(buf);
  516. X            if (out_of_mem) {
  517. X            p_end--;
  518. X            return FALSE;
  519. X            }
  520. X            p_char[p_end] = '=';
  521. X            for (s=buf; *s && !isdigit(*s); s++) ;
  522. X            if (!*s)
  523. X            goto malformed;
  524. X            p_newfirst = (LINENUM) atol(s);
  525. X            while (isdigit(*s)) s++;
  526. X            if (*s == ',') {
  527. X            for (; *s && !isdigit(*s); s++) ;
  528. X            if (!*s)
  529. X                goto malformed;
  530. X            p_repl_lines = ((LINENUM)atol(s)) - p_newfirst + 1;
  531. X            }
  532. X            else if (p_newfirst)
  533. X            p_repl_lines = 1;
  534. X            else {
  535. X            p_repl_lines = 0;
  536. X            p_newfirst = 1;
  537. X            }
  538. X            p_max = p_repl_lines + p_end;
  539. X            if (p_max > MAXHUNKSIZE)
  540. X            fatal4("Hunk too large (%ld lines) at line %ld: %s",
  541. X                  p_max, p_input_line, buf);
  542. X            while (p_max >= hunkmax)
  543. X            grow_hunkmax();
  544. X            if (p_repl_lines != ptrn_copiable)
  545. X            repl_could_be_missing = FALSE;
  546. X            break;
  547. X        }
  548. X        goto change_line;
  549. X        case '+':  case '!':
  550. X        repl_could_be_missing = FALSE;
  551. X          change_line:
  552. X        if (!isspace(buf[1]) && buf[1] != '>' && buf[1] != '<' &&
  553. X          repl_beginning && repl_could_be_missing) {
  554. X            repl_missing = TRUE;
  555. X            goto hunk_done;
  556. X        }
  557. X        if (context > 0) {
  558. X            if (context < p_context)
  559. X            p_context = context;
  560. X            context = -1000;
  561. X        }
  562. X        p_line[p_end] = savestr(buf+2);
  563. X        if (out_of_mem) {
  564. X            p_end--;
  565. X            return FALSE;
  566. X        }
  567. X        break;
  568. X        case '\t': case '\n':    /* assume the 2 spaces got eaten */
  569. X        if (repl_beginning && repl_could_be_missing &&
  570. X          (!ptrn_spaces_eaten || diff_type == NEW_CONTEXT_DIFF) ) {
  571. X            repl_missing = TRUE;
  572. X            goto hunk_done;
  573. X        }
  574. X        p_line[p_end] = savestr(buf);
  575. X        if (out_of_mem) {
  576. X            p_end--;
  577. X            return FALSE;
  578. X        }
  579. X        if (p_end != p_ptrn_lines + 1) {
  580. X            ptrn_spaces_eaten |= (repl_beginning != 0);
  581. X            context++;
  582. X            if (!repl_beginning)
  583. X            ptrn_copiable++;
  584. X            p_char[p_end] = ' ';
  585. X        }
  586. X        break;
  587. X        case ' ':
  588. X        if (!isspace(buf[1]) &&
  589. X          repl_beginning && repl_could_be_missing) {
  590. X            repl_missing = TRUE;
  591. X            goto hunk_done;
  592. X        }
  593. X        context++;
  594. X        if (!repl_beginning)
  595. X            ptrn_copiable++;
  596. X        p_line[p_end] = savestr(buf+2);
  597. X        if (out_of_mem) {
  598. X            p_end--;
  599. X            return FALSE;
  600. X        }
  601. X        break;
  602. X        default:
  603. X        if (repl_beginning && repl_could_be_missing) {
  604. X            repl_missing = TRUE;
  605. X            goto hunk_done;
  606. X        }
  607. X        goto malformed;
  608. X        }
  609. X        /* set up p_len for strncmp() so we don't have to */
  610. X        /* assume null termination */
  611. X        if (p_line[p_end])
  612. X        p_len[p_end] = strlen(p_line[p_end]);
  613. X        else
  614. X        p_len[p_end] = 0;
  615. X    }
  616. X    
  617. X    hunk_done:
  618. X    if (p_end >=0 && !repl_beginning)
  619. X        fatal2("No --- found in patch at line %ld\n", pch_hunk_beg());
  620. X
  621. X    if (repl_missing) {
  622. X        
  623. X        /* reset state back to just after --- */
  624. X        for (p_end--; p_end > repl_beginning; p_end--)
  625. X        free(p_line[p_end]);
  626. X        Fseek(pfp, repl_backtrack_position, 0);
  627. X        
  628. X        /* redundant 'new' context lines were omitted - set */
  629. X        /* up to fill them in from the old file context */
  630. X        fillsrc = 1;
  631. X        filldst = repl_beginning+1;
  632. X        fillcnt = p_repl_lines;
  633. X        p_end = p_max;
  634. X    }
  635. X
  636. X    if (diff_type == CONTEXT_DIFF &&
  637. X      (fillcnt || ptrn_copiable > 2*p_context) ) {
  638. X        if (verbose)
  639. X        say1("\
  640. X(Fascinating--this is really a new-style context diff but without the telltale\n\
  641. Xextra asterisks on the *** line that usually indicate the new style...)\n");
  642. X        diff_type = NEW_CONTEXT_DIFF;
  643. X    }
  644. X    
  645. X    /* if there were omitted context lines, fill them in now */
  646. X    if (fillcnt) {
  647. X        while (fillcnt-- > 0) {
  648. X        while (p_char[fillsrc] != ' ')
  649. X            fillsrc++;
  650. X        p_line[filldst] = p_line[fillsrc];
  651. X        p_char[filldst] = p_char[fillsrc];
  652. X        p_len[filldst] = p_len[fillsrc];
  653. X        fillsrc++; filldst++;
  654. X        }
  655. X        while (fillsrc <= p_end && p_char[fillsrc] != ' ')
  656. X        fillsrc++;
  657. X#ifdef DEBUGGING
  658. X        if (debug & 64)
  659. X        printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n",
  660. X            fillsrc,filldst,repl_beginning,p_end+1);
  661. X#endif
  662. X        assert(fillsrc==p_end+1 || fillsrc==repl_beginning);
  663. X        assert(filldst==p_end+1 || filldst==repl_beginning);
  664. X    }
  665. X    }
  666. X    else {                /* normal diff--fake it up */
  667. X    char hunk_type;
  668. X    Reg3 int i;
  669. X    LINENUM min, max;
  670. X    long line_beginning = ftell(pfp);
  671. X
  672. X    p_context = 0;
  673. X    ret = pgets(buf, sizeof buf, pfp);
  674. X    p_input_line++;
  675. X    if (ret == Nullch || !isdigit(*buf)) {
  676. X        next_intuit_at(line_beginning);
  677. X        return FALSE;
  678. X    }
  679. X    p_first = (LINENUM)atol(buf);
  680. X    for (s=buf; isdigit(*s); s++) ;
  681. X    if (*s == ',') {
  682. X        p_ptrn_lines = (LINENUM)atol(++s) - p_first + 1;
  683. X        while (isdigit(*s)) s++;
  684. X    }
  685. X    else
  686. X        p_ptrn_lines = (*s != 'a');
  687. X    hunk_type = *s;
  688. X    if (hunk_type == 'a')
  689. X        p_first++;            /* do append rather than insert */
  690. X    min = (LINENUM)atol(++s);
  691. X    for (; isdigit(*s); s++) ;
  692. X    if (*s == ',')
  693. X        max = (LINENUM)atol(++s);
  694. X    else
  695. X        max = min;
  696. X    if (hunk_type == 'd')
  697. X        min++;
  698. X    p_end = p_ptrn_lines + 1 + max - min + 1;
  699. X    if (p_end > MAXHUNKSIZE)
  700. X        fatal4("Hunk too large (%ld lines) at line %ld: %s",
  701. X          p_end, p_input_line, buf);
  702. X    while (p_end >= hunkmax)
  703. X        grow_hunkmax();
  704. X    p_newfirst = min;
  705. X    p_repl_lines = max - min + 1;
  706. X    Sprintf(buf, "*** %ld,%ld\n", p_first, p_first + p_ptrn_lines - 1);
  707. X    p_line[0] = savestr(buf);
  708. X    if (out_of_mem) {
  709. X        p_end = -1;
  710. X        return FALSE;
  711. X    }
  712. X    p_char[0] = '*';
  713. X    for (i=1; i<=p_ptrn_lines; i++) {
  714. X        ret = pgets(buf, sizeof buf, pfp);
  715. X        p_input_line++;
  716. X        if (ret == Nullch)
  717. X        fatal2("Unexpected end of file in patch at line %ld.\n",
  718. X          p_input_line);
  719. X        if (*buf != '<')
  720. X        fatal2("< expected at line %ld of patch.\n", p_input_line);
  721. X        p_line[i] = savestr(buf+2);
  722. X        if (out_of_mem) {
  723. X        p_end = i-1;
  724. X        return FALSE;
  725. X        }
  726. X        p_len[i] = strlen(p_line[i]);
  727. X        p_char[i] = '-';
  728. X    }
  729. X    if (hunk_type == 'c') {
  730. X        ret = pgets(buf, sizeof buf, pfp);
  731. X        p_input_line++;
  732. X        if (ret == Nullch)
  733. X        fatal2("Unexpected end of file in patch at line %ld.\n",
  734. X            p_input_line);
  735. X        if (*buf != '-')
  736. X        fatal2("--- expected at line %ld of patch.\n", p_input_line);
  737. X    }
  738. X    Sprintf(buf, "--- %ld,%ld\n", min, max);
  739. X    p_line[i] = savestr(buf);
  740. X    if (out_of_mem) {
  741. X        p_end = i-1;
  742. X        return FALSE;
  743. X    }
  744. X    p_char[i] = '=';
  745. X    for (i++; i<=p_end; i++) {
  746. X        ret = pgets(buf, sizeof buf, pfp);
  747. X        p_input_line++;
  748. X        if (ret == Nullch)
  749. X        fatal2("Unexpected end of file in patch at line %ld.\n",
  750. X            p_input_line);
  751. X        if (*buf != '>')
  752. X        fatal2("> expected at line %ld of patch.\n", p_input_line);
  753. X        p_line[i] = savestr(buf+2);
  754. X        if (out_of_mem) {
  755. X        p_end = i-1;
  756. X        return FALSE;
  757. X        }
  758. X        p_len[i] = strlen(p_line[i]);
  759. X        p_char[i] = '+';
  760. X    }
  761. X    }
  762. X    if (reverse)            /* backwards patch? */
  763. X    if (!pch_swap())
  764. X        say1("Not enough memory to swap next hunk!\n");
  765. X#ifdef DEBUGGING
  766. X    if (debug & 2) {
  767. X    int i;
  768. X    char special;
  769. X
  770. X    for (i=0; i <= p_end; i++) {
  771. X        if (i == p_ptrn_lines)
  772. X        special = '^';
  773. X        else
  774. X        special = ' ';
  775. X        fprintf(stderr, "%3d %c %c %s", i, p_char[i], special, p_line[i]);
  776. X        Fflush(stderr);
  777. X    }
  778. X    }
  779. X#endif
  780. X    if (p_end+1 < hunkmax)    /* paranoia reigns supreme... */
  781. X    p_char[p_end+1] = '^';  /* add a stopper for apply_hunk */
  782. X    return TRUE;
  783. X
  784. Xmalformed:
  785. X    fatal3("Malformed patch at line %ld: %s", p_input_line, buf);
  786. X        /* about as informative as "Syntax error" in C */
  787. X    return FALSE;    /* for lint */
  788. X}
  789. X
  790. X/* Input a line from the patch file, worrying about indentation. */
  791. X
  792. Xchar *
  793. Xpgets(bf,sz,fp)
  794. Xchar *bf;
  795. Xint sz;
  796. XFILE *fp;
  797. X{
  798. X    char *ret = fgets(bf, sz, fp);
  799. X    Reg1 char *s;
  800. X    Reg2 int indent = 0;
  801. X
  802. X    if (p_indent && ret != Nullch) {
  803. X    for (s=buf; indent < p_indent && (*s == ' ' || *s == '\t'); s++) {
  804. X        if (*s == '\t')
  805. X        indent += 8 - (indent % 7);
  806. X        else
  807. X        indent++;
  808. X    }
  809. X    if (buf != s)
  810. X        Strcpy(buf, s);
  811. X    }
  812. X    return ret;
  813. X}
  814. X
  815. X/* Reverse the old and new portions of the current hunk. */
  816. X
  817. Xbool
  818. Xpch_swap()
  819. X{
  820. X    char **tp_line;        /* the text of the hunk */
  821. X    short *tp_len;        /* length of each line */
  822. X    char *tp_char;        /* +, -, and ! */
  823. X    Reg1 LINENUM i;
  824. X    Reg2 LINENUM n;
  825. X    bool blankline = FALSE;
  826. X    Reg3 char *s;
  827. X
  828. X    i = p_first;
  829. X    p_first = p_newfirst;
  830. X    p_newfirst = i;
  831. X    
  832. X    /* make a scratch copy */
  833. X
  834. X    tp_line = p_line;
  835. X    tp_len = p_len;
  836. X    tp_char = p_char;
  837. X    p_line = Null(char**);    /* force set_hunkmax to allocate again */
  838. X    p_len = Null(short*);
  839. X    p_char = Nullch;
  840. X    set_hunkmax();
  841. X    if (p_line == Null(char**) || p_len == Null(short*) || p_char == Nullch) {
  842. X#ifndef lint
  843. X    if (p_line == Null(char**))
  844. X        free((char*)p_line);
  845. X    p_line = tp_line;
  846. X    if (p_len == Null(short*))
  847. X        free((char*)p_len);
  848. X    p_len = tp_len;
  849. X#endif
  850. X    if (p_char == Nullch)
  851. X        free((char*)p_char);
  852. X    p_char = tp_char;
  853. X    return FALSE;        /* not enough memory to swap hunk! */
  854. X    }
  855. X
  856. X    /* now turn the new into the old */
  857. X
  858. X    i = p_ptrn_lines + 1;
  859. X    if (tp_char[i] == '\n') {        /* account for possible blank line */
  860. X    blankline = TRUE;
  861. X    i++;
  862. X    }
  863. X    for (n=0; i <= p_end; i++,n++) {
  864. X    p_line[n] = tp_line[i];
  865. X    p_char[n] = tp_char[i];
  866. X    if (p_char[n] == '+')
  867. X        p_char[n] = '-';
  868. X    p_len[n] = tp_len[i];
  869. X    }
  870. X    if (blankline) {
  871. X    i = p_ptrn_lines + 1;
  872. X    p_line[n] = tp_line[i];
  873. X    p_char[n] = tp_char[i];
  874. X    p_len[n] = tp_len[i];
  875. X    n++;
  876. X    }
  877. X    assert(p_char[0] == '=');
  878. X    p_char[0] = '*';
  879. X    for (s=p_line[0]; *s; s++)
  880. X    if (*s == '-')
  881. X        *s = '*';
  882. X
  883. X    /* now turn the old into the new */
  884. X
  885. X    assert(tp_char[0] == '*');
  886. X    tp_char[0] = '=';
  887. X    for (s=tp_line[0]; *s; s++)
  888. X    if (*s == '*')
  889. X        *s = '-';
  890. X    for (i=0; n <= p_end; i++,n++) {
  891. X    p_line[n] = tp_line[i];
  892. X    p_char[n] = tp_char[i];
  893. X    if (p_char[n] == '-')
  894. X        p_char[n] = '+';
  895. X    p_len[n] = tp_len[i];
  896. X    }
  897. X    assert(i == p_ptrn_lines + 1);
  898. X    i = p_ptrn_lines;
  899. X    p_ptrn_lines = p_repl_lines;
  900. X    p_repl_lines = i;
  901. X#ifndef lint
  902. X    if (tp_line == Null(char**))
  903. X    free((char*)tp_line);
  904. X    if (tp_len == Null(short*))
  905. X    free((char*)tp_len);
  906. X#endif
  907. X    if (tp_char == Nullch)
  908. X    free((char*)tp_char);
  909. X    return TRUE;
  910. X}
  911. X
  912. X/* Return the specified line position in the old file of the old context. */
  913. X
  914. XLINENUM
  915. Xpch_first()
  916. X{
  917. X    return p_first;
  918. X}
  919. X
  920. X/* Return the number of lines of old context. */
  921. X
  922. XLINENUM
  923. Xpch_ptrn_lines()
  924. X{
  925. X    return p_ptrn_lines;
  926. X}
  927. X
  928. X/* Return the probable line position in the new file of the first line. */
  929. X
  930. XLINENUM
  931. Xpch_newfirst()
  932. X{
  933. X    return p_newfirst;
  934. X}
  935. X
  936. X/* Return the number of lines in the replacement text including context. */
  937. X
  938. XLINENUM
  939. Xpch_repl_lines()
  940. X{
  941. X    return p_repl_lines;
  942. X}
  943. X
  944. X/* Return the number of lines in the whole hunk. */
  945. X
  946. XLINENUM
  947. Xpch_end()
  948. X{
  949. X    return p_end;
  950. X}
  951. X
  952. X/* Return the number of context lines before the first changed line. */
  953. X
  954. XLINENUM
  955. Xpch_context()
  956. X{
  957. X    return p_context;
  958. X}
  959. X
  960. X/* Return the length of a particular patch line. */
  961. X
  962. Xshort
  963. Xpch_line_len(line)
  964. XLINENUM line;
  965. X{
  966. X    return p_len[line];
  967. X}
  968. X
  969. X/* Return the control character (+, -, *, !, etc) for a patch line. */
  970. X
  971. Xchar
  972. Xpch_char(line)
  973. XLINENUM line;
  974. X{
  975. X    return p_char[line];
  976. X}
  977. X
  978. X/* Return a pointer to a particular patch line. */
  979. X
  980. Xchar *
  981. Xpfetch(line)
  982. XLINENUM line;
  983. X{
  984. X    return p_line[line];
  985. X}
  986. X
  987. X/* Return where in the patch file this hunk began, for error messages. */
  988. X
  989. XLINENUM
  990. Xpch_hunk_beg()
  991. X{
  992. X    return p_input_line - p_end - 1;
  993. X}
  994. X
  995. !STUFFY!FUNK!
  996. echo Extracting Configure
  997. sed >Configure <<'!STUFFY!FUNK!' -e 's/X//'
  998. X#! /bin/sh
  999. X#
  1000. X# If these # comments don't work, trim them.  Don't worry about any other
  1001. X# shell scripts, Configure will trim # comments from them for you.
  1002. X#
  1003. X# Note: if you are running ksh, be sure to say "sh Configure".
  1004. X#
  1005. X# (If you are trying to port this package to a machine without sh, I would
  1006. X# suggest you cut out the prototypical config.h from the end of Configure
  1007. X# and edit it to reflect your system.  Some packages may include samples
  1008. X# of config.h for certain machines, so you might look for one of those.)
  1009. X#
  1010. X# $Header: Configure,v 2.0 86/09/17 15:32:58 lwall Exp $
  1011. X#
  1012. X# $Log:    Configure,v $
  1013. X# Revision 2.0  86/09/17  15:32:58  lwall
  1014. X# Baseline for netwide release.
  1015. X# 
  1016. X#
  1017. X# Yes, you may rip this off to use in other distribution packages.
  1018. X#
  1019. X# (Note: this Configure script was generated automatically.  Rather than
  1020. X# working with this copy of Configure, you may wish to get metaconfig.)
  1021. X
  1022. Xdefine='define'
  1023. Xundef='/*undef'
  1024. X
  1025. Xd_eunice=''
  1026. Xeunicefix=''
  1027. Xloclist=''
  1028. Xexpr=''
  1029. Xsed=''
  1030. Xecho=''
  1031. Xcat=''
  1032. Xrm=''
  1033. Xmv=''
  1034. Xcp=''
  1035. Xtail=''
  1036. Xtr=''
  1037. Xmkdir=''
  1038. Xsort=''
  1039. Xuniq=''
  1040. Xgrep=''
  1041. Xtrylist=''
  1042. Xtest=''
  1043. Xinews=''
  1044. Xegrep=''
  1045. Xmore=''
  1046. Xpg=''
  1047. XMcc=''
  1048. Xvi=''
  1049. Xmailx=''
  1050. XLog=''
  1051. XHeader=''
  1052. Xbin=''
  1053. Xcc=''
  1054. Xcontains=''
  1055. Xcpp=''
  1056. Xd_index=''
  1057. Xd_void=''
  1058. Xiandd=''
  1059. Xlibc=''
  1060. Xmansrc=''
  1061. Xmanext=''
  1062. Xn=''
  1063. Xc=''
  1064. Xpackage=''
  1065. Xregisters=''
  1066. Xreg1=''
  1067. Xreg2=''
  1068. Xreg3=''
  1069. Xreg4=''
  1070. Xreg5=''
  1071. Xreg6=''
  1072. Xreg7=''
  1073. Xreg8=''
  1074. Xreg9=''
  1075. Xreg10=''
  1076. Xreg11=''
  1077. Xreg12=''
  1078. Xreg13=''
  1079. Xreg14=''
  1080. Xreg15=''
  1081. Xreg16=''
  1082. Xspitshell=''
  1083. Xshsharp=''
  1084. Xsharpbang=''
  1085. Xstartsh=''
  1086. XCONFIG=''
  1087. X
  1088. Xpackage=patch
  1089. X
  1090. Xecho "Beginning of configuration questions for $package kit."
  1091. X: Eunice requires " " instead of "", can you believe it
  1092. Xecho " "
  1093. X
  1094. X: sanity checks
  1095. XPATH='.:/bin:/usr/bin:/usr/local/bin:/usr/ucb:/usr/local:/usr/lbin:/etc'
  1096. Xexport PATH || (echo "OOPS, this isn't sh.  Desperation time.  I will feed myself to sh."; sh $0; kill $$)
  1097. X
  1098. Xif test ! -t 0; then
  1099. X    echo "Say 'sh Configure', not 'sh <Configure'"
  1100. X    exit 1
  1101. Xfi
  1102. X
  1103. X: some greps do not return status, grrr.
  1104. Xecho "grimblepritz" >grimble
  1105. Xif grep blurfldyick grimble >/dev/null 2>&1 ; then
  1106. X    contains=contains
  1107. Xelse
  1108. X    if grep grimblepritz grimble >/dev/null 2>&1 ; then
  1109. X    contains=grep
  1110. X    else
  1111. X    contains=contains
  1112. X    fi
  1113. Xfi
  1114. Xrm -f grimble
  1115. X: the following should work in any shell
  1116. Xcase "$contains" in
  1117. Xcontains*)
  1118. X    echo " "
  1119. X    echo "AGH!  Grep doesn't return a status.  Attempting remedial action."
  1120. X    cat >contains <<'EOSS'
  1121. Xgrep "$1" "$2" >.greptmp && cat .greptmp && test -s .greptmp
  1122. XEOSS
  1123. Xchmod 755 contains
  1124. Xesac
  1125. X
  1126. X: first determine how to suppress newline on echo command
  1127. Xecho "Checking echo to see how to suppress newlines..."
  1128. X(echo "hi there\c" ; echo " ") >.echotmp
  1129. Xif $contains c .echotmp >/dev/null 2>&1 ; then
  1130. X    echo "...using -n."
  1131. X    n='-n'
  1132. X    c=''
  1133. Xelse
  1134. X    echo "...using \\\c"
  1135. X    echo "c."
  1136. X    n=''
  1137. X    c='\c'
  1138. Xfi
  1139. Xecho $n "Type carriage return to continue.  Your cursor should be here-->$c"
  1140. Xread ans
  1141. Xrm -f .echotmp
  1142. X
  1143. X: now set up to do reads with possible shell escape
  1144. X: if this does not work on your machine, 1,$ s/. myread/read ans/
  1145. Xcat <<EOSC >myread
  1146. Xans='!'
  1147. Xwhile expr "X\$ans" : "X!" >/dev/null; do
  1148. X    read ans
  1149. X    case "\$ans" in
  1150. X    !)
  1151. X    sh
  1152. X    echo " "
  1153. X    echo $n "\$rp $c"
  1154. X    ;;
  1155. X    !*)
  1156. X    set \`expr "X\$ans" : "X!\(.*\)\$"\`
  1157. X    sh -c "\$*"
  1158. X    echo " "
  1159. X    echo $n "\$rp $c"
  1160. X    ;;
  1161. X    esac
  1162. Xdone
  1163. Xrp='Your answer:'
  1164. XEOSC
  1165. X
  1166. X: general instructions
  1167. Xcat <<EOH
  1168. X 
  1169. XThis installation shell script will examine your system and ask you questions
  1170. Xto determine how $package and any auxiliary files should be installed.  If you
  1171. Xget stuck on a question, you may use a ! shell escape to start a subshell or
  1172. Xexecute a command.  Many of the questions will have default answers in
  1173. Xsquare brackets--typing carriage return will give you the default.
  1174. X
  1175. XOn some of the questions which ask for file or directory names you are
  1176. Xallowed to use the ~name construct to specify the login directory belonging
  1177. Xto "name", even if you don't have a shell which knows about that.  Questions
  1178. Xwhere this is allowed will be marked "(~name ok)".
  1179. XEOH
  1180. Xrp="[Type carriage return to continue]"
  1181. Xecho $n "$rp $c"
  1182. X. myread
  1183. Xcat <<EOH
  1184. XMuch effort has been expended to ensure that this shell script will run
  1185. Xon any Unix system.  If despite that it blows up on you, your best bet is
  1186. Xto edit Configure and run it again.  (Trying to install this package
  1187. Xwithout having run Configure may be well nigh impossible.)  Also, let me
  1188. X(lwall@sdcrdcf.UUCP) know how I blew it.
  1189. X
  1190. XThis installation script affects things in two ways: 1) it may do direct
  1191. Xvariable substitutions on some of the files included in this kit, and
  1192. X2) it builds a config.h file for inclusion in C programs.  You may edit
  1193. Xany of these files as the need arises after running this script.
  1194. X
  1195. XEOH
  1196. Xrp="[Type carriage return to continue]"
  1197. Xecho $n "$rp $c"
  1198. X. myread
  1199. X
  1200. X: get old answers, if there is a config file out there
  1201. Xif test -f config.sh; then
  1202. X    echo " "
  1203. X    rp="I see a config.sh file.  Did Configure make it on THIS system? [y]"
  1204. X    echo $n "$rp $c"
  1205. X    . myread
  1206. X    case "$ans" in
  1207. X    n*) echo "OK, I'll ignore it.";;
  1208. X    *)  echo "Fetching default answers from your old config.sh file..."
  1209. X        . config.sh
  1210. X    ;;
  1211. X    esac
  1212. Xfi
  1213. X
  1214. X: get list of predefined functions in a handy place
  1215. Xecho " "
  1216. Xif test -f /lib/libc.a; then
  1217. X    echo "Your C library is in /lib/libc.a.  You're normal."
  1218. X    libc=/lib/libc.a
  1219. Xelse
  1220. X    if test -f /usr/lib/libc.a; then
  1221. X    echo "Your C library is in /usr/lib/libc.a, of all places."
  1222. X    libc=/usr/lib/libc.a
  1223. X    else
  1224. X    if test -f "$libc"; then
  1225. X        echo "Your C library is in $libc, like you said before."
  1226. X    else
  1227. X        cat <<'EOM'
  1228. X 
  1229. XI can't seem to find your C library.  I've looked for /lib/libc.a and
  1230. X/usr/lib/libc.a, but neither of those are there.  What is the full name
  1231. XEOM
  1232. X        echo $n "of your C library? $c"
  1233. X        rp='C library full name?'
  1234. X        . myread
  1235. X        libc="$ans"
  1236. X    fi
  1237. X    fi
  1238. Xfi
  1239. Xecho " "
  1240. Xecho $n "Extracting names from $libc for later perusal...$c"
  1241. Xif ar t $libc > libc.list; then
  1242. X    echo "done"
  1243. Xelse
  1244. X    echo " "
  1245. X    echo "The archiver doesn't think $libc is a reasonable library."
  1246. X    exit 1
  1247. Xfi
  1248. X
  1249. X: make some quick guesses about what we are up against
  1250. Xecho " "
  1251. Xecho $n "Hmm...  $c"
  1252. Xif $contains SIGTSTP /usr/include/signal.h >/dev/null 2>&1 ; then
  1253. X    echo "Looks kind of like a BSD system, but we'll see..."
  1254. X    echo exit 0 >bsd
  1255. X    echo exit 1 >usg
  1256. X    echo exit 1 >v7
  1257. Xelse
  1258. X    if $contains fcntl libc.list >/dev/null 2>&1 ; then
  1259. X    echo "Looks kind of like a USG system, but we'll see..."
  1260. X    echo exit 1 >bsd
  1261. X    echo exit 0 >usg
  1262. X    echo exit 1 >v7
  1263. X    else
  1264. X    echo "Looks kind of like a version 7 system, but we'll see..."
  1265. X    echo exit 1 >bsd
  1266. X    echo exit 1 >usg
  1267. X    echo exit 0 >v7
  1268. X    fi
  1269. Xfi
  1270. Xif $contains vmssystem libc.list >/dev/null 2>&1 ; then
  1271. X    cat <<'EOI'
  1272. XThere is, however, a strange, musty smell in the air that reminds me of
  1273. Xsomething...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit.
  1274. XEOI
  1275. X    echo "exit 0" >eunice
  1276. X    eunicefix=unixtovms
  1277. X    d_eunice="$define"
  1278. X: it so happens the Eunice I know will not run shell scripts in Unix format
  1279. Xelse
  1280. X    echo " "
  1281. X    echo "Congratulations.  You aren't running Eunice."
  1282. X    eunicefix=':'
  1283. X    d_eunice="$undef"
  1284. X    echo "exit 1" >eunice
  1285. Xfi
  1286. Xchmod 755 bsd usg v7 eunice
  1287. X$eunicefix bsd usg v7 eunice
  1288. X
  1289. X: see if sh knows # comments
  1290. Xecho " "
  1291. Xecho "Checking your sh to see if it knows about # comments..."
  1292. Xif sh -c '#' >/dev/null 2>&1 ; then
  1293. X    echo "Your sh handles # comments correctly."
  1294. X    shsharp=true
  1295. X    spitshell=cat
  1296. X    echo " "
  1297. X    echo "Okay, let's see if #! works on this system..."
  1298. X    echo "#!/bin/echo hi" > try
  1299. X    $eunicefix try
  1300. X    chmod 755 try
  1301. X    try > today
  1302. X    if test -s today; then
  1303. X    echo "It does."
  1304. X    sharpbang='#!'
  1305. X    else
  1306. X    echo "#! /bin/echo hi" > try
  1307. X    $eunicefix try
  1308. X    chmod 755 try
  1309. X    try > today
  1310. X    if test -s today; then
  1311. X        echo "It does."
  1312. X        sharpbang='#! '
  1313. X    else
  1314. X        echo "It doesn't."
  1315. X        sharpbang=': use '
  1316. X    fi
  1317. X    fi
  1318. Xelse
  1319. X    echo "Your sh doesn't grok # comments--I will strip them later on."
  1320. X    shsharp=false
  1321. X    echo "exec grep -v '^#'" >spitshell
  1322. X    chmod 755 spitshell
  1323. X    $eunicefix spitshell
  1324. X    spitshell=`pwd`/spitshell
  1325. X    echo "I presume that if # doesn't work, #! won't work either!"
  1326. X    sharpbang=': use '
  1327. Xfi
  1328. X
  1329. X: figure out how to guarantee sh startup
  1330. Xecho " "
  1331. Xecho "Checking out how to guarantee sh startup..."
  1332. Xstartsh=$sharpbang'/bin/sh'
  1333. Xecho "Let's see if '$startsh' works..."
  1334. Xcat >try <<EOSS
  1335. X$startsh
  1336. Xset abc
  1337. Xtest "$?abc" != 1
  1338. XEOSS
  1339. X
  1340. Xchmod 755 try
  1341. X$eunicefix try
  1342. Xif try; then
  1343. X    echo "Yup, it does."
  1344. Xelse
  1345. X    echo "Nope.  You may have to fix up the shell scripts to make sure sh runs them."
  1346. Xfi
  1347. Xrm -f try today
  1348. X
  1349. X: find out where common programs are
  1350. Xecho " "
  1351. Xecho "Locating common programs..."
  1352. Xpth="/usr/ucb /bin /usr/bin /usr/local /usr/local/bin /usr/lbin /etc /usr/lib"
  1353. Xcat <<EOSC >loc
  1354. X$startsh
  1355. Xthing=\$1
  1356. Xshift
  1357. Xdflt=\$1
  1358. Xshift
  1359. Xfor dir in \$*; do
  1360. X    case "\$thing" in
  1361. X    .)
  1362. X    if test -d \$dir/\$thing; then
  1363. X        echo \$dir
  1364. X        exit 0
  1365. X    fi
  1366. X    ;;
  1367. X    *)
  1368. X    if test -f \$dir/\$thing; then
  1369. X        echo \$dir/\$thing
  1370. X        exit 0
  1371. X    fi
  1372. X    ;;
  1373. X    esac
  1374. Xdone
  1375. Xecho \$dflt
  1376. Xexit 1
  1377. XEOSC
  1378. Xchmod 755 loc
  1379. X$eunicefix loc
  1380. Xloclist="
  1381. Xexpr
  1382. Xsed
  1383. Xecho
  1384. Xcat
  1385. Xrm
  1386. Xgrep
  1387. X"
  1388. Xtrylist="
  1389. Xtest
  1390. XMcc
  1391. X"
  1392. Xfor file in $loclist; do
  1393. X    xxx=`loc $file $file $pth`
  1394. X    eval $file=$xxx
  1395. X    case "$xxx" in
  1396. X    /*)
  1397. X    echo $file is in $xxx.
  1398. X    ;;
  1399. X    *)
  1400. X    echo "I don't know where $file is.  I hope it's in everyone's PATH."
  1401. X    ;;
  1402. X    esac
  1403. Xdone
  1404. Xecho " "
  1405. Xecho "Don't worry if any of the following aren't found..."
  1406. Xans=offhand
  1407. Xfor file in $trylist; do
  1408. X    xxx=`loc $file $file $pth`
  1409. X    eval $file=$xxx
  1410. X    case "$xxx" in
  1411. X    /*)
  1412. X    echo $file is in $xxx.
  1413. X    ;;
  1414. X    *)
  1415. X    echo "I don't see $file out there, $ans."
  1416. X    ans=either
  1417. X    ;;
  1418. X    esac
  1419. Xdone
  1420. Xcase "$egrep" in
  1421. Xegrep)
  1422. X    echo "Substituting grep for egrep."
  1423. X    egrep=$grep
  1424. X    ;;
  1425. Xesac
  1426. Xcase "$test" in
  1427. Xtest)
  1428. X    echo "Hopefully test is built into your sh."
  1429. X    ;;
  1430. X/bin/test)
  1431. X    echo " "
  1432. X    echo $n 'Is your "test" built into sh? [n] (OK to guess) '"$c"
  1433. X    rp='test built into sh? [n]'
  1434. X    . myread
  1435. X    case "$ans" in
  1436. X    y*) test=test ;;
  1437. X    esac
  1438. X    ;;
  1439. X*)
  1440. X    test=test
  1441. X    ;;
  1442. Xesac
  1443. Xcase "$echo" in
  1444. Xecho)
  1445. X    echo "Hopefully echo is built into your sh."
  1446. X    ;;
  1447. X/bin/echo)
  1448. X    echo " "
  1449. X    echo "Checking compatibility between /bin/echo and builtin echo (if any)..."
  1450. X    $echo $n "hi there$c" >foo1
  1451. X    echo $n "hi there$c" >foo2
  1452. X    if cmp foo1 foo2 >/dev/null 2>&1; then
  1453. X    echo "They are compatible.  In fact, they may be identical."
  1454. X    else
  1455. X    echo "They are not compatible--the echo builtin will be used."
  1456. X    echo=echo
  1457. X    fi
  1458. X    $rm -f foo1 foo2
  1459. X    ;;
  1460. X*)
  1461. X    echo=echo
  1462. X    ;;
  1463. Xesac
  1464. X
  1465. X: index or strcpy
  1466. X$echo " "
  1467. Xif $contains index libc.list >/dev/null 2>&1 ; then
  1468. X    $echo "Your system appears to use index() and rindex() rather than strchr()"
  1469. X    $echo $n "and strrchr().  Is this correct? [y] $c"
  1470. X    rp='index() rather than strchr()? [y]'
  1471. X    . myread
  1472. X    case "$ans" in
  1473. X    n*|f*) d_index="$define" ;;
  1474. X    *)     d_index="$undef" ;;
  1475. X    esac
  1476. Xelse
  1477. X    $echo "Your system appears to use strchr() and strrchr() rather than index()"
  1478. X    $echo $n "and rindex().  Is this correct? [y] $c"
  1479. X    rp='strchr() rather than index()? [y]'
  1480. X    . myread
  1481. X    case "$ans" in
  1482. X    n*|f*) d_index="$undef" ;;
  1483. X    *)     d_index="$define" ;;
  1484. X    esac
  1485. Xfi
  1486. X
  1487. X: check for void type
  1488. X$echo " "
  1489. X$echo "Checking to see if your C compiler groks the void type..."
  1490. X$cat >try.c <<'EOCP'
  1491. Xvoid main();
  1492. XEOCP
  1493. Xif cc -c try.c >/dev/null 2>&1 ; then
  1494. X    d_void="$undef"
  1495. X    $echo "Yup, it does."
  1496. Xelse
  1497. X    d_void="$define"
  1498. X    $echo "Nope, it doesn't (boo hiss).  I will substitute int."
  1499. Xfi
  1500. X$rm -f try.*
  1501. X
  1502. X: see how we invoke the C preprocessor
  1503. Xecho " "
  1504. Xecho "Checking to see how your C preprocessor is invoked..."
  1505. Xcat <<'EOT' >testcpp.c
  1506. X#define ABC abc
  1507. X#define XYZ xyz
  1508. XABC.XYZ
  1509. XEOT
  1510. Xecho 'Maybe "cc -E" will work...'
  1511. Xcc -E testcpp.c >testcpp.out 2>&1
  1512. Xif $contains 'abc.xyz' testcpp.out >/dev/null 2>&1 ; then
  1513. X    echo "Yup, it does."
  1514. X    cpp='cc -E'
  1515. Xelse
  1516. X    echo 'Nope...maybe "cc -P" will work...'
  1517. X    cc -P testcpp.c >testcpp.out 2>&1
  1518. X    if $contains 'abc.xyz' testcpp.out >/dev/null 2>&1 ; then
  1519. X    echo "Yup, that does."
  1520. X    cpp='cc -P'
  1521. X    else
  1522. X    echo 'Nixed again...maybe "/lib/cpp" will work...'
  1523. X    /lib/cpp testcpp.c >testcpp.out 2>&1
  1524. X    if $contains 'abc.xyz' testcpp.out >/dev/null 2>&1 ; then
  1525. X        echo "Hooray, it works!  I was beginning to wonder."
  1526. X        cpp='/lib/cpp'
  1527. X    else
  1528. X        echo 'Hmm...maybe you already told me...'
  1529. X        case "$cpp" in
  1530. X        '') ;;
  1531. X        *) $cpp testcpp.c >testcpp.out 2>&1;;
  1532. X        esac
  1533. X        if $contains 'abc.xyz' testcpp.out >/dev/null 2>&1 ; then
  1534. X        echo "Hooray, you did!  I was beginning to wonder."
  1535. X        else
  1536. X        echo $n "Nope. I can't find a C preprocessor.  Name one: $c"
  1537. X        rp='Name a C preprocessor:'
  1538. X        . myread
  1539. X        cpp="$ans"
  1540. X        $cpp testcpp.c >testcpp.out 2>&1
  1541. X        if $contains 'abc.xyz' testcpp.out >/dev/null 2>&1 ; then
  1542. X            echo "OK, that will do."
  1543. X        else
  1544. X            echo "Sorry, I can't get that to work.  Go find one."
  1545. X            exit 1
  1546. X        fi
  1547. X        fi
  1548. X    fi
  1549. X    fi
  1550. Xfi
  1551. Xrm -f testcpp.c testcpp.out
  1552. X
  1553. X: get C preprocessor symbols handy
  1554. Xecho " "
  1555. Xcat <<'EOT' >Cppsym.c
  1556. Xchar *sym[] = {
  1557. X#ifdef mc68000
  1558. X    "mc68000",
  1559. X#endif
  1560. X#ifdef sun
  1561. X    "sun",
  1562. X#endif
  1563. X#ifdef gcos
  1564. X    "gcos",
  1565. X#endif
  1566. X#ifdef unix
  1567. X    "unix",
  1568. X#endif
  1569. X#ifdef ibm
  1570. X    "ibm",
  1571. X#endif
  1572. X#ifdef gimpel
  1573. X    "gimpel",
  1574. X#endif
  1575. X#ifdef interdata
  1576. X    "interdata",
  1577. X#endif
  1578. X#ifdef tss
  1579. X    "tss",
  1580. X#endif
  1581. X#ifdef os
  1582. X    "os",
  1583. X#endif
  1584. X#ifdef mert
  1585. X    "mert",
  1586. X#endif
  1587. X#ifdef pyr
  1588. X    "pyr",
  1589. X#endif
  1590. X#ifdef vax
  1591. X    "vax",
  1592. X#endif
  1593. X#ifdef pdp11
  1594. X    "pdp11",
  1595. X#endif
  1596. X#ifdef i8086
  1597. X    "i8086",
  1598. X#endif
  1599. X#ifdef z8000
  1600. X    "z8000",
  1601. X#endif
  1602. X#ifdef 3b2
  1603. X    "3b2",
  1604. X#endif
  1605. X#ifdef 3b5
  1606. X    "3b5",
  1607. X#endif
  1608. X#ifdef 3b20
  1609. X    "3b20",
  1610. X#endif
  1611. X#ifdef 3b200
  1612. X    "3b200",
  1613. X#endif
  1614. X0};
  1615. Xmain(argc,argv)
  1616. Xint argc;
  1617. Xchar **argv;
  1618. X{
  1619. X    int i;
  1620. X
  1621. X    for (argc--,argv++; argc; argc--,argv++) {
  1622. X    for (i=0; sym[i]; i++) {
  1623. X        if (strcmp(argv[0],sym[i]) == 0)
  1624. X        exit(0);
  1625. X    }
  1626. X    }
  1627. X    exit(1);
  1628. X}
  1629. XEOT
  1630. Xecho "Your machine appears to have the following attributes:"
  1631. X$cpp Cppsym.c | sed -n -e 's/^    "\(.*\)",$/\1/p'
  1632. Xcc Cppsym.c -o Cppsym
  1633. Xrm -f Cppsym.c
  1634. X
  1635. X: see how many register declarations we want to use
  1636. Xcase "$registers" in
  1637. X'')
  1638. X    if Cppsym pdp11 i8086 z8000; then
  1639. X    dflt=3
  1640. X    else
  1641. X    if Cppsym sun mc68000; then
  1642. X        dflt=10
  1643. X    else
  1644. X        : if you have any other numbers for me, send them in
  1645. X        dflt=6
  1646. X    fi
  1647. X    fi
  1648. X    ;;
  1649. X*)  dflt=$registers ;;
  1650. Xesac
  1651. Xcat <<EOM
  1652. X 
  1653. XDifferent C compilers on different machines pay attention to different
  1654. Xnumbers of register declarations.  About how many register declarations in
  1655. XEOM
  1656. X$echo $n "each routine does your C compiler pay attention to? (OK to guess) [$dflt] $c"
  1657. Xrp="# register declarations used? [$dflt]"
  1658. X. myread
  1659. Xcase "$ans" in
  1660. X'') ans=$dflt;;
  1661. Xesac
  1662. Xregisters=$ans
  1663. Xreg1=''
  1664. Xawk "END { for (i=1; i<=16; i++) printf \"reg%d=''\n\", i}" </dev/null >.foo
  1665. X. .foo
  1666. Xawk "END { for (i=1; i<=$registers; i++) printf \"reg%d=register\n\", i}" \
  1667. X    </dev/null >.foo
  1668. X. .foo
  1669. Xrm -f .foo
  1670. X
  1671. X: preserve RCS keywords in files with variable substitution, grrr
  1672. XLog='$Log'
  1673. XHeader='$Header'
  1674. X
  1675. X: set up shell script to do ~ expansion
  1676. Xcat >filexp <<EOSS
  1677. X$startsh
  1678. X: expand filename
  1679. Xcase "\$1" in
  1680. X~/*|~)
  1681. X    $echo \$1 | $sed "s|~|\${HOME-\$LOGDIR}|"
  1682. X    ;;
  1683. X~*)
  1684. X    if $test -f /bin/csh; then
  1685. X    /bin/csh -f -c "glob \$1"
  1686. X    $echo ""
  1687. X    else
  1688. X    name=\`$expr x\$1 : '..\([^/]*\)'\`
  1689. X    dir=\`$sed </etc/passwd -n -e "/^\${name}:/{s/^[^:]*:[^:]*:[^:]*:[^:]*:[^:]*:\([^:]*\).*"'\$'"/\1/" -e p -e q -e '}'\`
  1690. X    if $test ! -d "\$dir"; then
  1691. X        me=\`basename \$0\`
  1692. X        $echo "\$me: can't locate home directory for: \$name" >&2
  1693. X        exit 1
  1694. X    fi
  1695. X    case "\$1" in
  1696. X    */*)
  1697. X        $echo \$dir/\`$expr x\$1 : '..[^/]*/\(.*\)'\`
  1698. X        ;;
  1699. X    *)
  1700. X        $echo \$dir
  1701. X        ;;
  1702. X    esac
  1703. X    fi
  1704. X    ;;
  1705. X*)
  1706. X    $echo \$1
  1707. X    ;;
  1708. Xesac
  1709. XEOSS
  1710. Xchmod 755 filexp
  1711. X$eunicefix filexp
  1712. X
  1713. X: determine where public executables go
  1714. Xcase "$bin" in
  1715. X'')
  1716. X    dflt=`loc . /bin /usr/local/bin /usr/lbin /usr/local /usr/bin`
  1717. X    ;;
  1718. X*)  dflt="$bin"
  1719. X    ;;
  1720. Xesac
  1721. Xbin='blurfl/dyick'
  1722. Xwhile $test ! -d "$bin" ; do
  1723. X    case "$bin" in
  1724. X      blurfl*) ;;
  1725. X      *) $echo "$bin does not appear to exist." ;;
  1726. X    esac
  1727. X    $echo " "
  1728. X    rp="Where do you want to put the public executables? [$dflt]"
  1729. X    $echo $n "$rp $c"
  1730. X    . myread
  1731. X    bin="$ans"
  1732. X    bin=`filexp $bin`
  1733. X    case "$bin" in
  1734. X      '') bin=$dflt ;;
  1735. X    esac
  1736. Xdone
  1737. X
  1738. X: determine where manual pages go
  1739. Xcase "$mansrc" in
  1740. X'')
  1741. X    dflt=`loc . /usr/man/man1 /usr/man/mann /usr/man/local/man1 /usr/man/u_man/man1 /usr/man/man1`
  1742. X    ;;
  1743. X*)  dflt="$mansrc"
  1744. X    ;;
  1745. Xesac
  1746. Xmansrc='blurfl/dyick'
  1747. Xwhile $test ! -d "$mansrc" ; do
  1748. X    case "$mansrc" in
  1749. X      blurfl*) ;;
  1750. X      *) $echo "$mansrc does not appear to exist." ;;
  1751. X    esac
  1752. X    $echo " "
  1753. X    rp="Where do the manual pages (source) go? [$dflt]"
  1754. X    $echo $n "$rp $c"
  1755. X    . myread
  1756. X    mansrc=`filexp "$ans"`
  1757. X    case "$mansrc" in
  1758. X      '') mansrc=$dflt ;;
  1759. X    esac
  1760. Xdone
  1761. Xcase "$mansrc" in
  1762. X*l)
  1763. X    manext=l
  1764. X    ;;
  1765. X*n)
  1766. X    manext=n
  1767. X    ;;
  1768. X*)
  1769. X    manext=1
  1770. X    ;;
  1771. Xesac
  1772. X
  1773. X: see if we need a special compiler
  1774. X$echo " "
  1775. Xif usg; then
  1776. X    case "$cc" in
  1777. X    '')
  1778. X    case "$Mcc" in
  1779. X    /*) dflt='Mcc'
  1780. X        ;;
  1781. X    *)
  1782. X        if $contains '\-M' $mansrc/cc.1 >/dev/null 2>&1 ; then
  1783. X        dflt='cc -M'
  1784. X        else
  1785. X        dflt='cc'
  1786. X        fi
  1787. X        ;;
  1788. X    esac
  1789. X    ;;
  1790. X    *)  dflt="$cc";;
  1791. X    esac
  1792. X    $cat <<'EOM'
  1793. X 
  1794. XOn some systems the default C compiler will not resolve multiple global
  1795. Xreferences that happen to have the same name.  On some such systems the
  1796. X"Mcc" command may be used to force these to be resolved.  On other systems
  1797. Xa "cc -M" command is required.  What command will force resolution on
  1798. XEOM
  1799. X    $echo $n "this system? [$dflt] $c"
  1800. X    rp="Command to resolve multiple refs? [$dflt]"
  1801. X    . myread
  1802. X    cc="$ans"
  1803. X    case "$cc" in
  1804. X    '') cc="$dflt" ;;
  1805. X    esac
  1806. Xelse
  1807. X    $echo "Not a USG system--assuming cc can resolve multiple definitions."
  1808. X    cc=cc
  1809. Xfi
  1810. X
  1811. X: see if we should throw a -i into the Makefile
  1812. X$echo " "
  1813. Xif Cppsym pdp11 i8086 z8000; then
  1814. X    if $contains '\-i' $mansrc/cc.1 >/dev/null 2>&1 ; then
  1815. X    rp="Your system appears to have separate I and D space.  Is this true? [y]"
  1816. X    $echo $n "$rp $c"
  1817. X    . myread
  1818. X    case "$ans" in
  1819. X        n*|f*) iandd='' ;;
  1820. X        *)     iandd='-i' ;;
  1821. X    esac
  1822. X    else
  1823. X    $echo "Your system appears to NOT have separate I and D space."
  1824. X    $echo $n "Is this correct? [y] $c"
  1825. X    rp='No separate I and D.  Correct? [y]'
  1826. X    . myread
  1827. X    case "$ans" in
  1828. X        n*|f*) iandd='-i' ;;
  1829. X        *)     iandd='' ;;
  1830. X    esac
  1831. X    fi
  1832. Xelse
  1833. X    $echo $n "Does your machine have separate I and D space? [n] $c"
  1834. X    . myread
  1835. X    case "$ans" in
  1836. X    y*)    iandd='-i' ;;
  1837. X    *)     iandd='' ;;
  1838. X    esac
  1839. Xfi
  1840. X
  1841. X$echo " "
  1842. X$echo "End of configuration questions."
  1843. X$echo " "
  1844. X
  1845. X: create config.sh file
  1846. X$echo " "
  1847. X$echo "Creating config.sh..."
  1848. X$spitshell <<EOT >config.sh
  1849. X$startsh
  1850. X# config.sh
  1851. X# This file was produced by running the Configure script.
  1852. X
  1853. Xd_eunice='$d_eunice'
  1854. Xeunicefix='$eunicefix'
  1855. Xloclist='$loclist'
  1856. Xexpr='$expr'
  1857. Xsed='$sed'
  1858. Xecho='$echo'
  1859. Xcat='$cat'
  1860. Xrm='$rm'
  1861. Xmv='$mv'
  1862. Xcp='$cp'
  1863. Xtail='$tail'
  1864. Xtr='$tr'
  1865. Xmkdir='$mkdir'
  1866. Xsort='$sort'
  1867. Xuniq='$uniq'
  1868. Xgrep='$grep'
  1869. Xtrylist='$trylist'
  1870. Xtest='$test'
  1871. Xinews='$inews'
  1872. Xegrep='$egrep'
  1873. Xmore='$more'
  1874. Xpg='$pg'
  1875. XMcc='$Mcc'
  1876. Xvi='$vi'
  1877. Xmailx='$mailx'
  1878. XLog='$Log'
  1879. XHeader='$Header'
  1880. Xbin='$bin'
  1881. Xcc='$cc'
  1882. Xcontains='$contains'
  1883. Xcpp='$cpp'
  1884. Xd_index='$d_index'
  1885. Xd_void='$d_void'
  1886. Xiandd='$iandd'
  1887. Xlibc='$libc'
  1888. Xmansrc='$mansrc'
  1889. Xmanext='$manext'
  1890. Xn='$n'
  1891. Xc='$c'
  1892. Xpackage='$package'
  1893. Xregisters='$registers'
  1894. Xreg1='$reg1'
  1895. Xreg2='$reg2'
  1896. Xreg3='$reg3'
  1897. Xreg4='$reg4'
  1898. Xreg5='$reg5'
  1899. Xreg6='$reg6'
  1900. Xreg7='$reg7'
  1901. Xreg8='$reg8'
  1902. Xreg9='$reg9'
  1903. Xreg10='$reg10'
  1904. Xreg11='$reg11'
  1905. Xreg12='$reg12'
  1906. Xreg13='$reg13'
  1907. Xreg14='$reg14'
  1908. Xreg15='$reg15'
  1909. Xreg16='$reg16'
  1910. Xspitshell='$spitshell'
  1911. Xshsharp='$shsharp'
  1912. Xsharpbang='$sharpbang'
  1913. Xstartsh='$startsh'
  1914. XCONFIG=true
  1915. XEOT
  1916. X 
  1917. X: create config.h file
  1918. X$echo " "
  1919. X$echo "Creating config.h..."
  1920. X$cat <<EOT >config.h
  1921. X/* config.h
  1922. X * This file was produced by running the Configure script.
  1923. X * Feel free to modify any of this as the need arises.
  1924. X */
  1925. X
  1926. X
  1927. X#$d_eunice    EUNICE        /* no file linking? */
  1928. X#$d_eunice    VMS        /* other assorted ickies? */
  1929. X
  1930. X#$d_index    index strchr    /* cultural */
  1931. X#$d_index    rindex strrchr    /*  differences? */
  1932. X
  1933. X#$d_void    void int    /* is void to be avoided? */
  1934. X
  1935. X/* How many register declarations are paid attention to? */
  1936. X
  1937. X#define Reg1 $reg1        /**/
  1938. X#define Reg2 $reg2        /**/
  1939. X#define Reg3 $reg3        /**/
  1940. X#define Reg4 $reg4        /**/
  1941. X#define Reg5 $reg5        /**/
  1942. X#define Reg6 $reg6        /**/
  1943. X#define Reg7 $reg7        /**/
  1944. X#define Reg8 $reg8        /**/
  1945. X#define Reg9 $reg9        /**/
  1946. X#define Reg10 $reg10        /**/
  1947. X#define Reg11 $reg11        /**/
  1948. X#define Reg12 $reg12        /**/
  1949. X#define Reg13 $reg13        /**/
  1950. X#define Reg14 $reg14        /**/
  1951. X#define Reg15 $reg15        /**/
  1952. X#define Reg16 $reg16        /**/
  1953. X
  1954. XEOT
  1955. XCONFIG=true
  1956. X
  1957. Xif $contains '\.SH' MANIFEST >/dev/null 2>&1; then
  1958. X    $echo " "
  1959. X    $echo "Doing variable substitutions on .SH files..."
  1960. X    set `$grep <MANIFEST '\.SH' | awk '{print $1}'`
  1961. X    for file in $*; do
  1962. X    case "$file" in
  1963. X    */*)
  1964. X        dir=`$expr X$file : 'X\(.*\)/'`
  1965. X        file=`$expr X$file : 'X.*/\(.*\)'`
  1966. X        (cd $dir && . $file)
  1967. X        ;;
  1968. X    *)
  1969. X        . $file
  1970. X        ;;
  1971. X    esac
  1972. X    done
  1973. Xfi
  1974. X
  1975. Xif $contains '^depend:' Makefile >/dev/null 2>&1; then
  1976. X    $echo " "
  1977. X    $echo 'Now you need to generate make dependencies by running "make depend".'
  1978. X    $echo 'You might prefer to run it in background: "make depend > makedepend.out &"'
  1979. X    $echo $n "Would you like me to run it for you (it takes quite a while)? [n] $c" 
  1980. X    rp="Run make depend now? [n]"
  1981. X    . myread
  1982. X    case "$ans" in
  1983. X    y*) make depend;;
  1984. X    esac
  1985. Xfi
  1986. X
  1987. X$rm -f libc.list kit*isdone bsd usg v7 eunice loc Cppsym
  1988. X
  1989. Xif test -f Makefile; then
  1990. X    $echo " "
  1991. X    $echo "Now you must run a make."
  1992. Xelse
  1993. X    $echo "Done."
  1994. Xfi
  1995. X: end of Configure
  1996. !STUFFY!FUNK!
  1997. echo Extracting util.h
  1998. sed >util.h <<'!STUFFY!FUNK!' -e 's/X//'
  1999. X/* $Header: util.h,v 2.0 86/09/17 15:40:06 lwall Exp $
  2000. X *
  2001. X * $Log:    util.h,v $
  2002. X * Revision 2.0  86/09/17  15:40:06  lwall
  2003. X * Baseline for netwide release.
  2004. X * 
  2005. X */
  2006. X
  2007. X/* and for those machine that can't handle a variable argument list */
  2008. X
  2009. X#ifdef CANVARARG
  2010. X
  2011. X#define say1 say
  2012. X#define say2 say
  2013. X#define say3 say
  2014. X#define say4 say
  2015. X#define ask1 ask
  2016. X#define ask2 ask
  2017. X#define ask3 ask
  2018. X#define ask4 ask
  2019. X#define fatal1 fatal
  2020. X#define fatal2 fatal
  2021. X#define fatal3 fatal
  2022. X#define fatal4 fatal
  2023. X
  2024. X#else /* hope they allow multi-line macro actual arguments */
  2025. X
  2026. X#ifdef lint
  2027. X
  2028. X#define say1(a) say(a, 0, 0, 0)
  2029. X#define say2(a,b) say(a, (b)==(b), 0, 0)
  2030. X#define say3(a,b,c) say(a, (b)==(b), (c)==(c), 0)
  2031. X#define say4(a,b,c,d) say(a, (b)==(b), (c)==(c), (d)==(d))
  2032. X#define ask1(a) ask(a, 0, 0, 0)
  2033. X#define ask2(a,b) ask(a, (b)==(b), 0, 0)
  2034. X#define ask3(a,b,c) ask(a, (b)==(b), (c)==(c), 0)
  2035. X#define ask4(a,b,c,d) ask(a, (b)==(b), (c)==(c), (d)==(d))
  2036. X#define fatal1(a) fatal(a, 0, 0, 0)
  2037. X#define fatal2(a,b) fatal(a, (b)==(b), 0, 0)
  2038. X#define fatal3(a,b,c) fatal(a, (b)==(b), (c)==(c), 0)
  2039. X#define fatal4(a,b,c,d) fatal(a, (b)==(b), (c)==(c), (d)==(d))
  2040. X
  2041. X#else /* lint */
  2042. X    /* if this doesn't work, try defining CANVARARG above */
  2043. X#define say1(a) say(a, Nullch, Nullch, Nullch)
  2044. X#define say2(a,b) say(a, b, Nullch, Nullch)
  2045. X#define say3(a,b,c) say(a, b, c, Nullch)
  2046. X#define say4 say
  2047. X#define ask1(a) ask(a, Nullch, Nullch, Nullch)
  2048. X#define ask2(a,b) ask(a, b, Nullch, Nullch)
  2049. X#define ask3(a,b,c) ask(a, b, c, Nullch)
  2050. X#define ask4 ask
  2051. X#define fatal1(a) fatal(a, Nullch, Nullch, Nullch)
  2052. X#define fatal2(a,b) fatal(a, b, Nullch, Nullch)
  2053. X#define fatal3(a,b,c) fatal(a, b, c, Nullch)
  2054. X#define fatal4 fatal
  2055. X
  2056. X#endif /* lint */
  2057. X
  2058. X/* if neither of the above work, join all multi-line macro calls. */
  2059. X#endif
  2060. X
  2061. XEXT char serrbuf[BUFSIZ];        /* buffer for stderr */
  2062. X
  2063. Xchar *fetchname();
  2064. Xint move_file();
  2065. Xvoid copy_file();
  2066. Xvoid say();
  2067. Xvoid fatal();
  2068. Xvoid ask();
  2069. Xchar *savestr();
  2070. Xvoid set_signals();
  2071. Xvoid ignore_signals();
  2072. Xvoid makedirs();
  2073. !STUFFY!FUNK!
  2074. echo Extracting EXTERN.h
  2075. sed >EXTERN.h <<'!STUFFY!FUNK!' -e 's/X//'
  2076. X/* $Header: EXTERN.h,v 2.0 86/09/17 15:35:37 lwall Exp $
  2077. X *
  2078. X * $Log:    EXTERN.h,v $
  2079. X * Revision 2.0  86/09/17  15:35:37  lwall
  2080. X * Baseline for netwide release.
  2081. X * 
  2082. X */
  2083. X
  2084. X#undef EXT
  2085. X#define EXT extern
  2086. X
  2087. X#undef INIT
  2088. X#define INIT(x)
  2089. X
  2090. X#undef DOINIT
  2091. !STUFFY!FUNK!
  2092. echo ""
  2093. echo "End of kit 1 (of 3)"
  2094. cat /dev/null >kit1isdone
  2095. config=true
  2096. for iskit in 1 2 3; do
  2097.     if test -f kit${iskit}isdone; then
  2098.     echo "You have run kit ${iskit}."
  2099.     else
  2100.     echo "You still need to run kit ${iskit}."
  2101.     config=false
  2102.     fi
  2103. done
  2104. case $config in
  2105.     true)
  2106.     echo "You have run all your kits.  Please read README and then type Configure."
  2107.     chmod 755 Configure
  2108.     ;;
  2109. esac
  2110. : I do not append .signature, but someone might mail this.
  2111. exit
  2112.