home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume21 / p2c / part08 < prev    next >
Text File  |  1990-04-05  |  56KB  |  1,588 lines
  1. Subject:  v21i053:  Pascal to C translator, Part08/32
  2. Newsgroups: comp.sources.unix
  3. Approved: rsalz@uunet.UU.NET
  4. X-Checksum-Snefru: 60f295ea df7ce5df f553cf94 86a08247
  5.  
  6. Submitted-by: Dave Gillespie <daveg@csvax.caltech.edu>
  7. Posting-number: Volume 21, Issue 53
  8. Archive-name: p2c/part08
  9.  
  10. #! /bin/sh
  11. # This is a shell archive.  Remove anything before this line, then unpack
  12. # it by saving it into a file and typing "sh file".  To overwrite existing
  13. # files, type "sh file -c".  You can also feed this as standard input via
  14. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  15. # will see the following message at the end:
  16. #        "End of archive 8 (of 32)."
  17. # Contents:  src/parse.c.3 src/sys.p2crc.2
  18. # Wrapped by rsalz@litchi.bbn.com on Mon Mar 26 14:29:32 1990
  19. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  20. if test -f 'src/parse.c.3' -a "${1}" != "-c" ; then 
  21.   echo shar: Will not clobber existing file \"'src/parse.c.3'\"
  22. else
  23. echo shar: Extracting \"'src/parse.c.3'\" \(25765 characters\)
  24. sed "s/^X//" >'src/parse.c.3' <<'END_OF_FILE'
  25. X        mp->isreturn) {    /* the was-#defined flag */
  26. X        if (!anywords)
  27. X            outsection(minorspace);
  28. X        anywords++;
  29. X        output(format_s("#undef %s\n", mp->name));
  30. X        sym = findsymbol(mp->name);
  31. X        sym->flags &= ~AVOIDNAME;
  32. X        }
  33. X    }
  34. X    }
  35. X    if (conserve_mem) {
  36. X    free_stmt((Stmt *)func->val.i);   /* is this safe? */
  37. X    func->val.i = 0;
  38. X    forget_ctx(func, 0);
  39. X    }
  40. X    outsection(spacing);
  41. X}
  42. X
  43. X
  44. X
  45. X
  46. Xvoid movetoend(mp)
  47. XMeaning *mp;
  48. X{
  49. X    Meaning **mpp;
  50. X
  51. X    if (mp->ctx != curctx) {
  52. X        intwarning("movetoend", "curctx is wrong [268]");
  53. X    } else {
  54. X        mpp = &mp->ctx->cbase;     /* move a meaning to end of its parent context */
  55. X        while (*mpp != mp) {
  56. X        if (!*mpp) {
  57. X        intwarning("movetoend", "meaning not on its context list [269]");
  58. X        return;
  59. X        }
  60. X            mpp = &(*mpp)->cnext;
  61. X    }
  62. X        *mpp = mp->cnext;    /* Remove from present position in list */
  63. X        while (*mpp)
  64. X            mpp = &(*mpp)->cnext;
  65. X        *mpp = mp;           /* Insert at end of list */
  66. X        mp->cnext = NULL;
  67. X        curctxlast = mp;
  68. X    }
  69. X}
  70. X
  71. X
  72. X
  73. XStatic void scanfwdparams(mp)
  74. XMeaning *mp;
  75. X{
  76. X    Symbol *sym;
  77. X
  78. X    mp = mp->type->fbase;
  79. X    while (mp) {
  80. X    sym = findsymbol(mp->name);
  81. X    sym->flags |= FWDPARAM;
  82. X    mp = mp->xnext;
  83. X    }
  84. X}
  85. X
  86. X
  87. X
  88. XStatic void p_function(isfunc)
  89. Xint isfunc;
  90. X{
  91. X    Meaning *func;
  92. X    Type *type;
  93. X    Stmt *sp;
  94. X    Strlist *sl, *comments, *savecmt;
  95. X    int initializeattr = 0, isinline = 0;
  96. X
  97. X    if ((sl = strlist_find(attrlist, "INITIALIZE")) != NULL) {
  98. X    initializeattr = 1;
  99. X    strlist_delete(&attrlist, sl);
  100. X    }
  101. X    if ((sl = strlist_find(attrlist, "OPTIMIZE")) != NULL &&
  102. X    sl->value != -1 &&
  103. X    !strcmp((char *)(sl->value), "INLINE")) {
  104. X    isinline = 1;
  105. X    strlist_delete(&attrlist, sl);
  106. X    }
  107. X    ignore_attributes();
  108. X    comments = extractcomment(&curcomments, -1, curserial);
  109. X    changecomments(comments, -1, -1, -1, 0);
  110. X    if (curctx->kind == MK_FUNCTION) {    /* sub-procedure */
  111. X    savecmt = curcomments;
  112. X    } else {
  113. X    savecmt = NULL;
  114. X    flushcomments(&curcomments, -1, -1);
  115. X    }
  116. X    curcomments = comments;
  117. X    curserial = serialcount = 1;
  118. X    gettok();
  119. X    if (!wexpecttok(TOK_IDENT))
  120. X    skiptotoken(TOK_IDENT);
  121. X    if (curtokmeaning && curtokmeaning->ctx == curctx &&
  122. X        curtokmeaning->kind == MK_FUNCTION) {
  123. X        func = curtokmeaning;
  124. X        if (!func->isforward || func->val.i)
  125. X            warning(format_s("Redeclaration of function %s [270]", func->name));
  126. X    skiptotoken(TOK_SEMI);
  127. X        movetoend(func);
  128. X        pushctx(func);
  129. X        type = func->type;
  130. X    } else {
  131. X        func = addmeaning(curtoksym, MK_FUNCTION);
  132. X        gettok();
  133. X        func->val.i = 0;
  134. X        pushctx(func);
  135. X        func->type = type = p_funcdecl(&isfunc, 0);
  136. X        func->isfunction = isfunc;
  137. X    func->namedfile = isinline;
  138. X        type->meaning = func;
  139. X    }
  140. X    wneedtok(TOK_SEMI);
  141. X    if (initializeattr) {
  142. X    sl = strlist_append(&initialcalls, format_s("%s()", func->name));
  143. X    sl->value = 1;
  144. X    }
  145. X    if (curtok == TOK_IDENT && !strcmp(curtokbuf, "C")) {
  146. X    gettok();
  147. X    wneedtok(TOK_SEMI);
  148. X    }
  149. X    if (blockkind == TOK_IMPORT) {
  150. X    strlist_empty(&curcomments);
  151. X    if (curtok == TOK_IDENT &&
  152. X        (!strcicmp(curtokbuf, "FORWARD") ||
  153. X         strlist_cifind(externwords, curtokbuf))) {
  154. X        gettok();
  155. X        while (curtok == TOK_IDENT)
  156. X        gettok();
  157. X        wneedtok(TOK_SEMI);
  158. X    }
  159. X        /* do nothing more */
  160. X    } else if (blockkind == TOK_EXPORT) {
  161. X        func->isforward = 1;
  162. X    scanfwdparams(func);
  163. X    flushcomments(NULL, -1, -1);
  164. X        forward_decl(func, 1);
  165. X    } else {
  166. X    checkkeyword(TOK_INTERRUPT);
  167. X    checkkeyword(TOK_INLINE);
  168. X        if (curtok == TOK_INTERRUPT) {
  169. X            note("Ignoring INTERRUPT keyword [258]");
  170. X            gettok();
  171. X            wneedtok(TOK_SEMI);
  172. X        }
  173. X        if (curtok == TOK_IDENT && !strcicmp(curtokbuf, "FORWARD")) {
  174. X            func->isforward = 1;
  175. X        scanfwdparams(func);
  176. X            gettok();
  177. X            if (func->ctx->kind != MK_FUNCTION) {
  178. X                outsection(minorspace);
  179. X        flushcomments(NULL, -1, -1);
  180. X                forward_decl(func, 0);
  181. X                outsection(minorspace);
  182. X            }
  183. X        } else if (curtok == TOK_IDENT &&
  184. X           (strlist_cifind(externwords, curtokbuf) ||
  185. X            strlist_cifind(cexternwords, curtokbuf))) {
  186. X            if (*externalias && my_strchr(externalias, '%')) {
  187. X                strchange(&func->name, format_s(externalias, func->name));
  188. X            } else if (strlist_cifind(cexternwords, curtokbuf)) {
  189. X        if (func->name[0] == '_')
  190. X            strchange(&func->name, func->name + 1);
  191. X        if (func->name[strlen(func->name)-1] == '_')
  192. X            func->name[strlen(func->name)-1] = 0;
  193. X        }
  194. X        func->isforward = 1;    /* for Oregon Software Pascal-2 */
  195. X        func->exported = 1;
  196. X            gettok();
  197. X        while (curtok == TOK_IDENT)
  198. X        gettok();
  199. X            outsection(minorspace);
  200. X        flushcomments(NULL, -1, -1);
  201. X        scanfwdparams(func);
  202. X            forward_decl(func, 1);
  203. X            outsection(minorspace);
  204. X    } else if (curtok == TOK_IDENT) {
  205. X        wexpecttok(TOK_BEGIN);   /* print warning */
  206. X        gettok();
  207. X            outsection(minorspace);
  208. X        flushcomments(NULL, -1, -1);
  209. X        scanfwdparams(func);
  210. X            forward_decl(func, 1);
  211. X            outsection(minorspace);
  212. X        } else {
  213. X            if (func->ctx->kind == MK_FUNCTION)
  214. X                func->ctx->needvarstruct = 1;
  215. X        func->comments = curcomments;
  216. X        curcomments = NULL;
  217. X            p_block(TOK_FUNCTION);
  218. X            echoprocname(func);
  219. X        changecomments(curcomments, -1, curserial, -1, 10000);
  220. X            sp = p_body();
  221. X            func->ctx->needvarstruct = 0;
  222. X            func->val.i = (long)sp;
  223. X        strlist_mix(&func->comments, curcomments);
  224. X        curcomments = NULL;
  225. X            if (func->ctx->kind != MK_FUNCTION || !collectnest) {
  226. X                out_function(func);    /* output top-level procedures immediately */
  227. X            }                          /*  (sub-procedures are output later) */
  228. X        }
  229. X        if (!wneedtok(TOK_SEMI))
  230. X        skippasttoken(TOK_SEMI);
  231. X    }
  232. X    strlist_mix(&curcomments, savecmt);
  233. X    popctx();
  234. X}
  235. X
  236. X
  237. X
  238. XStatic void out_include(name, quoted)
  239. Xchar *name;
  240. Xint quoted;
  241. X{
  242. X    if (quoted)
  243. X        output(format_s("#include \"%s\"\n", name));
  244. X    else
  245. X        output(format_s("#include <%s>\n", name));
  246. X}
  247. X
  248. X
  249. XStatic void cleanheadername(dest, name)
  250. Xchar *dest, *name;
  251. X{
  252. X    char *cp;
  253. X    int len;
  254. X
  255. X    if (*name == '<' || *name == '"')
  256. X    name++;
  257. X    cp = my_strrchr(name, '/');
  258. X    if (cp)
  259. X    cp++;
  260. X    else
  261. X    cp = name;
  262. X    strcpy(dest, cp);
  263. X    len = strlen(dest);
  264. X    if (dest[len-1] == '>' || dest[len-1] == '"')
  265. X    dest[len-1] = 0;
  266. X}
  267. X
  268. X
  269. X
  270. X
  271. XStatic int tryimport(sym, fname, ext, need)
  272. XSymbol *sym;
  273. Xchar *fname, *ext;
  274. Xint need;
  275. X{
  276. X    int found = 0;
  277. X    Meaning *savectx, *savectxlast;
  278. X
  279. X    savectx = curctx;
  280. X    savectxlast = curctxlast;
  281. X    curctx = nullctx;
  282. X    curctxlast = curctx->cbase;
  283. X    while (curctxlast && curctxlast->cnext)
  284. X        curctxlast = curctxlast->cnext;
  285. X    if (p_search(fname, ext, need)) {
  286. X        curtokmeaning = sym->mbase;
  287. X        while (curtokmeaning && !curtokmeaning->isactive)
  288. X            curtokmeaning = curtokmeaning->snext;
  289. X        if (curtokmeaning)
  290. X            found = 1;
  291. X    }
  292. X    curctx = savectx;
  293. X    curctxlast = savectxlast;
  294. X    return found;
  295. X}
  296. X
  297. X
  298. X
  299. XStatic void p_import(inheader)
  300. Xint inheader;
  301. X{
  302. X    Strlist *sl;
  303. X    Symbol *sym;
  304. X    char *name;
  305. X    int found, isfrom = (curtok == TOK_FROM);
  306. X
  307. X    outsection(minorspace);
  308. X    do {
  309. X        gettok();
  310. X        if (!wexpecttok(TOK_IDENT)) {
  311. X        skiptotoken(TOK_SEMI);
  312. X        break;
  313. X    }
  314. X        sym = curtoksym;
  315. X        if (curtokmeaning && curtokmeaning->kind == MK_MODULE) {
  316. X            found = 1;
  317. X    } else if (strlist_cifind(permimports, sym->name)) {
  318. X            found = 2;   /* built-in module, there already! */
  319. X        } else {
  320. X            found = 0;
  321. X            sl = strlist_cifind(importfrom, sym->name);
  322. X            name = (sl) ? format_none((char *)sl->value) : NULL;
  323. X            if (name) {
  324. X                if (tryimport(sym, name, "pas", 1))
  325. X                    found = 1;
  326. X            } else {
  327. X                for (sl = importdirs; sl && !found; sl = sl->next) {
  328. X                    if (tryimport(sym, format_s(sl->s, curtokcase), NULL, 0))
  329. X                        found = 1;
  330. X                }
  331. X            }
  332. X        }
  333. X        if (found == 1) {
  334. X            if (!inheader) {
  335. X                sl = strlist_cifind(includefrom, curtokmeaning->name);
  336. X                name = (sl) ? (char *)sl->value :
  337. X            format_ss(*headerfnfmt2 ? headerfnfmt2 : headerfnfmt,
  338. X                  infname, curtokmeaning->name);
  339. X                if (name && !strlist_find(includedfiles, name)) {
  340. X                    strlist_insert(&includedfiles, name);
  341. X                    if (*name_HSYMBOL)
  342. X                        output(format_s("#ifndef %s\n", format_s(name_HSYMBOL, sym->name)));
  343. X                    if (*name == '"' || *name == '<')
  344. X                        output(format_s("#include %s\n", name));
  345. X                    else
  346. X                        out_include(name, quoteincludes);
  347. X                    if (*name_HSYMBOL)
  348. X                        output("#endif\n");
  349. X                    outsection(minorspace);
  350. X                }
  351. X            }
  352. X            import_ctx(curtokmeaning);
  353. X    } else if (curtokmeaning) {
  354. X        /* Modula-2, importing a single ident */
  355. X        /* Ignored for now, since we always import whole modules */
  356. X        } else if (found == 0) {
  357. X            warning(format_s("Could not find module %s [271]", sym->name));
  358. X            if (!inheader) {
  359. X                out_include(format_ss(*headerfnfmt2?headerfnfmt2:headerfnfmt,
  360. X                      sym->name, sym->name),
  361. X                quoteincludes);
  362. X            }
  363. X        }
  364. X        gettok();
  365. X    } while (curtok == TOK_COMMA);
  366. X    if (isfrom) {
  367. X    checkkeyword(TOK_IMPORT);
  368. X    if (wneedtok(TOK_IMPORT)) {
  369. X        do {
  370. X        gettok();
  371. X        if (curtok == TOK_IDENT)
  372. X            gettok();
  373. X        } while (curtok == TOK_COMMA);
  374. X    }
  375. X    }
  376. X    if (!wneedtok(TOK_SEMI))
  377. X    skippasttoken(TOK_SEMI);
  378. X    outsection(minorspace);
  379. X}
  380. X
  381. X
  382. X
  383. X
  384. Xvoid do_include(blkind)
  385. XToken blkind;
  386. X{
  387. X    FILE *oldfile = outf;
  388. X    int savelnum = outf_lnum;
  389. X    char fname[256];
  390. X
  391. X    outsection(majorspace);
  392. X    strcpy(fname, curtokbuf);
  393. X    removesuffix(fname);
  394. X    strcat(fname, ".c");
  395. X    if (!strcmp(fname, codefname)) {
  396. X        warning("Include file name conflict! [272]");
  397. X        badinclude();
  398. X        return;
  399. X    }
  400. X    saveoldfile(fname);
  401. X    outf = fopen(fname, "w");
  402. X    if (!outf) {
  403. X        outf = oldfile;
  404. X        perror(fname);
  405. X        badinclude();
  406. X        return;
  407. X    }
  408. X    outf_lnum = 1;
  409. X    output(format_ss("\n/* Include file %s from %s */\n\n", fname, codefname));
  410. X    if (blkind == TOK_END)
  411. X        gettok();
  412. X    else
  413. X        curtok = blkind;
  414. X    p_block(blockkind);
  415. X    output("\n\n/* End. */\n\n");
  416. X    fclose(outf);
  417. X    outf = oldfile;
  418. X    outf_lnum = savelnum;
  419. X    if (curtok != TOK_EOF) {
  420. X        warning("Junk at end of include file ignored [273]");
  421. X    }
  422. X    outsection(majorspace);
  423. X    if (*includefnfmt)
  424. X    out_include(format_s(includefnfmt, fname), 1);
  425. X    else
  426. X    out_include(fname, 1);
  427. X    outsection(majorspace);
  428. X    pop_input();
  429. X    getline();
  430. X    gettok();
  431. X}
  432. X
  433. X
  434. X
  435. X
  436. X/* blockkind is one of:
  437. X       TOK_PROGRAM:     Global declarations of a program
  438. X       TOK_FUNCTION:    Declarations local to a procedure or function
  439. X       TOK_IMPORT:      Import text read from a module
  440. X       TOK_EXPORT:      Export section of a module
  441. X       TOK_IMPLEMENT:   Implementation section of a module
  442. X       TOK_END:         None of the above
  443. X*/
  444. X
  445. Xvoid p_block(blkind)
  446. XToken blkind;
  447. X{
  448. X    Token saveblockkind = blockkind;
  449. X    Token lastblockkind = TOK_END;
  450. X
  451. X    blockkind = blkind;
  452. X    for (;;) {
  453. X    while (curtok == TOK_INTFONLY) {
  454. X        include_as_import();
  455. X        gettok();
  456. X    }
  457. X        if (curtok == TOK_CONST || curtok == TOK_TYPE ||
  458. X        curtok == TOK_VAR || curtok == TOK_VALUE) {
  459. X            while (curtok == TOK_CONST || curtok == TOK_TYPE ||
  460. X           curtok == TOK_VAR || curtok == TOK_VALUE) {
  461. X                lastblockkind = curtok;
  462. X                switch (curtok) {
  463. X
  464. X                    case TOK_CONST:
  465. X                        p_constdecl();
  466. X                        break;
  467. X
  468. X                    case TOK_TYPE:
  469. X                        p_typedecl();
  470. X                        break;
  471. X
  472. X                    case TOK_VAR:
  473. X                        p_vardecl();
  474. X                        break;
  475. X
  476. X            case TOK_VALUE:
  477. X            p_valuedecl();
  478. X            break;
  479. X
  480. X            default:
  481. X            break;
  482. X                }
  483. X            }
  484. X            if ((blkind == TOK_PROGRAM ||
  485. X                 blkind == TOK_EXPORT ||
  486. X                 blkind == TOK_IMPLEMENT) &&
  487. X                (curtok != TOK_BEGIN || !mainlocals)) {
  488. X                outsection(majorspace);
  489. X                if (declarevars(curctx, 0))
  490. X                    outsection(majorspace);
  491. X            }
  492. X        } else {
  493. X        checkmodulewords();
  494. X        checkkeyword(TOK_SEGMENT);
  495. X        if (curtok == TOK_SEGMENT) {
  496. X        note("SEGMENT or OVERLAY keyword ignored [259]");
  497. X        gettok();
  498. X        }
  499. X        p_attributes();
  500. X            switch (curtok) {
  501. X
  502. X                case TOK_LABEL:
  503. X                    p_labeldecl();
  504. X                    break;
  505. X
  506. X                case TOK_IMPORT:
  507. X                case TOK_FROM:
  508. X                    p_import(0);
  509. X                    break;
  510. X
  511. X        case TOK_EXPORT:
  512. X            do {
  513. X            gettok();
  514. X            checkkeyword(TOK_QUALIFIED);
  515. X            if (curtok == TOK_QUALIFIED)
  516. X                gettok();
  517. X            wneedtok(TOK_IDENT);
  518. X            } while (curtok == TOK_COMMA);
  519. X            if (!wneedtok(TOK_SEMI))
  520. X            skippasttoken(TOK_SEMI);
  521. X            break;
  522. X
  523. X                case TOK_MODULE:
  524. X            p_nested_module();
  525. X                    break;
  526. X
  527. X                case TOK_PROCEDURE:
  528. X                    p_function(0);
  529. X                    break;
  530. X
  531. X                case TOK_FUNCTION:
  532. X                    p_function(1);
  533. X                    break;
  534. X
  535. X                case TOK_INCLUDE:
  536. X                    if (blockkind == TOK_PROGRAM ||
  537. X                        blockkind == TOK_IMPLEMENT ||
  538. X            (blockkind == TOK_FUNCTION && !collectnest)) {
  539. X                        do_include(lastblockkind);
  540. X                    } else {
  541. X                        badinclude();
  542. X                    }
  543. X                    break;
  544. X
  545. X                default:
  546. X            if (curtok == TOK_BEGIN && blockkind == TOK_IMPORT) {
  547. X            warning("BEGIN encountered in interface text [274]");
  548. X            skipparens();
  549. X            if (curtok == TOK_SEMI)
  550. X                gettok();
  551. X            break;
  552. X            }
  553. X                    blockkind = saveblockkind;
  554. X                    return;
  555. X            }
  556. X            lastblockkind = TOK_END;
  557. X        }
  558. X    }
  559. X}
  560. X
  561. X
  562. X
  563. X
  564. XStatic void skipunitheader()
  565. X{
  566. X    if (curtok == TOK_LPAR || curtok == TOK_LBR) {
  567. X    skipparens();
  568. X    }
  569. X}
  570. X
  571. X
  572. XStatic void skiptomodule()
  573. X{
  574. X    skipping_module++;
  575. X    while (curtok != TOK_MODULE) {
  576. X        if (curtok == TOK_END) {
  577. X            gettok();
  578. X            if (curtok == TOK_DOT)
  579. X                break;
  580. X        } else
  581. X            gettok();
  582. X    }
  583. X    skipping_module--;
  584. X}
  585. X
  586. X
  587. X
  588. XStatic void p_moduleinit(mod)
  589. XMeaning *mod;
  590. X{
  591. X    Stmt *sp;
  592. X    Strlist *sl;
  593. X
  594. X    if (curtok != TOK_BEGIN && curtok != TOK_END) {
  595. X    wexpecttok(TOK_END);
  596. X    skiptotoken2(TOK_BEGIN, TOK_END);
  597. X    }
  598. X    if (curtok == TOK_BEGIN || initialcalls) {
  599. X    echoprocname(mod);
  600. X    sp = p_body();
  601. X    strlist_mix(&mod->comments, curcomments);
  602. X    curcomments = NULL;
  603. X    if (ansiC != 0)
  604. X        output("void ");
  605. X    output(format_s(name_UNITINIT, mod->name));
  606. X    if (void_args)
  607. X        output("(void)\n");
  608. X    else
  609. X        output("()\n");
  610. X    outcontext = mod;
  611. X    out_block(sp, BR_FUNCTION, 10000);
  612. X    free_stmt(sp);
  613. X    /* The following must come after out_block! */
  614. X    sl = strlist_append(&initialcalls,
  615. X                format_s("%s()",
  616. X                     format_s(name_UNITINIT, mod->name)));
  617. X    sl->value = 1;
  618. X    } else
  619. X    wneedtok(TOK_END);
  620. X}
  621. X
  622. X
  623. X
  624. XStatic void p_nested_module()
  625. X{
  626. X    Meaning *mp;
  627. X
  628. X    if (!modula2) {
  629. X    note("Ignoring nested module [260]");
  630. X    p_module(1, 0);
  631. X    return;
  632. X    }
  633. X    note("Nested modules not fully supported [261]");
  634. X    checkmodulewords();
  635. X    wneedtok(TOK_MODULE);
  636. X    wexpecttok(TOK_IDENT);
  637. X    mp = addmeaning(curtoksym, MK_MODULE);
  638. X    mp->anyvarflag = 0;
  639. X    gettok();
  640. X    skipunitheader();
  641. X    wneedtok(TOK_SEMI);
  642. X    p_block(TOK_IMPLEMENT);
  643. X    p_moduleinit(mp);
  644. X    if (curtok == TOK_IDENT)
  645. X    gettok();
  646. X    wneedtok(TOK_SEMI);
  647. X}
  648. X
  649. X
  650. X
  651. XStatic int p_module(ignoreit, isdefn)
  652. Xint ignoreit;
  653. Xint isdefn;    /* Modula-2: 0=local module, 1=DEFINITION, 2=IMPLEMENTATION */
  654. X{
  655. X    Meaning *mod, *mp;
  656. X    Strlist *sl;
  657. X    int kind;
  658. X    char *cp;
  659. X
  660. X    checkmodulewords();
  661. X    wneedtok(TOK_MODULE);
  662. X    wexpecttok(TOK_IDENT);
  663. X    if (curtokmeaning && curtokmeaning->kind == MK_MODULE && isdefn == 2) {
  664. X    mod = curtokmeaning;
  665. X    import_ctx(mod);
  666. X    for (mp = mod->cbase; mp; mp = mp->cnext)
  667. X        if (mp->kind == MK_FUNCTION)
  668. X        mp->isforward = 1;
  669. X    } else {
  670. X    mod = addmeaning(curtoksym, MK_MODULE);
  671. X    }
  672. X    mod->anyvarflag = 0;
  673. X    pushctx(mod);
  674. X    gettok();
  675. X    skipunitheader();
  676. X    wneedtok(TOK_SEMI);
  677. X    if (ignoreit || 
  678. X        (requested_module && strcicmp(requested_module, mod->name))) {
  679. X        if (!quietmode)
  680. X        if (outf == stdout)
  681. X        fprintf(stderr, "Skipping over module \"%s\"\n", mod->name);
  682. X        else
  683. X        printf("Skipping over module \"%s\"\n", mod->name);
  684. X    checkmodulewords();
  685. X        while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  686. X            p_import(1);
  687. X    checkmodulewords();
  688. X    if (curtok == TOK_EXPORT)
  689. X        gettok();
  690. X        strlist_empty(&curcomments);
  691. X        p_block(TOK_IMPORT);
  692. X        setup_module(mod->sym->name, 0);
  693. X    checkmodulewords();
  694. X        if (curtok == TOK_IMPLEMENT) {
  695. X            skiptomodule();
  696. X        } else {
  697. X            if (!wneedtok(TOK_END))
  698. X        skippasttoken(TOK_END);
  699. X            if (curtok == TOK_SEMI)
  700. X                gettok();
  701. X        }
  702. X        popctx();
  703. X        strlist_empty(&curcomments);
  704. X        return 0;
  705. X    }
  706. X    found_module = 1;
  707. X    if (isdefn != 2) {
  708. X    if (!*hdrfname) {
  709. X        sl = strlist_cifind(includefrom, mod->name);
  710. X        if (sl)
  711. X        cleanheadername(hdrfname, (char *)sl->value);
  712. X        else
  713. X        strcpy(hdrfname, format_ss(headerfnfmt, infname, mod->name));
  714. X    }
  715. X    saveoldfile(hdrfname);
  716. X    hdrf = fopen(hdrfname, "w");
  717. X    if (!hdrf) {
  718. X        perror(hdrfname);
  719. X        error("Could not open output file for header");
  720. X    }
  721. X    outsection(majorspace);
  722. X    if (usevextern && my_strchr(name_GSYMBOL, '%'))
  723. X        output(format_s("#define %s\n", format_s(name_GSYMBOL, mod->sym->name)));
  724. X    out_include(hdrfname, quoteincludes);
  725. X    outsection(majorspace);
  726. X    select_outfile(hdrf);
  727. X    output(format_s("/* Header for module %s, generated by p2c */\n", mod->name));
  728. X    if (*name_HSYMBOL) {
  729. X        cp = format_s(name_HSYMBOL, mod->sym->name);
  730. X        output(format_ss("#ifndef %s\n#define %s\n", cp, cp));
  731. X    }
  732. X    outsection(majorspace);
  733. X    checkmodulewords();
  734. X    while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  735. X        p_import(0);
  736. X    checkmodulewords();
  737. X    if (curtok == TOK_EXPORT)
  738. X        gettok();
  739. X    checkmodulewords();
  740. X    while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  741. X        p_import(0);
  742. X    outsection(majorspace);
  743. X    if (usevextern) {
  744. X        output(format_s("#ifdef %s\n# define vextern\n#else\n",
  745. X                format_s(name_GSYMBOL, mod->sym->name)));
  746. X        output("# define vextern extern\n#endif\n");
  747. X    }
  748. X    checkmodulewords();
  749. X    p_block(TOK_EXPORT);
  750. X    setup_module(mod->sym->name, 1);
  751. X    outsection(majorspace);
  752. X    if (usevextern)
  753. X        output("#undef vextern\n");
  754. X    outsection(minorspace);
  755. X    if (*name_HSYMBOL)
  756. X        output(format_s("#endif /*%s*/\n", format_s(name_HSYMBOL, mod->sym->name)));
  757. X    output("\n/* End. */\n\n");
  758. X    select_outfile(codef);
  759. X    fclose(hdrf);
  760. X    *hdrfname = 0;
  761. X    redeclarevars(mod);
  762. X    declarevars(mod, 0);
  763. X    }
  764. X    checkmodulewords();
  765. X    if (curtok != TOK_END) {
  766. X    if (!modula2 && !implementationmodules)
  767. X        wneedtok(TOK_IMPLEMENT);
  768. X    import_ctx(mod);
  769. X        p_block(TOK_IMPLEMENT);
  770. X    flushcomments(NULL, -1, -1);
  771. X    p_moduleinit(mod);
  772. X        kind = 1;
  773. X    } else {
  774. X        kind = 0;
  775. X        if (!wneedtok(TOK_END))
  776. X        skippasttoken(TOK_END);
  777. X    }
  778. X    if (curtok == TOK_IDENT)
  779. X    gettok();
  780. X    if (curtok == TOK_SEMI)
  781. X        gettok();
  782. X    popctx();
  783. X    return kind;
  784. X}
  785. X
  786. X
  787. X
  788. X
  789. Xint p_search(fname, ext, need)
  790. Xchar *fname, *ext;
  791. Xint need;
  792. X{
  793. X    char infnbuf[300];
  794. X    FILE *fp;
  795. X    Meaning *mod;
  796. X    int savesysprog, savecopysource;
  797. X    int outerimportmark, importmark, mypermflag;
  798. X
  799. X    strcpy(infnbuf, fname);
  800. X    fixfname(infnbuf, ext);
  801. X    fp = fopen(infnbuf, "r");
  802. X    if (!fp) {
  803. X        if (need)
  804. X            perror(infnbuf);
  805. X    if (logf)
  806. X        fprintf(logf, "(Unable to open search file \"%s\")\n", infnbuf);
  807. X        return 0;
  808. X    }
  809. X    flushcomments(NULL, -1, -1);
  810. X    ignore_directives++;
  811. X    savesysprog = sysprog_flag;
  812. X    sysprog_flag |= 3;
  813. X    savecopysource = copysource;
  814. X    copysource = 0;
  815. X    outerimportmark = numimports;   /*obsolete*/
  816. X    importmark = push_imports();
  817. X    clearprogress();
  818. X    push_input_file(fp, infnbuf, 0);
  819. X    do {
  820. X    strlist_empty(&curcomments);
  821. X    checkmodulewords();
  822. X    permflag = 0;
  823. X    if (curtok == TOK_DEFINITION) {
  824. X        gettok();
  825. X        checkmodulewords();
  826. X    } else if (curtok == TOK_IMPLEMENT && modula2) {
  827. X        gettok();
  828. X        checkmodulewords();
  829. X        warning("IMPLEMENTATION module in search text! [275]");
  830. X    }
  831. X        if (!wneedtok(TOK_MODULE))
  832. X        break;
  833. X        if (!wexpecttok(TOK_IDENT))
  834. X        break;
  835. X        mod = addmeaning(curtoksym, MK_MODULE);
  836. X        mod->anyvarflag = 0;
  837. X        if (!quietmode && !showprogress)
  838. X        if (outf == stdout)
  839. X        fprintf(stderr, "Reading import text for \"%s\"\n", mod->name);
  840. X        else
  841. X        printf("Reading import text for \"%s\"\n", mod->name);
  842. X    if (verbose)
  843. X        fprintf(logf, "%s, %d/%d: Reading import text for \"%s\"\n",
  844. X            infname, inf_lnum, outf_lnum, mod->name);
  845. X        pushctx(mod);
  846. X        gettok();
  847. X        skipunitheader();
  848. X        wneedtok(TOK_SEMI);
  849. X    mypermflag = permflag;
  850. X        if (debug>0) printf("Found module %s\n", mod->name);
  851. X    checkmodulewords();
  852. X        while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  853. X            p_import(1);
  854. X    checkmodulewords();
  855. X    if (curtok == TOK_EXPORT)
  856. X        gettok();
  857. X        strlist_empty(&curcomments);
  858. X        p_block(TOK_IMPORT);
  859. X        setup_module(mod->sym->name, 0);
  860. X    if (mypermflag) {
  861. X        strlist_add(&permimports, mod->sym->name)->value = (long)mod;
  862. X        perm_import(mod);
  863. X    }
  864. X    checkmodulewords();
  865. X    if (curtok == TOK_END) {
  866. X        gettok();
  867. X        if (curtok == TOK_SEMI)
  868. X        gettok();
  869. X    } else {
  870. X        wexpecttok(TOK_IMPLEMENT);
  871. X        if (importall) {
  872. X        skiptomodule();
  873. X            }
  874. X        }
  875. X        popctx();
  876. X    } while (curtok == TOK_MODULE);
  877. X    pop_imports(importmark);
  878. X    unimport(outerimportmark);
  879. X    sysprog_flag = savesysprog;
  880. X    copysource = savecopysource;
  881. X    ignore_directives--;
  882. X    pop_input();
  883. X    strlist_empty(&curcomments);
  884. X    clearprogress();
  885. X    return 1;
  886. X}
  887. X
  888. X
  889. X
  890. X
  891. Xvoid p_program()
  892. X{
  893. X    Meaning *prog;
  894. X    Stmt *sp;
  895. X    int nummods, isdefn = 0;
  896. X
  897. X    flushcomments(NULL, -1, -1);
  898. X    output(format_s("\n#include %s\n", p2c_h_name));
  899. X    outsection(majorspace);
  900. X    p_attributes();
  901. X    ignore_attributes();
  902. X    checkmodulewords();
  903. X    if (modula2) {
  904. X    if (curtok == TOK_MODULE) {
  905. X        curtok = TOK_PROGRAM;
  906. X    } else {
  907. X        if (curtok == TOK_DEFINITION) {
  908. X        isdefn = 1;
  909. X        gettok();
  910. X        checkmodulewords();
  911. X        } else if (curtok == TOK_IMPLEMENT) {
  912. X        isdefn = 2;
  913. X        gettok();
  914. X        checkmodulewords();
  915. X        }
  916. X    }
  917. X    }
  918. X    switch (curtok) {
  919. X
  920. X        case TOK_MODULE:
  921. X        if (implementationmodules)
  922. X        isdefn = 2;
  923. X            nummods = 0;
  924. X            while (curtok == TOK_MODULE) {
  925. X                if (p_module(0, isdefn)) {
  926. X                    nummods++;
  927. X                    if (nummods == 2 && !requested_module)
  928. X                        warning("Multiple modules in one source file may not work correctly [276]");
  929. X                }
  930. X            }
  931. X        wneedtok(TOK_DOT);
  932. X            break;
  933. X
  934. X        default:
  935. X            if (curtok == TOK_PROGRAM) {
  936. X                gettok();
  937. X                if (!wexpecttok(TOK_IDENT))
  938. X            skiptotoken(TOK_IDENT);
  939. X                prog = addmeaning(curtoksym, MK_MODULE);
  940. X                gettok();
  941. X                if (curtok == TOK_LPAR) {
  942. X                    while (curtok != TOK_RPAR) {
  943. X                        if (curtok == TOK_IDENT &&
  944. X                            strcicmp(curtokbuf, "INPUT") &&
  945. X                            strcicmp(curtokbuf, "OUTPUT") &&
  946. X                strcicmp(curtokbuf, "KEYBOARD") &&
  947. X                strcicmp(curtokbuf, "LISTING")) {
  948. X                if (literalfilesflag == 2) {
  949. X                strlist_add(&literalfiles, curtokbuf);
  950. X                } else
  951. X                note(format_s("Unexpected name \"%s\" in program header [262]",
  952. X                          curtokcase));
  953. X                        }
  954. X                        gettok();
  955. X                    }
  956. X                    gettok();
  957. X                }
  958. X        if (curtok == TOK_LBR)
  959. X            skipparens();
  960. X                wneedtok(TOK_SEMI);
  961. X            } else {
  962. X                prog = addmeaning(findsymbol("program"), MK_MODULE);
  963. X            }
  964. X            prog->anyvarflag = 1;
  965. X            if (requested_module && strcicmp(requested_module, prog->name) &&
  966. X                                    strcicmp(requested_module, "program")) {
  967. X                for (;;) {
  968. X                    skiptomodule();
  969. X                    if (curtok == TOK_DOT)
  970. X                        break;
  971. X                     (void)p_module(0, 2);
  972. X                }
  973. X        gettok();
  974. X                break;
  975. X            }
  976. X            pushctx(prog);
  977. X            p_block(TOK_PROGRAM);
  978. X            echoprocname(prog);
  979. X        flushcomments(NULL, -1, -1);
  980. X        if (curtok != TOK_EOF) {
  981. X        sp = p_body();
  982. X        strlist_mix(&prog->comments, curcomments);
  983. X        curcomments = NULL;
  984. X        if (fullprototyping > 0) {
  985. X            output(format_s("main(int argc, %s *argv[])", charname));
  986. X        } else {
  987. X            output("main(argc, argv)\n");
  988. X            singleindent(argindent);
  989. X            output("int argc;\n");
  990. X            singleindent(argindent);
  991. X            output(format_s("%s *argv[];\n", charname));
  992. X        }
  993. X        outcontext = prog;
  994. X        out_block(sp, BR_FUNCTION, 10000);
  995. X        free_stmt(sp);
  996. X        popctx();
  997. X        if (curtok == TOK_SEMI)
  998. X            gettok();
  999. X        else 
  1000. X            wneedtok(TOK_DOT);
  1001. X        }
  1002. X            break;
  1003. X
  1004. X    }
  1005. X    if (curtok != TOK_EOF) {
  1006. X        warning("Junk at end of input file ignored [277]");
  1007. X    }
  1008. X}
  1009. X
  1010. X
  1011. X
  1012. X
  1013. X
  1014. X/* End. */
  1015. X
  1016. X
  1017. END_OF_FILE
  1018. if test 25765 -ne `wc -c <'src/parse.c.3'`; then
  1019.     echo shar: \"'src/parse.c.3'\" unpacked with wrong size!
  1020. fi
  1021. # end of 'src/parse.c.3'
  1022. fi
  1023. if test -f 'src/sys.p2crc.2' -a "${1}" != "-c" ; then 
  1024.   echo shar: Will not clobber existing file \"'src/sys.p2crc.2'\"
  1025. else
  1026. echo shar: Extracting \"'src/sys.p2crc.2'\" \(26809 characters\)
  1027. sed "s/^X//" >'src/sys.p2crc.2' <<'END_OF_FILE'
  1028. X                                # %S=name of parent module or procedure.
  1029. X
  1030. XConstFormat                     # Format for #define names derived from
  1031. X                                # Pascal consts.  (Often used: %^s)
  1032. X
  1033. XModuleFormat                    # Format for program and module names.
  1034. X
  1035. XFunctionFormat            # Format for procedure and function names.
  1036. X
  1037. XVarFormat            # Format for variable names.
  1038. X
  1039. XTypeFormat            # Format for typedef names.
  1040. X
  1041. XFieldFormat            # Format for fields of records; %S=record type.
  1042. X
  1043. XEnumFormat            # Format for enumeration constants;
  1044. X                # %s=enum type name.  If not specified,
  1045. X                # default is ConstFormat, else SymbolFormat.
  1046. X
  1047. XReturnValueName   Result        # Return value holding variable; [%s=func name]
  1048. XUnitInitName      _%s_init      # Turbo Pascal unit initializer; %s=unit name
  1049. XHSymbolName       %s_H          # Name of "_H" symbol, if any; %s=unit name
  1050. XGSymbolName       %s_G          # Name of "_G" symbol; [%s=unit name]
  1051. XStringMaxName     MAX_%s        # VAR STRING hidden variable; %s=param name
  1052. XArrayMinName      %s_LOW    # Lower bound hidden variable; %s=param name
  1053. XArrayMaxName      %s_HIGH    # Upper bound hidden variable; %s=param name
  1054. XCopyParName       %s_           # Alternate name for parameter %s
  1055. XStaticLinkName    LINK          # Static link parameter name; [%s=func name]
  1056. XLocalVarsStruct   LOC_%s        # Name of struct type for locals; %s=func name
  1057. XLocalVarsName     V             # Name of struct var for locals; [%s=func name]
  1058. XFwdStructName     %s            # Name of forward-used structs; %s=type name
  1059. X                                # (may simply be %s if you don't mind confusion)
  1060. XEnumListName      %s_NAMES      # Name of array to hold names for enum %s
  1061. XUnionName         UU            # Name of variant union
  1062. XUnionPartName     %s            # Name of variant element; %s=tag value name
  1063. XFakeStructName    _REC_%s    # Name of "temporary" structs; %s=base name
  1064. XLabelName         _L%s          # Name of GOTO label; %s=label name
  1065. XLabelVarName      _JL%s        # Name of GOTO label jmp_buf variable; %s=label
  1066. XTempName          TEMP%s        # Name of general temporary vars; %s=unique id
  1067. XDummyName         DUMMY%s       # Name of throwaway "dummy" vars; %s=unique id
  1068. XWithName          WITH%s        # Name of WITH statement temp ptr; %s=unique id
  1069. XForName           FORLIM%s      # Name of FOR statement temp limit; %s=unique id
  1070. XPtrName           PTR%s         # Name of NIL-checking temp ptr; %s=unique id
  1071. XStringName        STR%s         # Name of temporary string vars; %s=unique id
  1072. XSetName           SET%s         # Name of temporary set vars; %s=unique id
  1073. XFNVarName         %s_NAME       # Name of file-name vars; %s=file var
  1074. XFNSizeName        _FNSIZE       # Maximum length of file name (macro or integer)
  1075. X
  1076. XAlternateName1    %s_           # Way to produce a second C symbol for a Pascal
  1077. X                                # symbol, where original symbol was %s.  Default
  1078. X                                # is to use AlternateName with %d=1.
  1079. X
  1080. XAlternateName2                  # A second alternate for %s.
  1081. X
  1082. XAlternateName                   # A %d'th name for %s.  %s and %d may appear in
  1083. X                                # either order.  Default is %d applications of
  1084. X                                # AlternateName1.
  1085. X
  1086. XExportSymbol                    # Name of exported symbol %s.  E.g.: "P_%s"
  1087. X                                # Default=%s, i.e., don't mess with the name.
  1088. X                                # %s is Pascal symbol name; %S is module name.
  1089. X
  1090. XExport_Symbol                   # Exported-symbol format to be used when the
  1091. X                                # symbol %s contains an '_'.  Default=use
  1092. X                                # ExportSymbol format for every symbol.
  1093. X
  1094. XAlias                           # Name of external proc or var; default="%s".
  1095. X                                # If does not contain a "%s", this simply
  1096. X                                # renames the next defined symbol of any kind.
  1097. X
  1098. XSynonym                # Format:  Synonym name = newname
  1099. XSynonym                # Treat the word "name" in the input file
  1100. XSynonym                # exactly the same as the keyword or identifier
  1101. XSynonym                # "newname".  If "newname" is omitted, ignore
  1102. XSynonym                # the word "name" in the input.  For example:
  1103. XSynonym                # "Synonym andthen = and" creates a keyword;
  1104. XSynonym                # "Synonym allocmem = getmem" simulates a
  1105. XSynonym                # built-in function "allocmem" which acts like
  1106. XSynonym                # Turbo's "getmem"; "Synonym segment" ignores
  1107. XSynonym                # the word "segment" in the input.
  1108. X
  1109. XNameOf                          # Format:  NameOf name = newname
  1110. XNameOf                          # Rename the specified symbol.  The name may
  1111. XNameOf                          # be of the form "modulename.name" or
  1112. XNameOf                          # "procname.name"; otherwise, all usages of
  1113. XNameOf                          # the symbol are renamed.
  1114. X
  1115. XVarMacro                        # Format:  VarMacro varname = C-expression
  1116. XVarMacro                        # Must come before the declaration of variable
  1117. XVarMacro                        # "varname".  Causes all references to the
  1118. XVarMacro                        # variable to use the C expression instead.
  1119. XVarMacro                        # In the expr, all C operators are supported;
  1120. XVarMacro                        # all identifier names are used verbatim.
  1121. XVarMacro                        # Also works for Turbo Pascal typed-constants.
  1122. XVarMacro                        # Suppresses declaration of variable unless
  1123. XVarMacro                        # "varname" appears in the C expression.
  1124. XVarMacro                        # Simple algebra is used for assignments to
  1125. XVarMacro                        # vars with expr definitions: if X -> 2*V+1,
  1126. XVarMacro                        # then "X:=Y" translates to "V=(Y-1)/2".
  1127. X
  1128. XConstMacro                      # Analogous to VarMacro, but for constants and
  1129. XConstMacro                      # enumeration constants.  In an enum constant,
  1130. XConstMacro                      # if the C-expression is a single name the
  1131. XConstMacro                      # result is equivalent to Alias or NameOf.
  1132. X
  1133. XFieldMacro                      # Format:  FieldMacro rec.field = C-expression
  1134. XFieldMacro                      # where "rec" is a record type name which
  1135. XFieldMacro                      # also appears in the C-expression.  For
  1136. XFieldMacro                      # example: FieldMacro obj.foo = bar(obj) causes
  1137. XFieldMacro                      # the field "foo" of record type "obj" to be 
  1138. XFieldMacro                      # referenced through the function or macro
  1139. XFieldMacro                      # "bar", rather than using dot notation.
  1140. X
  1141. XFuncMacro                       # Format:  FuncMacro foo(a,b,c) = C-expression
  1142. XFuncMacro                       # where "a", "b", "c" are arbitrary arg names
  1143. XFuncMacro                       # also appearing in the C-expression.  "Foo"
  1144. XFuncMacro                       # is a procedure or function defined or to be
  1145. XFuncMacro                       # defined in the code, or predefined in Pascal.
  1146. XFuncMacro                       # E.g.: FuncMacro PtInRect(p,r) = PtInRect(p,&r)
  1147. XFuncMacro                       # causes "r" to be treated as a VAR param even
  1148. XFuncMacro                       # though otherwise it would be passed by value.
  1149. X
  1150. XWarnMacros                      # 1=warn if Var/Const/Field/FuncMacro not used
  1151. X                                # 0 or default=don't care.
  1152. X
  1153. XSpecialMalloc                   # Format:  SpecialMalloc x.y.z = funcname
  1154. XSpecialMalloc                   # where x is a type name, and y and z are
  1155. XSpecialMalloc                   # optional variant tags for records.  The
  1156. XSpecialMalloc                   # statement "new(p,y,z)" where p is a pointer
  1157. XSpecialMalloc                   # to x is converted to p = funcname().
  1158. X
  1159. XSpecialFree                     # Like SpecialMalloc, but defines a special
  1160. XSpecialFree                     # function for freeing things of a given type.
  1161. X
  1162. XSpecialSizeOf                   # Like SpecialMalloc, but defines a name or
  1163. XSpecialSizeOf                   # other integer-valued C expression which is
  1164. XSpecialSizeOf                   # the size of an object of the given type.
  1165. X
  1166. XAvoidName         getc          # If any of these names appear in the code,
  1167. XAvoidName         putc          # use an alternate name so as to avoid
  1168. XAvoidName         getchar       # library conflicts.
  1169. XAvoidName         putchar
  1170. XAvoidName         feof          # These are typically macro names whose use
  1171. XAvoidName         ferror        # would be disasterous under any
  1172. XAvoidName         clearerr      # circumstances.
  1173. XAvoidName         fileno
  1174. XAvoidName         BUFSIZ    NULL    EOF
  1175. XAvoidName         stdin     stdout  stderr
  1176. XAvoidName         true false assert
  1177. XAvoidName         Anyptr Void Char PP PV
  1178. XAvoidName         Signed Const Volatile Register Static Local Inline
  1179. XAvoidName         cdecl far near huge
  1180. XAvoidName         isalpha isupper islower isdigit isxdigit isspace ispunct
  1181. XAvoidName         isalnum isprint isgraph iscntrl isascii toascii
  1182. XAvoidName         toupper tolower
  1183. XAvoidName      LINK SEXT
  1184. X
  1185. XAvoidGlobalName   fopen         # These names should be avoided in global
  1186. XAvoidGlobalName   fclose        # contexts, but they are okay as local names.
  1187. XAvoidGlobalName   fseek
  1188. XAvoidGlobalName   exit      main
  1189. XAvoidGlobalName   strcpy    strcat
  1190. XAvoidGlobalName   printf    fprintf sprintf
  1191. XAvoidGlobalName   scanf     fscanf  sscanf
  1192. XAvoidGlobalName   malloc    realloc free
  1193. XAvoidGlobalName   y0 y1 yn j0 j1 jn    # from math.h -- urghhh!
  1194. X                                # ... we should define lots more of these!
  1195. X
  1196. XWarnName                        # A similar list of names to leave alone, but
  1197. XWarnName                        # generate warnings for if they are defined.
  1198. X
  1199. XWarnNames                       # 1=All vars, consts, types, procs, fields
  1200. X                                #   defined after this point should generate
  1201. X                                #   warnings if used.
  1202. X                                # 0 or default=no warnings for future names
  1203. X
  1204. XWarnLibrary                     # A list of C functions, any calls to which
  1205. XWarnLibrary                     # should generate warnings.
  1206. X
  1207. X
  1208. X
  1209. X
  1210. X
  1211. X# TARGET LIBRARY
  1212. X
  1213. XQuoteIncludes                   # 1 or default=write #include "foo.h"
  1214. X                                # 0=write #include <foo.h>
  1215. X
  1216. XIncludeFrom                     # Names of modules which need special
  1217. XIncludeFrom                     # #include file names.  Formats:
  1218. XIncludeFrom                     # IncludeFrom foo bar.h   => #include <bar.h>
  1219. XIncludeFrom                     #   if QuoteIncludes=0 else #include "bar.h"
  1220. XIncludeFrom                     # IncludeFrom foo <bar.h> => #include <bar.h>
  1221. XIncludeFrom                     # IncludeFrom foo "bar.h" => #include "bar.h"
  1222. XIncludeFrom                     # IncludeFrom foo         => no #include at all
  1223. XIncludeFrom iodeclarations <p2c/iodecl.h>
  1224. XIncludeFrom system
  1225. XIncludeFrom printer
  1226. XIncludeFrom dos
  1227. XIncludeFrom crt
  1228. X
  1229. XImportFrom                      # Names of modules whose import text
  1230. XImportFrom                      # resides in the specified files.
  1231. XImportFrom                      # E.g.: ImportFrom  mymod  /usr/me/mymod.imp
  1232. XImportFrom                      # These are the Turbo Pascal standard units
  1233. XImportFrom  system         %H/turbo.imp
  1234. XImportFrom  printer       %H/turbo.imp
  1235. XImportFrom  dos           %H/turbo.imp
  1236. XImportFrom  crt           %H/turbo.imp
  1237. XImportFrom  graph          %H/turbo.imp
  1238. X
  1239. XImportDir   %_s.pas             # Search list of other places to look for
  1240. XImportDir   %_s.text            # the module named %s.
  1241. XImportDir   %H/%_s.imp
  1242. X
  1243. XIncludeDir  %_s                 # Search list of places to look for the
  1244. XIncludeDir  %_s.pas             # Pascal include file %s.
  1245. XIncludeDir  %_s.text
  1246. XIncludeDir  %H/%_s.pas
  1247. X
  1248. XLibraryFile %H/system.imp       # Names of import-text files to search
  1249. XLibraryFile                     # always (as if "-s name" were used).
  1250. X
  1251. XStructFunction    sprintf       # Names of "structured functions".
  1252. XStructFunction    memcpy  memmove
  1253. XStructFunction    strcpy    strsub   strrtrim    strrpt
  1254. XStructFunction    P_addset  P_addsetr  P_remset
  1255. X
  1256. XStrlapFunction    P_setunion    # Names of "structured functions" which
  1257. XStrlapFunction    P_setint      # allow duplication of their arguments.
  1258. XStrlapFunction    P_setdiff
  1259. XStrlapFunction      P_setxor
  1260. XStrlapFunction    P_expset    strlower   strupper   strpad
  1261. X
  1262. XNoSideEffects     strcmp memcmp # Names of functions which have absolutely
  1263. XNoSideEffects                   # no side effects on their arguments or
  1264. XNoSideEffects                   # other global state of the program.
  1265. X
  1266. XDeterministic     abs sin cos   # Names of functions which satisfy all
  1267. XDeterministic                   # requirements for NoSideEffects, and
  1268. XDeterministic                   # additionally compute their result
  1269. XDeterministic                   # deterministically (and quickly), without
  1270. XDeterministic                   # any sort of hidden dependencies.
  1271. X                                # (need many more in this list!)
  1272. X
  1273. XLeaveAlone                      # Names of library functions which should
  1274. XLeaveAlone                      # be left alone, rather than translated
  1275. XLeaveAlone                      # into C equivalents.  (For example, prevents
  1276. XLeaveAlone                      # converting fwritebytes into C fwrite.)
  1277. X
  1278. XHeaderName        <p2c/p2c.h>   # Name of standard p2c header file
  1279. X
  1280. XUCharName         uchar         # Name of a typedef for "unsigned char";
  1281. X                                # default="char" or "unsigned char".
  1282. X
  1283. XSCharName         schar         # Name of a typedef for "signed char";
  1284. X                                # default="char" or "signed char".
  1285. X
  1286. XBooleanName       boolean       # Name of a typedef for booleans; default=char.
  1287. X
  1288. XTrueName          true          # Name of a boolean "true" constant (optional)
  1289. XFalseName         false         # Name of a boolean "false" constant (opt.)
  1290. X
  1291. XNullName          NULL          # Name of a NULL pointer constant
  1292. X
  1293. XProcTypeName      _PROCEDURE    # Name of procedure-pointer typedef
  1294. X
  1295. XEscapeCodeName    P_escapecode  # Names of error-handling variables
  1296. XIOResultName      P_ioresult
  1297. X
  1298. XArgCName          P_argc        # Name of global copy of argc
  1299. XArgVName          P_argv        # Name of global copy of argv
  1300. X
  1301. XMainName          PASCAL_MAIN   # Name of program setup function
  1302. X
  1303. XEscapeName        _Escape       # Name of error-generation function
  1304. X
  1305. XEscIOName         _EscIO        # Name of I/O-error-generation function
  1306. X
  1307. XCheckIOName       _CHKIO        # Name of I/O-error-checking function
  1308. X
  1309. XSetIOName         _SETIO        # Name of I/O-error-setting function
  1310. X
  1311. XFileNotFoundName  FileNotFound  # Name or number of "File Not Found" ioresult
  1312. X
  1313. XFileNotOpenName   FileNotOpen   # Name or number of "File Not Open" ioresult
  1314. X
  1315. XFileWriteErrorName FileWriteError # Name of num of "File Write Error" ioresult
  1316. X
  1317. XBadInputFormatName BadInputFormat # Name or num of "Bad Input Format" ioresult
  1318. X
  1319. XEndOfFileName     EndOfFile     # Name or number of "End of File" ioresult
  1320. X
  1321. XOutMemName        _OutMem       # Name of out-of-memory error function
  1322. X
  1323. XCaseCheckName      _CaseCheck    # Name of case-out-of-range error function
  1324. X
  1325. XNilCheckName      _NilCheck    # Name of nil-pointer error function
  1326. X
  1327. XSetBitsName                     # Name of macro defined equal to SetBits
  1328. X                                # default=compile SetBits in-line
  1329. X
  1330. XSprintfValue                    # 1=sprintf() returns its first argument
  1331. X                                # 0=sprintf() returns a character count
  1332. X                                # default=don't know (unless AnsiC=1)
  1333. X                                # -2=don't know regardless of AnsiC
  1334. X                                # 2=don't use sprintf in expressions
  1335. X
  1336. XSprintfName                     # If SprintfValue != 1, this is the name
  1337. X                                # of a sprintf-like function which returns
  1338. X                                # its first argument.  Default=no such
  1339. X                                # function exists.
  1340. X
  1341. XMemCpyName                      # Methods known: "memcpy", "bcopy"
  1342. X                                # default=according to Target, default "memcpy"
  1343. X
  1344. XRoundName                       # Name of function or macro for rounding
  1345. X                                # a real to an integer.  Precede name with
  1346. X                                # a '*' if it is a macro that evaluates its
  1347. X                                # arguments more than once.  Default=do it
  1348. X                                # by hand.
  1349. X
  1350. XDivName                # Name of function or macro for Pascal integer
  1351. X                # division where numerator may be negative.
  1352. X                # Use '*' if macro; default=use regular '/'.
  1353. X
  1354. XModName                # Name of function or macro for Pascal integer
  1355. X                # modulo where numerator may be negative.
  1356. X                # Use '*' if macro; default=use regular '%'.
  1357. X
  1358. XRemName                # Name of function or macro for VAX Pascal
  1359. X                # REM where numerator or denominator may be
  1360. X                # negative.  Use '*' if macro; default=use MOD.
  1361. X
  1362. XAbsName           labs          # Name of function for computing ABS of a
  1363. X                                # "long" value.  Precede with '*' if a
  1364. X                                # macro.  Default=by hand, or "labs" in AnsiC.
  1365. X
  1366. XOddName                         # Name of a macro for computing ODD of an
  1367. X                                # integer.  Default=x&1.
  1368. X
  1369. XEvenName                        # Name of a macro for computing NOT ODD of
  1370. X                                # an integer.  Default=!odd(x).
  1371. X
  1372. XSwapName          _swap         # Name of Turbo-like swap() function.
  1373. X
  1374. XStrCpyLeft                      # 1 or default=strcpy(s1,s2) works even if
  1375. X                                # s1 and s2 overlap, provided s1 <= s2.
  1376. X                                # 0=strcpy(s1,s2) does not allow overlap.
  1377. X
  1378. XStrCICmpName      strcicmp      # Name of a strcicmp-like function; no default
  1379. XStrSubName        strsub        # Name of a strsub-like function; no default
  1380. XStrPosName        strpos2       # Name of a strpos2-like function; no default
  1381. XStrDeleteName     strdelete     # Name of a strdelete-like function; no default
  1382. XStrInsertName     strinsert     # Name of a strinsert-like function; no default
  1383. XStrMoveName      strmove    # Name of a strmove-like function; no default
  1384. XStrLTrimName      strltrim      # Name of a strltrim-like function; no default
  1385. XStrRTrimName      strrtrim      # Name of a strrtrim-like function; no default
  1386. XStrRptName        strrpt        # Name of a strrpt-like function; no default
  1387. XStrPadName        strpad        # Name of a pad-like function; no default
  1388. X
  1389. XMallocName        Malloc        # Name of a malloc-like function; default=malloc
  1390. XFreeName          Free          # Name of a dispose-like function; default=free
  1391. XFreeRvalueName    FreeR         # Name of a free-like function; default=free
  1392. X
  1393. XRandRealName      _randreal     # Name of a Turbo "random" function; no default
  1394. XRandIntName       _randint      # Name of a Turbo "random()" function; no def
  1395. XRandomizeName     _randomize    # Name of a Turbo "randomize" procedure
  1396. X
  1397. XSkipSpaceName     _skipspaces   # Name of a Turbo seekeof/seekeoln skipper
  1398. X
  1399. XReadlnName                      # Name of function or macro to skip past eoln.
  1400. X                                # Special names: fgets=use fgets with dummy var
  1401. X                                #                scanf=use scanf/fscanf
  1402. X                                # Default=use whichever method works out best
  1403. X
  1404. XFreopenName                     # Name of function or macro that acts like
  1405. X                                # freopen(n,m,f), but if f==NULL acts like
  1406. X                                # fopen(n,m).  Default=do it by hand.
  1407. X                                # "fopen"=assume not reopening files.
  1408. X                                # "fclose"=fclose first, then fopen.
  1409. X
  1410. XEofName           P_eof         # Name of "feof" with Pascal semantics.
  1411. XEolnName          P_eoln        # Name of "eoln" function.
  1412. XFilePosName       ftell         # Name of "filepos" function.
  1413. XMaxPosName        P_maxpos      # Name of "maxpos" function.
  1414. X
  1415. XSetUnionName      P_setunion    # Name of a set "+" function; no default
  1416. XSetIntName        P_setint      # Name of a set "*" function; no default
  1417. XSetDiffName       P_setdiff     # Name of a set "-" function; no default
  1418. XSetXorName        P_setxor      # Name of a set "/" function; no default
  1419. XSetInName         P_inset       # Name of a set "IN" function; no default
  1420. XSetAddName        P_addset      # Name of a set "a:=a+[x]" function; no default
  1421. XSetAddRangeName   P_addsetr     # Name of a set "a:=a+[x..y]" function; no def
  1422. XSetRemName        P_remset      # Name of a set "a:=a-[x]" function; no default
  1423. XSetEqualName      P_setequal    # Name of a set "=" function; no default
  1424. XSubSetName        P_subset      # Name of a set "<=" function; no default
  1425. XSetCopyName       P_setcpy      # Name of a set ":=" function; no default
  1426. XSetExpandName     P_expset      # Name of small-set-to-set expander; no default
  1427. XSetPackName       P_packset     # Name of set-to-small-set packer; no default
  1428. X
  1429. XSignExtendName    SEXT          # Name of macro to sign-extend a number.
  1430. X
  1431. XGetBitsName       *P_getbits_%s # Name of family of array-unpacking functions.
  1432. X                                # Precede name with '*' if a macro.  %s will
  1433. X                                # expand to S (for signed) or U (for unsigned),
  1434. X                                # followed by B (big array) or S (small array).
  1435. X
  1436. XPutBitsName       *P_putbits_%s # Name of family of functions which 'OR' a
  1437. X                                # value into an element of a packed array.
  1438. X                                # %s expands to S or U, followed by B or S.
  1439. X                                # Use '*' if macro.  Default=use StoreBits.
  1440. X
  1441. XClrBitsName       *P_clrbits_%s # Name of family of functions which zero an
  1442. X                                # element of a packed array.  %s expands
  1443. X                                # to B or S only.  Use '*' if macro.
  1444. X                                # Default=use StoreBits.
  1445. X
  1446. XStoreBitsName                   # Name of a family of functions or macros
  1447. X                                # which act just like PutBits, but overwrite
  1448. X                                # the array element rather than OR'ing.
  1449. X                                # Default=use ClrBits followed by PutBits.
  1450. X                                # At least StoreBits or both PutBits and
  1451. X                                # ClrBits must be defined.
  1452. X
  1453. XDeclBufName        FILEBUF      # Name of a macro for declaring the file
  1454. X                # buffer for a file using GET and PUT.
  1455. X
  1456. XDeclBufNCName                   # Name of a DeclBufName-like macro with two
  1457. X                                # arguments (no storage class), in case your
  1458. X                # compiler can't handle null macro arguments.
  1459. X
  1460. XBufferedFile            # Names of file variables that use GET/PUT/^
  1461. XBufferedFile            # notation instead of READ/WRITE notation.
  1462. XBufferedFile            # Mostly useful for globals; locals are
  1463. XBufferedFile            # detected automatically.  May be a var name,
  1464. XBufferedFile            # field name, proc.var, type.field, or
  1465. XBufferedFile            # "1"=use buffers for all files.
  1466. X
  1467. XUnBufferedFile            # Names of files that will not be buffered,
  1468. XUnBufferedFile            # even if they would otherwise be.  Syntax
  1469. XUnBufferedFile            # same as for BufferedFile.
  1470. X
  1471. XResetBufName       RESETBUF     # Name of a macro for setting up a file
  1472. X                # buffer in "read" mode.  (For RESET.)
  1473. X
  1474. XSetupBufName       SETUPBUF    # Name of a macro for setting up a file
  1475. X                # buffer in read/write mode.  (For OPEN, SEEK.)
  1476. X
  1477. XGetFBufName        GETFBUF      # Name of a macro for accessing a file
  1478. X                                # buffer using "file^" notation.
  1479. X
  1480. XGetName            GET          # Name of a macro for advancing
  1481. X                                # to the next element of an input file.
  1482. X
  1483. XPutFBufName        PUTFBUF      # Name of a macro for storing an element
  1484. X                                # of a file using "file^" notation.
  1485. X
  1486. XPutName            PUT          # Name of a macro for advancing
  1487. X                                # to the next element of an output file.
  1488. X
  1489. XCharGetFBufName    P_peek       # A special GetFBuf for text and files of char.
  1490. X
  1491. XCharGetName        getc         # A special Get for text and files of char.
  1492. X
  1493. XCharPutFBufName    CPUTFBUF     # A special PutFBuf for text and files of char.
  1494. X
  1495. XCharPutName        CPUT         # A special Put for text and files of char.
  1496. X
  1497. XArrayGetFBufName   AGETFBUF    # A special GetFBuf for files of arrays.
  1498. X
  1499. XArrayGetName            # A special Get for files of arrays.
  1500. X
  1501. XArrayPutFBufName   APUTFBUF    # A special PutFBuf for files of arrays.
  1502. X
  1503. XArrayPutName            # A special Put for files of arrays.
  1504. X
  1505. X
  1506. X
  1507. X# CHECKING
  1508. X
  1509. XCaseCheck                       # 1=check CASE statements without OTHERWISE
  1510. X                                # 0 or default=skip CASE stmt if out of range
  1511. X                                # 2=according to $range$ directives
  1512. X
  1513. XArrayCheck                      # 1=check array bounds
  1514. X                                # 0 or default=do not check array bounds
  1515. X                                # 2=according to $range$ directives
  1516. X                                #   (not yet implemented)
  1517. X
  1518. XNilCheck                        # check pointer dereferences (0, 1, or 2)
  1519. X
  1520. XRangeCheck                      # enable other range checking (0, 1, or 2):
  1521. X                                #   string indexing, ...?
  1522. X                                #   (not yet implemented)
  1523. X
  1524. XMallocCheck                     # 1=check if malloc returns NULL
  1525. X                                # 0 or default=assume malloc never returns NULL
  1526. X                                # (often used with MallocName; see above)
  1527. X
  1528. XCheckFileOpen                   # 1 or default=check for errors during open,
  1529. X                                # 0=assume file opens successfully
  1530. X                # 2=check only when $iocheck off$ or {$I-}
  1531. X
  1532. XCheckFileIsOpen                 # 1=check for "file not open" error,
  1533. X                                # 0 or default=eof, etc., assume file is open
  1534. X                # 2=check only when $iocheck off$ or {$I-}
  1535. X
  1536. XCheckFileWrite                  # 1=check for errors during write
  1537. X                                # 0=ignore write errors
  1538. X                # 2 or default=only when $iocheck off$ or {$I-}
  1539. X
  1540. XCheckReadFormat                 # 1=check for "bad format" errors during read
  1541. X                                # 0=ignore read format errors
  1542. X                # 2 or default=only when $iocheck off$ or {$I-}
  1543. X
  1544. XCheckFileEOF                    # 1=check for "past EOF" errors reading files
  1545. X                                # 0=ignore file EOF errors
  1546. X                # 2 or default=only when $iocheck off$ or {$I-}
  1547. X
  1548. XCheckStdinEOF                   # 1=check for "past EOF" errors reading stdin
  1549. X                                # 0=ignore stdin EOF errors
  1550. X                # 2 or default=only when $iocheck off$ or {$I-}
  1551. X
  1552. XCheckFileSeek                   # 1=check for errors during seek
  1553. X                                # 0=ignore seek errors
  1554. X                # 2 or default=only when $iocheck off$ or {$I-}
  1555. X
  1556. X
  1557. X
  1558. X
  1559. XInclude %H/loc.p2crc        # Include any local modifications to this file.
  1560. X
  1561. X
  1562. X
  1563. X# End of p2crc
  1564. END_OF_FILE
  1565. if test 26809 -ne `wc -c <'src/sys.p2crc.2'`; then
  1566.     echo shar: \"'src/sys.p2crc.2'\" unpacked with wrong size!
  1567. fi
  1568. # end of 'src/sys.p2crc.2'
  1569. fi
  1570. echo shar: End of archive 8 \(of 32\).
  1571. cp /dev/null ark8isdone
  1572. MISSING=""
  1573. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 ; do
  1574.     if test ! -f ark${I}isdone ; then
  1575.     MISSING="${MISSING} ${I}"
  1576.     fi
  1577. done
  1578. if test "${MISSING}" = "" ; then
  1579.     echo You have unpacked all 32 archives.
  1580.     echo "Now see PACKNOTES and the README"
  1581.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1582. else
  1583.     echo You still need to unpack the following archives:
  1584.     echo "        " ${MISSING}
  1585. fi
  1586. ##  End of shell archive.
  1587. exit 0
  1588.