home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume20 / plum-ansi-macros < prev    next >
Text File  |  1989-10-22  |  27KB  |  1,314 lines
  1. Subject:  v20i048:  Plum-Hall X3J11 macro explainer
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: Eric S. Raymond <eric@snark.uu.net>
  7. Posting-number: Volume 20, Issue 48
  8. Archive-name: plum-ansi-macros
  9.  
  10. his is a tutorial program which illustrates how the Standard's
  11. macro-expansion algorithm works.  First, look at some of the  .out  files
  12. to see the model of presentation of macro-expansion.
  13.  
  14. Then, look at the file  mac.c  for notes on the implementation.  This is
  15. not an elegant program.  It was designed to illustrate the dynamics in
  16. the minimum amount of C code.  Forget about "information-hiding";
  17. everything is a string of chars.
  18.  
  19. All of this directory is experimental, not intended to be authoritative,
  20. and in no way an official opinion of the ANSI X3J11 committee.
  21.  
  22. Permissions:
  23.  Permission is granted for reproduction and use of this  mac  program,
  24.  provided that its enclosed authorship notice is reproduced entirely.
  25.  
  26.  
  27.  Tom Plum, Plum Hall Inc, 609-927-3770,  uunet!plumhall!plum .
  28.  
  29. #!/bin/sh
  30. : "This is a shell archive, meaning:                              "
  31. : "1. Remove everything above the #! /bin/sh line.                "
  32. : "2. Save the resulting test in a file.                          "
  33. : "3. Execute the file with /bin/sh (not csh) to create the files:"
  34. : "    READ.ME"
  35. : "    Makefile"
  36. : "    mac.c"
  37. : "    std1.in"
  38. : "    std2.in"
  39. : "    std3.in"
  40. : "    std4.in"
  41. : "    test1.in"
  42. : "    test2.in"
  43. : "    test5.in"
  44. : "    test6.in"
  45. : "    test7.in"
  46. : "    test8.in"
  47. : "    std1.out"
  48. : "    std2.out"
  49. : "    std3.out"
  50. : "    std4.out"
  51. : "    test1.out"
  52. : "    test2.out"
  53. : "    test5.out"
  54. : "    test6.out"
  55. : "    test7.out"
  56. : "    test8.out"
  57. echo file: READ.ME
  58. sed 's/^X//' >READ.ME << 'END-of-READ.ME'
  59. XThe MAC demonstration program
  60. X
  61. XThis is a tutorial program which illustrates how the Standard's
  62. Xmacro-expansion algorithm works.  First, look at some of the  .out  files
  63. Xto see the model of presentation of macro-expansion.
  64. X
  65. XThen, look at the file  mac.c  for notes on the implementation.  This is
  66. Xnot an elegant program.  It was designed to illustrate the dynamics in
  67. Xthe minimum amount of C code.  Forget about "information-hiding";
  68. Xeverything is a string of chars.
  69. X
  70. XAll of this directory is experimental, not intended to be authoritative,
  71. Xand in no way an official opinion of the ANSI X3J11 committee.
  72. X
  73. X-----------------------
  74. XPermissions:
  75. X
  76. X Permission is granted for reproduction and use of this  mac  program,
  77. X provided that its enclosed authorship notice is reproduced entirely.
  78. X
  79. X
  80. X Tom Plum, Plum Hall Inc, 609-927-3770,  uunet!plumhall!plum .
  81. END-of-READ.ME
  82. echo file: Makefile
  83. sed 's/^X//' >Makefile << 'END-of-Makefile'
  84. X#
  85. X# Makefile for the Plum-Hall X3J11 macro untangler
  86. X#
  87. XSRC = Makefile mac.c
  88. XIN = std[1234].in test[12345678].in
  89. XOUT = std[1234].out test[12345678].out
  90. X
  91. Xmac: mac.c 
  92. X    cc -g -o mac mac.c
  93. X
  94. XSUFFIXES: .out .in
  95. X
  96. X.in.out: mac
  97. X    mac <$*.in >$*.out
  98. X
  99. Xshar: READ.ME $(SRC) $(IN) $(OUT)
  100. X    shar READ.ME $(SRC) $(IN) $(OUT) >mac.shar
  101. X
  102. Xclean:
  103. X    rm -f mac mac.shar *~
  104. END-of-Makefile
  105. echo file: mac.c
  106. sed 's/^X//' >mac.c << 'END-of-mac.c'
  107. X/* macros - skeleton of macro expansion algorithm
  108. X * Each token is one char (letter a-z).
  109. X * Token-buffers are modeled by plain old char strings.
  110. X * Each such buffer has another same-size buffer printed just under it,
  111. X * which shows the "hide-set" associated with the token above it.
  112. X * (The "hide-set" contains all the tokens that are non-replaceable.)
  113. X * #define  is  #d (no space before or after #).
  114. X * No attempt to model details of whitespace handling.
  115. X * Two tokens, when catenated, produce "second token plus one".
  116. X * "Stringize" is crudely stubbed; two quotes "" replace the string.
  117. X * Does not handle empty actuals gracefully.
  118. X * Does not span newlines in matching actuals.
  119. X * Revisions:
  120. X * 88/10/01: Identify the "replacement" buffer as "R".
  121. X * 88/10/03: Handle the hide-set of actuals properly.
  122. X * 88/10/03: Indicate where to refine for the exact (unspecified)
  123. X *        semantics of interactions of hide-sets in catenation 
  124. X */
  125. X/*
  126. X * First version written by Thomas Plum, Plum Hall Inc.
  127. X * Subsequently revised by members of X3J11, the
  128. X * ANSI C Standards Committee.
  129. X * Permission is granted to reproduce and use this program,
  130. X * for all purposes, provided that this notice is included.
  131. X */
  132. X
  133. X/* First, 300+ lines of inelegant support routines, to about 363  ... */
  134. X
  135. X#include <stdio.h>
  136. X#include <ctype.h>
  137. X#include <string.h>
  138. X#define TRACE(x) 0    /* or,  printf x , if needed for debugging */
  139. X#define OUT(x) printf x
  140. X#define cpy_nam(p, q) (p[0] = *(q), p[1] = '\0', ++(q))
  141. X#define eobuf(p) (*(p) == '\0')
  142. X#define next(p, s) (strncmp(p, s, (length_matched = strlen(s))) == 0)
  143. X#define advance(p) (p += length_matched)
  144. X#define is_obj(p) in_set(obj.nam, *(p))
  145. X#define is_fn(p) in_set(fn.nam, *(p))
  146. X#define obj_def(p) obj.def[obj_num(p)][0]
  147. X#define obj_num(p) (strchr(obj.nam, *(p)) - obj.nam)
  148. X#define fn_def(p) fn.def[fn_num(p)][0]
  149. X#define fn_num(p) (strchr(fn.nam, *(p)) - fn.nam)
  150. X#define fn_parm_count(p) strlen(fn.parms[fn_num(p)])
  151. X#define fn_parm_index(p, q) \
  152. X    (strchr(fn.parms[fn_num(p)], *(q)) - fn.parms[fn_num(p)])
  153. X#define is_parm_name(p, q) in_set(fn.parms[fn_num(p)], *(q))
  154. X#define in_set(p, c) (strchr(p, c) != 0)
  155. X#define hide_set(p) *((char*)p + L)
  156. X#define A 9   /* max # of macro args */
  157. X#define D 26  /* max # of macro defs */
  158. X#define L 100 /* max length of an input line  or of a macro def */
  159. Xint length_matched;
  160. Xvoid diagram(), expand(), expand_fn(), set_hide(), listcpy();
  161. Xvoid add_hide(), lower_case();
  162. Xchar *h_set();
  163. Xchar arg_patterns[10][24] =
  164. X    {
  165. X    "()",
  166. X    "(_)",
  167. X    "(_,_)",
  168. X    "(_,_,_)",
  169. X    "(_,_,_,_)",
  170. X    "(_,_,_,_,_)",
  171. X    "(_,_,_,_,_,_)",
  172. X    "(_,_,_,_,_,_,_)",
  173. X    "(_,_,_,_,_,_,_,_)",
  174. X    "(_,_,_,_,_,_,_,_,_)",
  175. X    };
  176. Xchar next_token(p) char *p;
  177. X    {
  178. X    length_matched = 0;
  179. X    ++p;
  180. X    for (;;)
  181. X        {
  182. X        if (*p == ' ')
  183. X            ++p, ++length_matched;
  184. X        else if (*p == '\0')
  185. X            {
  186. X            printf("treating end-of-buffer as end-of-file\n");
  187. X            return *p;
  188. X            }
  189. X        else
  190. X            return *p;
  191. X        }
  192. X    }
  193. X
  194. Xvoid strip_blanks(p) char *p;
  195. X    {
  196. X    char *q = p;
  197. X
  198. X    while (*p == ' ')
  199. X        ++p;
  200. X    /* now at first non-blank in p */
  201. X    while (*p != '\0')    /* can't use strcpy because overlap */
  202. X        hide_set(q) = hide_set(p), *q++ = *p++;
  203. X    while (*--q == ' ')
  204. X        ;
  205. X    *++q = '\0', hide_set(q) = '\0';
  206. X    }
  207. X
  208. Xstruct obj { int n; char nam[D]; char def[D][2][L]; }
  209. X    obj = {0};
  210. Xstruct fn  { int n; char nam[D]; char def[D][2][L]; char parms[D][A]; }
  211. X    fn = {0};
  212. X
  213. Xvoid install_obj(nam, def) char *nam; char *def;
  214. X    {
  215. X    obj.nam[obj.n] = nam[0];
  216. X    strcpy(obj.def[obj.n][0], def);
  217. X    strip_blanks(obj.def[obj.n][0]);
  218. X    set_hide(obj.def[obj.n][0], nam);
  219. X    printf("obj: nam=<%s> def=<%s>\n", nam, obj.def[obj.n][0]);
  220. X    printf("                 <%s>\n", obj.def[obj.n][1]);
  221. X    ++obj.n;
  222. X    }
  223. X
  224. Xvoid install_fn(nam, def, parms) char *nam; char *def; char *parms;
  225. X    {
  226. X    fn.nam[fn.n] = nam[0];
  227. X    strcpy(fn.def[fn.n][0], def);
  228. X    strcpy(fn.parms[fn.n], parms);
  229. X    strip_blanks(fn.def[fn.n][0]);
  230. X    set_hide(fn.def[fn.n][0], nam);
  231. X    printf("fn:  nam=<%s> parms=<%s> def=<%s>\n", nam, parms, fn.def[fn.n][0]);
  232. X    printf("                    %*s      <%s>\n", 
  233. X        strlen(parms), "", fn.def[fn.n][1]);
  234. X    ++fn.n;
  235. X    }
  236. X
  237. Xchar *parse_parms(p, parms) char *p; char *parms;
  238. X    {
  239. X    int i = 0;
  240. X
  241. X    while (*p != ')')
  242. X        {
  243. X        if (*p != ' ' && *p != ',')
  244. X            parms[i++] = *p;
  245. X        ++p;
  246. X        }
  247. X    ++p;
  248. X    parms[i] = '\0';
  249. X    return p;
  250. X    }
  251. X
  252. X
  253. X
  254. Xvoid replace(level, suf, buf, p, p2, def) char *level, *suf, *buf, *p, *p2, *def;
  255. X    {
  256. X    char hold[2][L];
  257. X    char old_hide[2];
  258. X
  259. X    listcpy(hold[0], p2);
  260. X    old_hide[0] = hide_set(p), old_hide[1] = '\0';
  261. X    listcpy(p, def);
  262. X    add_hide(p, old_hide);
  263. X    listcpy(p + strlen(def), hold[0]);
  264. X    diagram(level, buf, suf);
  265. X    }
  266. Xchar *match_actuals(p, actual, n) char *p; char actual[A][2][L]; int n;
  267. X    {
  268. X    int parens = 1;
  269. X    int i = 0;
  270. X    int j = 0;
  271. X
  272. X    TRACE(("match_actuals(<%s>, actual)\n", p));
  273. X    p += 1;
  274. X    /* past the '(' */
  275. X
  276. X    for ( ;; )
  277. X        {
  278. X        if (*p == '(')
  279. X            {
  280. X            ++parens;
  281. X            actual[i][1][j] = p[L];
  282. X            actual[i][0][j++] = *p++;
  283. X            }
  284. X        else if (*p == ')')
  285. X            {
  286. X            --parens;
  287. X            if (parens == 0)
  288. X                break;
  289. X            actual[i][1][j] = p[L];
  290. X            actual[i][0][j++] = *p++;
  291. X            }
  292. X        else if (*p == ',' && parens == 1)
  293. X            {
  294. X            actual[i][1][j] = '\0';
  295. X            actual[i][0][j] = '\0';
  296. X            j = 0;
  297. X            ++i;
  298. X            ++p;
  299. X            }
  300. X        else
  301. X            {
  302. X            actual[i][1][j] = p[L];
  303. X            actual[i][0][j++] = *p++;
  304. X            }
  305. X        }
  306. X    actual[i][1][j] = '\0';
  307. X    actual[i][0][j] = '\0';
  308. X    /* should strip blanks on each actual, to be sure non-empty */
  309. X    if (i == 0 && n == 0)
  310. X        ;    /* ok, no args */
  311. X    else if (i != n-1)
  312. X        {
  313. X        printf("wrong number of actuals\n");
  314. X        exit(2);
  315. X        }
  316. X    for (i = 0; i < n; ++i)
  317. X        TRACE(("actual[%d] = <%s>\n", i, actual[i][0]));
  318. X    return p+1;
  319. X    }
  320. X
  321. Xchar *stringize(s) char *s;
  322. X    {
  323. X    static char string_buf[2][L] = {"\"\"", "  "};
  324. X
  325. X    printf("string \"%s\" --> \"\"\n", s);
  326. X    return string_buf[0];
  327. X    }
  328. X
  329. Xchar *catenate(p, q) char *p, *q;
  330. X    {
  331. X    static char cat_buf[2][L];
  332. X    char old_hide[2];
  333. X
  334. X    cat_buf[0][0] = q[0] + 1;
  335. X    cat_buf[0][1] = '\0';
  336. X    set_hide(cat_buf[0], " ");
  337. X    old_hide[0] = hide_set(p), old_hide[1] = '\0';
  338. X    add_hide(cat_buf[0], old_hide);
  339. X    old_hide[0] = hide_set(q), old_hide[1] = '\0';
  340. X    add_hide(cat_buf[0], old_hide);    /* NOTE: The other "unspecified" */
  341. X                                    /* choice is to intersect(!) the */
  342. X                                    /* two hide-sets, as in Prosser  */
  343. X                                    /* 86-196.                       */
  344. X    printf("catenate %c%c --> %c\n", p[0], q[0], cat_buf[0][0]);
  345. X    return cat_buf[0];
  346. X    }
  347. X
  348. Xvoid listcpy(p, q) char *p, *q;
  349. X    {
  350. X    strcpy(p, q);
  351. X    strcpy(&hide_set(p), &hide_set(q));
  352. X    }
  353. X
  354. Xvoid diagram(level, s, suf) char *level, *s, *suf;
  355. X    {
  356. X    char prefix[L];
  357. X
  358. X    if (level[0] == '\0')
  359. X        strcpy(prefix, "0");
  360. X    else
  361. X        strcpy(prefix, level+1);
  362. X    printf("%s%s: %s\n", prefix, suf, s);
  363. X    printf("%*s%.*s\n", strlen(prefix)+strlen(suf)+2, ": ",
  364. X        strlen(s), &hide_set(s));
  365. X    }
  366. X
  367. Xint charcmp(s, t) char *s, *t;
  368. X    {
  369. X    return *s - *t;
  370. X    }
  371. X
  372. Xvoid set_hide(def, nam) char *def, *nam;
  373. X    {
  374. X    memset(&hide_set(def), nam[0], strlen(def));
  375. X    def[L+strlen(def)] = '\0';
  376. X    }
  377. Xchar hide_sets[10][10] = {0};
  378. Xint n_hide_sets = 0;
  379. Xvoid add_hide(p, h) char *p, *h;
  380. X    {
  381. X    int i, lim;
  382. X
  383. X    lim = strlen(p);
  384. X    for (i = 0; i < lim; ++i)
  385. X        {
  386. X        char c = p[L+i];
  387. X        char old_h[2];
  388. X
  389. X        old_h[0] = c, old_h[1] = '\0';
  390. X        TRACE(("c=<%c>, h=<%c>\n", c, h[0]));
  391. X        if (h[0] == ' ')
  392. X            ;
  393. X        else if (c == ' ')
  394. X            p[L+i] = h[0];
  395. X        else if (h[0] == c)
  396. X            ;
  397. X        else if (in_set(h_set(old_h), h[0]))
  398. X            ;
  399. X        else
  400. X            {
  401. X            char new_hide[10];
  402. X            int n = n_hide_sets;
  403. X            int j;
  404. X            int found = 0;
  405. X
  406. X            strcpy(new_hide, h_set(old_h));
  407. X            strcat(new_hide, h_set(h));
  408. X            qsort(new_hide, strlen(new_hide), 1, charcmp);
  409. X            TRACE(("new_hide=<%s>\n", new_hide));
  410. X            for (j = 0; j < n_hide_sets; ++j)
  411. X                {
  412. X                if (strcmp(new_hide, hide_sets[j]) == 0)
  413. X                    {
  414. X                    p[L+i] = j + '0';
  415. X                    found = 1;
  416. X                    }
  417. X                }
  418. X            if (!found)
  419. X                {
  420. X                if (n > 9)
  421. X                    {
  422. X                    printf("too many hide-sets\n");
  423. X                    exit(2);
  424. X                    }
  425. X                strcpy(hide_sets[n], new_hide);
  426. X                p[L+i] = n + '0';
  427. X                qsort(hide_sets[n], strlen(hide_sets[n]), 1, charcmp);
  428. X                printf("hide-set #%d = {%s}\n", n, hide_sets[n]);
  429. X                ++n_hide_sets;
  430. X                }
  431. X            }
  432. X        }
  433. X    }
  434. X
  435. Xchar *h_set(s) char *s;
  436. X    {
  437. X    char c = s[0];
  438. X
  439. X    if (isdigit(c))
  440. X        return hide_sets[c - '0'];
  441. X    else
  442. X        return s;
  443. X    }
  444. X
  445. Xint is_hidden(p) char *p;
  446. X    {
  447. X    if (!islower(*p))
  448. X        return 0;
  449. X    else if (*p == p[L])
  450. X        return 1;
  451. X    else if (isdigit(p[L]) && strchr(hide_sets[p[L] - '0'], *p) != 0)
  452. X        return 1;
  453. X    else
  454. X        return 0;
  455. X    }
  456. X
  457. Xvoid mark_non_replace(p) char *p;
  458. X    {
  459. X    *p = toupper(*p);
  460. X    }
  461. X
  462. Xvoid lower_case(p) char *p;
  463. X    {
  464. X    for ( ; *p != '\0'; ++p)
  465. X        *p = tolower(*p);
  466. X    }
  467. X
  468. X
  469. X/* Now: Here's the actual macro algorithm ... */
  470. X
  471. Xvoid preproc(p) char *p;
  472. X    {
  473. X    char nam[2];
  474. X    char parms[A];
  475. X
  476. X    if (next(p, "#d "))
  477. X        {             /* starting a #define */
  478. X        advance(p);
  479. X        TRACE(("p=<%s>\n", p));
  480. X        cpy_nam(nam, p);
  481. X        if (next(p, "("))    /* a fn-like macro */
  482. X            {
  483. X            advance(p);
  484. X            p = parse_parms(p, parms);
  485. X            install_fn(nam, p, parms);
  486. X            }
  487. X        else        /* an object-like macro */
  488. X            install_obj(nam, p);
  489. X        }    /* end of #define */
  490. X    else if (next(p, "#u "))
  491. X        {            /* starting a #undef */
  492. X        } /* stub */
  493. X    else
  494. X        {
  495. X        expand(p, "");
  496. X        lower_case(p);
  497. X        set_hide(p, " ");
  498. X        diagram("", p, "");
  499. X        }
  500. X    }
  501. Xvoid expand(buf, level) char *buf; char *level;
  502. X    {
  503. X    char *p = buf;
  504. X
  505. X    TRACE(("expand(<%s>, %s)\n", buf, level));
  506. X    diagram(level, buf, "");
  507. X    while (!eobuf(p))
  508. X        {
  509. X        if (is_hidden(p))
  510. X            {
  511. X            mark_non_replace(p);
  512. X            ++p;
  513. X            diagram(level, buf, "");
  514. X            }
  515. X        else if (is_obj(p))    /* instance of object-like macro */
  516. X            replace(level, "", buf, p, p+1, obj_def(p));
  517. X        else if (is_fn(p) && next_token(p) == '(') 
  518. X            expand_fn(buf, p, level); /* instance of fn-like macro */
  519. X        else
  520. X            ++p;    /* ordinary token */
  521. X        }    /* end while !eobuf */
  522. X    }    /* end expand() */
  523. X
  524. X
  525. X
  526. X
  527. X
  528. X
  529. Xvoid expand_fn(buf, p, level) char *buf, *p, *level;
  530. X    {
  531. X    char actual[A][2][L], expandeds[A][2][L];
  532. X    char repl[2][L];
  533. X    char nlevel[20];
  534. X    char fn_nam[2];
  535. X    char invocation[2][L];
  536. X    char *start_invok, *q;
  537. X    int i_parm, num_parms;
  538. X
  539. X    start_invok = p;
  540. X    cpy_nam(fn_nam, p);
  541. X    advance(p);    /* past any blanks skipped in next_token */
  542. X    num_parms = fn_parm_count(fn_nam);
  543. X    p = match_actuals(p, actual, num_parms);
  544. X    for (i_parm = 0; i_parm < num_parms; ++i_parm)
  545. X        {
  546. X        listcpy(expandeds[i_parm][0], actual[i_parm][0]);
  547. X        sprintf(nlevel, "%s.%d", level, i_parm+1);
  548. X        expand(expandeds[i_parm][0], nlevel);
  549. X        }
  550. X    sprintf(invocation[0], "%s%s", fn_nam, arg_patterns[num_parms]);
  551. X    set_hide(invocation[0], " ");
  552. X    diagram(level, invocation[0], "R");
  553. X    listcpy(repl[0], fn_def(fn_nam));
  554. X    diagram(level, repl[0], "R");
  555. X    TRACE(("subst parms in repl:<%s>\n", repl));
  556. X    for (q = repl[0]; !eobuf(q); )
  557. X        {
  558. X        TRACE(("repl-token <%c>\n", *q));
  559. X        if (q[1] == '#' && q[2] == '#' && !eobuf(q+3))
  560. X            {
  561. X            replace(level, "R", repl[0], q, q+4,
  562. X                catenate(q, q+3));
  563. X            q += 1;    /* advance past new "token" */
  564. X            }
  565. X        else if (q[0] == '#' && is_parm_name(fn_nam, q+1))
  566. X            {
  567. X            i_parm = fn_parm_index(fn_nam, q+1);
  568. X            replace(level, "R", repl[0], q, q+2,
  569. X                stringize(actual[i_parm][0]));
  570. X            q += 2;    /* advance past "" */
  571. X            }
  572. X        else if (is_parm_name(fn_nam, q))
  573. X            {
  574. X            i_parm = fn_parm_index(fn_nam, q);
  575. X            replace(level, "R", repl[0], q, q+1,
  576. X                expandeds[i_parm][0]);
  577. X            q += strlen(expandeds[i_parm][0]);    /* advance past expansion */
  578. X            }
  579. X        else        /* ordinary token */
  580. X            ++q;
  581. X        }
  582. X    replace(level, "", buf, start_invok, p, repl[0]);
  583. X    }
  584. X
  585. X
  586. X
  587. X
  588. Xmain()
  589. X    {
  590. X    char line[BUFSIZ];
  591. X
  592. X    while (gets(line))
  593. X        {
  594. X        set_hide(line, " ");
  595. X        preproc(line);
  596. X        }
  597. X    } /* end main */
  598. END-of-mac.c
  599. echo file: std1.in
  600. sed 's/^X//' >std1.in << 'END-of-std1.in'
  601. X#d f(a) f( x * (a))
  602. X#d z z[0]
  603. X#d x 2
  604. Xf(y+1) + f(f(z)) %
  605. END-of-std1.in
  606. echo file: std2.in
  607. sed 's/^X//' >std2.in << 'END-of-std2.in'
  608. X#d f(a) f( x * (a))
  609. X#d x    2
  610. X#d g    f
  611. X#d t(a) a
  612. Xt(t(g)(0) + t)(1);
  613. END-of-std2.in
  614. echo file: std3.in
  615. sed 's/^X//' >std3.in << 'END-of-std3.in'
  616. X#d f(a) f( x * (a))
  617. X#d x    2
  618. X#d g    f
  619. X#d w    0,1
  620. X#d h    g(~
  621. X
  622. Xg(x+(3,4)-w) | h 5)
  623. END-of-std3.in
  624. echo file: std4.in
  625. sed 's/^X//' >std4.in << 'END-of-std4.in'
  626. X#d f(a) f( x * (a))
  627. X#d x    2
  628. X#d m(a) a(w)
  629. X#d w    0,1
  630. X
  631. Xm (f)^m(m) ;
  632. END-of-std4.in
  633. echo file: test1.in
  634. sed 's/^X//' >test1.in << 'END-of-test1.in'
  635. X#d x(c) (y(c,3))
  636. X#d y(a, b) x(a+b)
  637. Xy(x(2),1)
  638. END-of-test1.in
  639. echo file: test2.in
  640. sed 's/^X//' >test2.in << 'END-of-test2.in'
  641. X#d f(a) i(x*(a))
  642. X#d j(a) k(x*(a))
  643. X#d z y[0]
  644. X#d x 2
  645. Xf(j(z)) 3 4 z
  646. X
  647. X#d h(g) g
  648. X#d a()  0
  649. X#d b    ()
  650. X#d c    a b
  651. Xh(c)
  652. X
  653. X#d m(a) <<#a>>
  654. X#d n(a) m(a)
  655. Xm(1 2 3)
  656. Xm(z)
  657. Xn(z)
  658. X
  659. X#d e(a, b) [[a##b]]
  660. Xe(x,y)
  661. END-of-test2.in
  662. echo file: test5.in
  663. sed 's/^X//' >test5.in << 'END-of-test5.in'
  664. X#d h(g) g
  665. X#d a()  0
  666. X#d b    ()
  667. X#d c    a b
  668. Xh(c)
  669. END-of-test5.in
  670. echo file: test6.in
  671. sed 's/^X//' >test6.in << 'END-of-test6.in'
  672. X#d m(a) <<#a>>
  673. X#d n(a) m(a)
  674. Xm(1 2 3)
  675. Xm(z)
  676. Xn(z)
  677. END-of-test6.in
  678. echo file: test7.in
  679. sed 's/^X//' >test7.in << 'END-of-test7.in'
  680. X#d e(a, b) [[a##b]]
  681. Xe(x,y)
  682. END-of-test7.in
  683. echo file: test8.in
  684. sed 's/^X//' >test8.in << 'END-of-test8.in'
  685. X#d f(a) a * g
  686. X#d g(a) f(a)
  687. X
  688. Xf(2)(9)
  689. END-of-test8.in
  690. echo file: std1.out
  691. sed 's/^X//' >std1.out << 'END-of-std1.out'
  692. Xfn:  nam=<f> parms=<a> def=<f( x * (a))>
  693. X                           <fffffffffff>
  694. Xobj: nam=<z> def=<z[0]>
  695. X                 <zzzz>
  696. Xobj: nam=<x> def=<2>
  697. X                 <x>
  698. X0: f(y+1) + f(f(z)) %
  699. X :                   
  700. X1: y+1
  701. X :    
  702. X0R: f(_)
  703. X  :     
  704. X0R: f( x * (a))
  705. X  : fffffffffff
  706. X0R: f( x * (y+1))
  707. X  : fffffffffffff
  708. X0: f( x * (y+1)) + f(f(z)) %
  709. X : fffffffffffff            
  710. X0: F( x * (y+1)) + f(f(z)) %
  711. X : fffffffffffff            
  712. Xhide-set #0 = {fx}
  713. X0: F( 2 * (y+1)) + f(f(z)) %
  714. X : fff0fffffffff            
  715. X1: f(z)
  716. X :     
  717. X1.1: z
  718. X   :  
  719. X1.1: z[0]
  720. X   : zzzz
  721. X1.1: Z[0]
  722. X   : zzzz
  723. X1R: f(_)
  724. X  :     
  725. X1R: f( x * (a))
  726. X  : fffffffffff
  727. Xhide-set #1 = {fz}
  728. X1R: f( x * (Z[0]))
  729. X  : ffffffff1111ff
  730. X1: f( x * (Z[0]))
  731. X : ffffffff1111ff
  732. X1: F( x * (Z[0]))
  733. X : ffffffff1111ff
  734. X1: F( 2 * (Z[0]))
  735. X : fff0ffff1111ff
  736. X0R: f(_)
  737. X  :     
  738. X0R: f( x * (a))
  739. X  : fffffffffff
  740. X0R: f( x * (F( 2 * (Z[0]))))
  741. X  : fffffffffff0ffff1111ffff
  742. X0: F( 2 * (y+1)) + f( x * (F( 2 * (Z[0])))) %
  743. X : fff0fffffffff   fffffffffff0ffff1111ffff  
  744. X0: F( 2 * (y+1)) + F( x * (F( 2 * (Z[0])))) %
  745. X : fff0fffffffff   fffffffffff0ffff1111ffff  
  746. X0: F( 2 * (y+1)) + F( 2 * (F( 2 * (Z[0])))) %
  747. X : fff0fffffffff   fff0fffffff0ffff1111ffff  
  748. X0: f( 2 * (y+1)) + f( 2 * (f( 2 * (z[0])))) %
  749. X :                                           
  750. END-of-std1.out
  751. echo file: std2.out
  752. sed 's/^X//' >std2.out << 'END-of-std2.out'
  753. Xfn:  nam=<f> parms=<a> def=<f( x * (a))>
  754. X                           <fffffffffff>
  755. Xobj: nam=<x> def=<2>
  756. X                 <x>
  757. Xobj: nam=<g> def=<f>
  758. X                 <g>
  759. Xfn:  nam=<t> parms=<a> def=<a>
  760. X                           <t>
  761. X0: t(t(g)(0) + t)(1);
  762. X :                   
  763. X1: t(g)(0) + t
  764. X :            
  765. X1.1: g
  766. X   :  
  767. X1.1: f
  768. X   : g
  769. Xtreating end-of-buffer as end-of-file
  770. X1R: t(_)
  771. X  :     
  772. X1R: a
  773. X  : t
  774. Xhide-set #0 = {gt}
  775. X1R: f
  776. X  : 0
  777. X1: f(0) + t
  778. X : 0       
  779. X1.1: 0
  780. X   :  
  781. X1R: f(_)
  782. X  :     
  783. X1R: f( x * (a))
  784. X  : fffffffffff
  785. X1R: f( x * (0))
  786. X  : fffffffffff
  787. Xhide-set #1 = {fgt}
  788. X1: f( x * (0)) + t
  789. X : 11111111111    
  790. X1: F( x * (0)) + t
  791. X : 11111111111    
  792. Xhide-set #2 = {fgtx}
  793. X1: F( 2 * (0)) + t
  794. X : 11121111111    
  795. Xtreating end-of-buffer as end-of-file
  796. X0R: t(_)
  797. X  :     
  798. X0R: a
  799. X  : t
  800. X0R: F( 2 * (0)) + t
  801. X  : 11121111111tttt
  802. X0: F( 2 * (0)) + t(1);
  803. X : 11121111111tttt    
  804. X0: F( 2 * (0)) + T(1);
  805. X : 11121111111tttt    
  806. X0: f( 2 * (0)) + t(1);
  807. X :                    
  808. END-of-std2.out
  809. echo file: std3.out
  810. sed 's/^X//' >std3.out << 'END-of-std3.out'
  811. Xfn:  nam=<f> parms=<a> def=<f( x * (a))>
  812. X                           <fffffffffff>
  813. Xobj: nam=<x> def=<2>
  814. X                 <x>
  815. Xobj: nam=<g> def=<f>
  816. X                 <g>
  817. Xobj: nam=<w> def=<0,1>
  818. X                 <www>
  819. Xobj: nam=<h> def=<g(~>
  820. X                 <hhh>
  821. X0: 
  822. X : 
  823. X0: 
  824. X : 
  825. X0: g(x+(3,4)-w) | h 5)
  826. X :                    
  827. X0: f(x+(3,4)-w) | h 5)
  828. X : g                  
  829. X1: x+(3,4)-w
  830. X :          
  831. X1: 2+(3,4)-w
  832. X : x        
  833. X1: 2+(3,4)-0,1
  834. X : x       www
  835. X0R: f(_)
  836. X  :     
  837. X0R: f( x * (a))
  838. X  : fffffffffff
  839. Xhide-set #0 = {fx}
  840. Xhide-set #1 = {fw}
  841. X0R: f( x * (2+(3,4)-0,1))
  842. X  : ffffffff0fffffff111ff
  843. Xhide-set #2 = {fg}
  844. Xhide-set #3 = {fgx}
  845. Xhide-set #4 = {fgw}
  846. X0: f( x * (2+(3,4)-0,1)) | h 5)
  847. X : 222222223222222244422       
  848. X0: F( x * (2+(3,4)-0,1)) | h 5)
  849. X : 222222223222222244422       
  850. X0: F( 2 * (2+(3,4)-0,1)) | h 5)
  851. X : 222322223222222244422       
  852. X0: F( 2 * (2+(3,4)-0,1)) | g(~ 5)
  853. X : 222322223222222244422   hhh   
  854. Xhide-set #5 = {gh}
  855. X0: F( 2 * (2+(3,4)-0,1)) | f(~ 5)
  856. X : 222322223222222244422   5hh   
  857. X1: ~ 5
  858. X : h  
  859. X0R: f(_)
  860. X  :     
  861. X0R: f( x * (a))
  862. X  : fffffffffff
  863. Xhide-set #6 = {fh}
  864. X0R: f( x * (~ 5))
  865. X  : ffffffff6ffff
  866. Xhide-set #7 = {fgh}
  867. Xhide-set #8 = {fghh}
  868. X0: F( 2 * (2+(3,4)-0,1)) | f( x * (~ 5))
  869. X : 222322223222222244422   7777777787777
  870. X0: F( 2 * (2+(3,4)-0,1)) | F( x * (~ 5))
  871. X : 222322223222222244422   7777777787777
  872. Xhide-set #9 = {fghx}
  873. X0: F( 2 * (2+(3,4)-0,1)) | F( 2 * (~ 5))
  874. X : 222322223222222244422   7779777787777
  875. X0: f( 2 * (2+(3,4)-0,1)) | f( 2 * (~ 5))
  876. X :                                      
  877. END-of-std3.out
  878. echo file: std4.out
  879. sed 's/^X//' >std4.out << 'END-of-std4.out'
  880. Xfn:  nam=<f> parms=<a> def=<f( x * (a))>
  881. X                           <fffffffffff>
  882. Xobj: nam=<x> def=<2>
  883. X                 <x>
  884. Xfn:  nam=<m> parms=<a> def=<a(w)>
  885. X                           <mmmm>
  886. Xobj: nam=<w> def=<0,1>
  887. X                 <www>
  888. X0: 
  889. X : 
  890. X0: 
  891. X : 
  892. X0: m (f)^m(m) ;
  893. X :             
  894. X1: f
  895. X :  
  896. Xtreating end-of-buffer as end-of-file
  897. X0R: m(_)
  898. X  :     
  899. X0R: a(w)
  900. X  : mmmm
  901. X0R: f(w)
  902. X  : mmmm
  903. X0: f(w)^m(m) ;
  904. X : mmmm       
  905. X1: w
  906. X : m
  907. Xhide-set #0 = {mw}
  908. X1: 0,1
  909. X : 000
  910. X0R: f(_)
  911. X  :     
  912. X0R: f( x * (a))
  913. X  : fffffffffff
  914. Xhide-set #1 = {fmw}
  915. X0R: f( x * (0,1))
  916. X  : ffffffff111ff
  917. Xhide-set #2 = {fm}
  918. X0: f( x * (0,1))^m(m) ;
  919. X : 2222222211122       
  920. X0: F( x * (0,1))^m(m) ;
  921. X : 2222222211122       
  922. Xhide-set #3 = {fmx}
  923. X0: F( 2 * (0,1))^m(m) ;
  924. X : 2223222211122       
  925. X1: m
  926. X :  
  927. Xtreating end-of-buffer as end-of-file
  928. X0R: m(_)
  929. X  :     
  930. X0R: a(w)
  931. X  : mmmm
  932. X0R: m(w)
  933. X  : mmmm
  934. X0: F( 2 * (0,1))^m(w) ;
  935. X : 2223222211122 mmmm  
  936. X0: F( 2 * (0,1))^M(w) ;
  937. X : 2223222211122 mmmm  
  938. X0: F( 2 * (0,1))^M(0,1) ;
  939. X : 2223222211122 mm000m  
  940. X0: f( 2 * (0,1))^m(0,1) ;
  941. X :                       
  942. END-of-std4.out
  943. echo file: test1.out
  944. sed 's/^X//' >test1.out << 'END-of-test1.out'
  945. Xfn:  nam=<x> parms=<c> def=<(y(c,3))>
  946. X                           <xxxxxxxx>
  947. Xfn:  nam=<y> parms=<ab> def=<x(a+b)>
  948. X                            <yyyyyy>
  949. X0: y(x(2),1)
  950. X :          
  951. X1: x(2)
  952. X :     
  953. X1.1: 2
  954. X   :  
  955. X1R: x(_)
  956. X  :     
  957. X1R: (y(c,3))
  958. X  : xxxxxxxx
  959. X1R: (y(2,3))
  960. X  : xxxxxxxx
  961. X1: (y(2,3))
  962. X : xxxxxxxx
  963. X1.1: 2
  964. X   : x
  965. X1.2: 3
  966. X   : x
  967. X1R: y(_,_)
  968. X  :       
  969. X1R: x(a+b)
  970. X  : yyyyyy
  971. Xhide-set #0 = {xy}
  972. X1R: x(2+b)
  973. X  : yy0yyy
  974. X1R: x(2+3)
  975. X  : yy0y0y
  976. X1: (x(2+3))
  977. X : x000000x
  978. X1: (X(2+3))
  979. X : x000000x
  980. X2: 1
  981. X :  
  982. X0R: y(_,_)
  983. X  :       
  984. X0R: x(a+b)
  985. X  : yyyyyy
  986. X0R: x((X(2+3))+b)
  987. X  : yy00000000yyy
  988. X0R: x((X(2+3))+1)
  989. X  : yy00000000yyy
  990. X0: x((X(2+3))+1)
  991. X : yy00000000yyy
  992. X1: (X(2+3))+1
  993. X : 00000000yy
  994. X0R: x(_)
  995. X  :     
  996. X0R: (y(c,3))
  997. X  : xxxxxxxx
  998. X0R: (y((X(2+3))+1,3))
  999. X  : xxx0000000000xxxx
  1000. X0: (y((X(2+3))+1,3))
  1001. X : 00000000000000000
  1002. X0: (Y((X(2+3))+1,3))
  1003. X : 00000000000000000
  1004. X0: (y((x(2+3))+1,3))
  1005. X :                  
  1006. END-of-test1.out
  1007. echo file: test2.out
  1008. sed 's/^X//' >test2.out << 'END-of-test2.out'
  1009. Xfn:  nam=<f> parms=<a> def=<i(x*(a))>
  1010. X                           <ffffffff>
  1011. Xfn:  nam=<j> parms=<a> def=<k(x*(a))>
  1012. X                           <jjjjjjjj>
  1013. Xobj: nam=<z> def=<y[0]>
  1014. X                 <zzzz>
  1015. Xobj: nam=<x> def=<2>
  1016. X                 <x>
  1017. X0: f(j(z)) 3 4 z
  1018. X :              
  1019. X1: j(z)
  1020. X :     
  1021. X1.1: z
  1022. X   :  
  1023. X1.1: y[0]
  1024. X   : zzzz
  1025. X1R: j(_)
  1026. X  :     
  1027. X1R: k(x*(a))
  1028. X  : jjjjjjjj
  1029. Xhide-set #0 = {jz}
  1030. X1R: k(x*(y[0]))
  1031. X  : jjjjj0000jj
  1032. X1: k(x*(y[0]))
  1033. X : jjjjj0000jj
  1034. Xhide-set #1 = {jx}
  1035. X1: k(2*(y[0]))
  1036. X : jj1jj0000jj
  1037. X0R: f(_)
  1038. X  :     
  1039. X0R: i(x*(a))
  1040. X  : ffffffff
  1041. Xhide-set #2 = {fj}
  1042. Xhide-set #3 = {fjx}
  1043. Xhide-set #4 = {fjz}
  1044. X0R: i(x*(k(2*(y[0]))))
  1045. X  : fffff22322444422ff
  1046. X0: i(x*(k(2*(y[0])))) 3 4 z
  1047. X : fffff22322444422ff      
  1048. Xhide-set #5 = {fx}
  1049. X0: i(2*(k(2*(y[0])))) 3 4 z
  1050. X : ff5ff22322444422ff      
  1051. X0: i(2*(k(2*(y[0])))) 3 4 y[0]
  1052. X : ff5ff22322444422ff     zzzz
  1053. X0: i(2*(k(2*(y[0])))) 3 4 y[0]
  1054. X :                            
  1055. X0: 
  1056. X : 
  1057. X0: 
  1058. X : 
  1059. Xfn:  nam=<h> parms=<g> def=<g>
  1060. X                           <h>
  1061. Xfn:  nam=<a> parms=<> def=<0>
  1062. X                          <a>
  1063. Xobj: nam=<b> def=<()>
  1064. X                 <bb>
  1065. Xobj: nam=<c> def=<a b>
  1066. X                 <ccc>
  1067. X0: h(c)
  1068. X :     
  1069. X1: c
  1070. X :  
  1071. X1: a b
  1072. X : ccc
  1073. Xhide-set #6 = {bc}
  1074. X1: a ()
  1075. X : cc66
  1076. X0R: h(_)
  1077. X  :     
  1078. X0R: g
  1079. X  : h
  1080. Xhide-set #7 = {ch}
  1081. Xhide-set #8 = {bch}
  1082. X0R: a ()
  1083. X  : 7788
  1084. X0: a ()
  1085. X : 7788
  1086. X0R: a()
  1087. X  :    
  1088. X0R: 0
  1089. X  : a
  1090. Xhide-set #9 = {ach}
  1091. X0: 0
  1092. X : 9
  1093. X0: 0
  1094. X :  
  1095. X0: 
  1096. X : 
  1097. X0: 
  1098. X : 
  1099. Xfn:  nam=<m> parms=<a> def=<<<#a>>>
  1100. X                           <mmmmmm>
  1101. Xfn:  nam=<n> parms=<a> def=<m(a)>
  1102. X                           <nnnn>
  1103. X0: m(1 2 3)
  1104. X :         
  1105. X1: 1 2 3
  1106. X :      
  1107. X0R: m(_)
  1108. X  :     
  1109. X0R: <<#a>>
  1110. X  : mmmmmm
  1111. Xstring "1 2 3" --> ""
  1112. X0R: <<"">>
  1113. X  : mmmmmm
  1114. X0: <<"">>
  1115. X : mmmmmm
  1116. X0: <<"">>
  1117. X :       
  1118. X0: m(z)
  1119. X :     
  1120. X1: z
  1121. X :  
  1122. X1: y[0]
  1123. X : zzzz
  1124. X0R: m(_)
  1125. X  :     
  1126. X0R: <<#a>>
  1127. X  : mmmmmm
  1128. Xstring "z" --> ""
  1129. X0R: <<"">>
  1130. X  : mmmmmm
  1131. X0: <<"">>
  1132. X : mmmmmm
  1133. X0: <<"">>
  1134. X :       
  1135. X0: n(z)
  1136. X :     
  1137. X1: z
  1138. X :  
  1139. X1: y[0]
  1140. X : zzzz
  1141. X0R: n(_)
  1142. X  :     
  1143. X0R: m(a)
  1144. X  : nnnn
  1145. Xtoo many hide-sets
  1146. END-of-test2.out
  1147. echo file: test5.out
  1148. sed 's/^X//' >test5.out << 'END-of-test5.out'
  1149. Xfn:  nam=<h> parms=<g> def=<g>
  1150. X                           <h>
  1151. Xfn:  nam=<a> parms=<> def=<0>
  1152. X                          <a>
  1153. Xobj: nam=<b> def=<()>
  1154. X                 <bb>
  1155. Xobj: nam=<c> def=<a b>
  1156. X                 <ccc>
  1157. X0: h(c)
  1158. X :     
  1159. X1: c
  1160. X :  
  1161. X1: a b
  1162. X : ccc
  1163. Xhide-set #0 = {bc}
  1164. X1: a ()
  1165. X : cc00
  1166. X0R: h(_)
  1167. X  :     
  1168. X0R: g
  1169. X  : h
  1170. Xhide-set #1 = {ch}
  1171. Xhide-set #2 = {bch}
  1172. X0R: a ()
  1173. X  : 1122
  1174. X0: a ()
  1175. X : 1122
  1176. X0R: a()
  1177. X  :    
  1178. X0R: 0
  1179. X  : a
  1180. Xhide-set #3 = {ach}
  1181. X0: 0
  1182. X : 3
  1183. X0: 0
  1184. X :  
  1185. END-of-test5.out
  1186. echo file: test6.out
  1187. sed 's/^X//' >test6.out << 'END-of-test6.out'
  1188. Xfn:  nam=<m> parms=<a> def=<<<#a>>>
  1189. X                           <mmmmmm>
  1190. Xfn:  nam=<n> parms=<a> def=<m(a)>
  1191. X                           <nnnn>
  1192. X0: m(1 2 3)
  1193. X :         
  1194. X1: 1 2 3
  1195. X :      
  1196. X0R: m(_)
  1197. X  :     
  1198. X0R: <<#a>>
  1199. X  : mmmmmm
  1200. Xstring "1 2 3" --> ""
  1201. X0R: <<"">>
  1202. X  : mmmmmm
  1203. X0: <<"">>
  1204. X : mmmmmm
  1205. X0: <<"">>
  1206. X :       
  1207. X0: m(z)
  1208. X :     
  1209. X1: z
  1210. X :  
  1211. X0R: m(_)
  1212. X  :     
  1213. X0R: <<#a>>
  1214. X  : mmmmmm
  1215. Xstring "z" --> ""
  1216. X0R: <<"">>
  1217. X  : mmmmmm
  1218. X0: <<"">>
  1219. X : mmmmmm
  1220. X0: <<"">>
  1221. X :       
  1222. X0: n(z)
  1223. X :     
  1224. X1: z
  1225. X :  
  1226. X0R: n(_)
  1227. X  :     
  1228. X0R: m(a)
  1229. X  : nnnn
  1230. X0R: m(z)
  1231. X  : nnnn
  1232. X0: m(z)
  1233. X : nnnn
  1234. X1: z
  1235. X : n
  1236. X0R: m(_)
  1237. X  :     
  1238. X0R: <<#a>>
  1239. X  : mmmmmm
  1240. Xstring "z" --> ""
  1241. X0R: <<"">>
  1242. X  : mmmmmm
  1243. Xhide-set #0 = {mn}
  1244. X0: <<"">>
  1245. X : 000000
  1246. X0: <<"">>
  1247. X :       
  1248. END-of-test6.out
  1249. echo file: test7.out
  1250. sed 's/^X//' >test7.out << 'END-of-test7.out'
  1251. Xfn:  nam=<e> parms=<ab> def=<[[a##b]]>
  1252. X                            <eeeeeeee>
  1253. X0: e(x,y)
  1254. X :       
  1255. X1: x
  1256. X :  
  1257. X2: y
  1258. X :  
  1259. X0R: e(_,_)
  1260. X  :       
  1261. X0R: [[a##b]]
  1262. X  : eeeeeeee
  1263. Xcatenate ab --> c
  1264. X0R: [[c]]
  1265. X  : eeeee
  1266. X0: [[c]]
  1267. X : eeeee
  1268. X0: [[c]]
  1269. X :      
  1270. END-of-test7.out
  1271. echo file: test8.out
  1272. sed 's/^X//' >test8.out << 'END-of-test8.out'
  1273. Xfn:  nam=<f> parms=<a> def=<a * g>
  1274. X                           <fffff>
  1275. Xfn:  nam=<g> parms=<a> def=<f(a)>
  1276. X                           <gggg>
  1277. X0: 
  1278. X : 
  1279. X0: 
  1280. X : 
  1281. X0: f(2)(9)
  1282. X :        
  1283. X1: 2
  1284. X :  
  1285. X0R: f(_)
  1286. X  :     
  1287. X0R: a * g
  1288. X  : fffff
  1289. X0R: 2 * g
  1290. X  : fffff
  1291. X0: 2 * g(9)
  1292. X : fffff   
  1293. X1: 9
  1294. X :  
  1295. X0R: g(_)
  1296. X  :     
  1297. X0R: f(a)
  1298. X  : gggg
  1299. X0R: f(9)
  1300. X  : gggg
  1301. Xhide-set #0 = {fg}
  1302. X0: 2 * f(9)
  1303. X : ffff0000
  1304. X0: 2 * F(9)
  1305. X : ffff0000
  1306. X0: 2 * f(9)
  1307. X :         
  1308. END-of-test8.out
  1309. exit
  1310. -- 
  1311.       Eric S. Raymond = eric@snark.uu.net    (mad mastermind of TMN-Netnews)
  1312.  
  1313.  
  1314.