开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
parse.c.3
资源名称：pascal2c.tar.Z　[点击查看]
上传用户：upcnvip
上传日期：2007-01-06
资源大小：474k
文件大小：25k
源码类别：

编译器/解释器

开发平台：

C/C++

parse.c.3：源码内容
  1. mp->isreturn) {    /* the was-#defined flag */
  2. if (!anywords)
  3.     outsection(minorspace);
  4. anywords++;
  5. output(format_s("#undef %sn", mp->name));
  6. sym = findsymbol(mp->name);
  7. sym->flags &= ~AVOIDNAME;
  8.     }
  9. }
  10.     }
  11.     if (conserve_mem) {
  12. free_stmt((Stmt *)func->val.i);   /* is this safe? */
  13. func->val.i = 0;
  14. forget_ctx(func, 0);
  15.     }
  16.     outsection(spacing);
  17. }
  22. void movetoend(mp)
  23. Meaning *mp;
  24. {
  25.     Meaning **mpp;
  27.     if (mp->ctx != curctx) {
  28.         intwarning("movetoend", "curctx is wrong [268]");
  29.     } else {
  30.         mpp = &mp->ctx->cbase;     /* move a meaning to end of its parent context */
  31.         while (*mpp != mp) {
  32.     if (!*mpp) {
  33. intwarning("movetoend", "meaning not on its context list [269]");
  34. return;
  35.     }
  36.             mpp = &(*mpp)->cnext;
  37. }
  38.         *mpp = mp->cnext;    /* Remove from present position in list */
  39.         while (*mpp)
  40.             mpp = &(*mpp)->cnext;
  41.         *mpp = mp;           /* Insert at end of list */
  42.         mp->cnext = NULL;
  43.         curctxlast = mp;
  44.     }
  45. }
  49. Static void scanfwdparams(mp)
  50. Meaning *mp;
  51. {
  52.     Symbol *sym;
  54.     mp = mp->type->fbase;
  55.     while (mp) {
  56. sym = findsymbol(mp->name);
  57. sym->flags |= FWDPARAM;
  58. mp = mp->xnext;
  59.     }
  60. }
  64. Static void p_function(isfunc)
  65. int isfunc;
  66. {
  67.     Meaning *func;
  68.     Type *type;
  69.     Stmt *sp;
  70.     Strlist *sl, *comments, *savecmt;
  71.     int initializeattr = 0, isinline = 0;
  73.     if ((sl = strlist_find(attrlist, "INITIALIZE")) != NULL) {
  74. initializeattr = 1;
  75. strlist_delete(&attrlist, sl);
  76.     }
  77.     if ((sl = strlist_find(attrlist, "OPTIMIZE")) != NULL &&
  78. sl->value != -1 &&
  79. !strcmp((char *)(sl->value), "INLINE")) {
  80. isinline = 1;
  81. strlist_delete(&attrlist, sl);
  82.     }
  83.     ignore_attributes();
  84.     comments = extractcomment(&curcomments, -1, curserial);
  85.     changecomments(comments, -1, -1, -1, 0);
  86.     if (curctx->kind == MK_FUNCTION) {    /* sub-procedure */
  87. savecmt = curcomments;
  88.     } else {
  89. savecmt = NULL;
  90. flushcomments(&curcomments, -1, -1);
  91.     }
  92.     curcomments = comments;
  93.     curserial = serialcount = 1;
  94.     gettok();
  95.     if (!wexpecttok(TOK_IDENT))
  96. skiptotoken(TOK_IDENT);
  97.     if (curtokmeaning && curtokmeaning->ctx == curctx &&
  98.         curtokmeaning->kind == MK_FUNCTION) {
  99.         func = curtokmeaning;
  100.         if (!func->isforward || func->val.i)
  101.             warning(format_s("Redeclaration of function %s [270]", func->name));
  102. skiptotoken(TOK_SEMI);
  103.         movetoend(func);
  104.         pushctx(func);
  105.         type = func->type;
  106.     } else {
  107.         func = addmeaning(curtoksym, MK_FUNCTION);
  108.         gettok();
  109.         func->val.i = 0;
  110.         pushctx(func);
  111.         func->type = type = p_funcdecl(&isfunc, 0);
  112.         func->isfunction = isfunc;
  113. func->namedfile = isinline;
  114.         type->meaning = func;
  115.     }
  116.     wneedtok(TOK_SEMI);
  117.     if (initializeattr) {
  118. sl = strlist_append(&initialcalls, format_s("%s()", func->name));
  119. sl->value = 1;
  120.     }
  121.     if (curtok == TOK_IDENT && !strcmp(curtokbuf, "C")) {
  122. gettok();
  123. wneedtok(TOK_SEMI);
  124.     }
  125.     if (blockkind == TOK_IMPORT) {
  126. strlist_empty(&curcomments);
  127. if (curtok == TOK_IDENT &&
  128.     (!strcicmp(curtokbuf, "FORWARD") ||
  129.      strlist_cifind(externwords, curtokbuf))) {
  130.     gettok();
  131.     while (curtok == TOK_IDENT)
  132. gettok();
  133.     wneedtok(TOK_SEMI);
  134. }
  135.         /* do nothing more */
  136.     } else if (blockkind == TOK_EXPORT) {
  137.         func->isforward = 1;
  138. scanfwdparams(func);
  139. flushcomments(NULL, -1, -1);
  140.         forward_decl(func, 1);
  141.     } else {
  142. checkkeyword(TOK_INTERRUPT);
  143. checkkeyword(TOK_INLINE);
  144.         if (curtok == TOK_INTERRUPT) {
  145.             note("Ignoring INTERRUPT keyword [258]");
  146.             gettok();
  147.             wneedtok(TOK_SEMI);
  148.         }
  149.         if (curtok == TOK_IDENT && !strcicmp(curtokbuf, "FORWARD")) {
  150.             func->isforward = 1;
  151.     scanfwdparams(func);
  152.             gettok();
  153.             if (func->ctx->kind != MK_FUNCTION) {
  154.                 outsection(minorspace);
  155. flushcomments(NULL, -1, -1);
  156.                 forward_decl(func, 0);
  157.                 outsection(minorspace);
  158.             }
  159.         } else if (curtok == TOK_IDENT &&
  160.    (strlist_cifind(externwords, curtokbuf) ||
  161.     strlist_cifind(cexternwords, curtokbuf))) {
  162.             if (*externalias && my_strchr(externalias, '%')) {
  163.                 strchange(&func->name, format_s(externalias, func->name));
  164.             } else if (strlist_cifind(cexternwords, curtokbuf)) {
  165. if (func->name[0] == '_')
  166.     strchange(&func->name, func->name + 1);
  167. if (func->name[strlen(func->name)-1] == '_')
  168.     func->name[strlen(func->name)-1] = 0;
  169.     }
  170.     func->isforward = 1;    /* for Oregon Software Pascal-2 */
  171.     func->exported = 1;
  172.             gettok();
  173.     while (curtok == TOK_IDENT)
  174. gettok();
  175.             outsection(minorspace);
  176.     flushcomments(NULL, -1, -1);
  177.     scanfwdparams(func);
  178.             forward_decl(func, 1);
  179.             outsection(minorspace);
  180. } else if (curtok == TOK_IDENT) {
  181.     wexpecttok(TOK_BEGIN);   /* print warning */
  182.     gettok();
  183.             outsection(minorspace);
  184.     flushcomments(NULL, -1, -1);
  185.     scanfwdparams(func);
  186.             forward_decl(func, 1);
  187.             outsection(minorspace);
  188.         } else {
  189.             if (func->ctx->kind == MK_FUNCTION)
  190.                 func->ctx->needvarstruct = 1;
  191.     func->comments = curcomments;
  192.     curcomments = NULL;
  193.             p_block(TOK_FUNCTION);
  194.             echoprocname(func);
  195.     changecomments(curcomments, -1, curserial, -1, 10000);
  196.             sp = p_body();
  197.             func->ctx->needvarstruct = 0;
  198.             func->val.i = (long)sp;
  199.     strlist_mix(&func->comments, curcomments);
  200.     curcomments = NULL;
  201.             if (func->ctx->kind != MK_FUNCTION || !collectnest) {
  202.                 out_function(func);    /* output top-level procedures immediately */
  203.             }                          /*  (sub-procedures are output later) */
  204.         }
  205.         if (!wneedtok(TOK_SEMI))
  206.     skippasttoken(TOK_SEMI);
  207.     }
  208.     strlist_mix(&curcomments, savecmt);
  209.     popctx();
  210. }
  214. Static void out_include(name, quoted)
  215. char *name;
  216. int quoted;
  217. {
  218.     if (quoted)
  219.         output(format_s("#include "%s"n", name));
  220.     else
  221.         output(format_s("#include <%s>n", name));
  222. }
  225. Static void cleanheadername(dest, name)
  226. char *dest, *name;
  227. {
  228.     char *cp;
  229.     int len;
  231.     if (*name == '<' || *name == '"')
  232. name++;
  233.     cp = my_strrchr(name, '/');
  234.     if (cp)
  235. cp++;
  236.     else
  237. cp = name;
  238.     strcpy(dest, cp);
  239.     len = strlen(dest);
  240.     if (dest[len-1] == '>' || dest[len-1] == '"')
  241. dest[len-1] = 0;
  242. }
  247. Static int tryimport(sym, fname, ext, need)
  248. Symbol *sym;
  249. char *fname, *ext;
  250. int need;
  251. {
  252.     int found = 0;
  253.     Meaning *savectx, *savectxlast;
  255.     savectx = curctx;
  256.     savectxlast = curctxlast;
  257.     curctx = nullctx;
  258.     curctxlast = curctx->cbase;
  259.     while (curctxlast && curctxlast->cnext)
  260.         curctxlast = curctxlast->cnext;
  261.     if (p_search(fname, ext, need)) {
  262.         curtokmeaning = sym->mbase;
  263.         while (curtokmeaning && !curtokmeaning->isactive)
  264.             curtokmeaning = curtokmeaning->snext;
  265.         if (curtokmeaning)
  266.             found = 1;
  267.     }
  268.     curctx = savectx;
  269.     curctxlast = savectxlast;
  270.     return found;
  271. }
  275. Static void p_import(inheader)
  276. int inheader;
  277. {
  278.     Strlist *sl;
  279.     Symbol *sym;
  280.     char *name;
  281.     int found, isfrom = (curtok == TOK_FROM);
  283.     outsection(minorspace);
  284.     do {
  285.         gettok();
  286.         if (!wexpecttok(TOK_IDENT)) {
  287.     skiptotoken(TOK_SEMI);
  288.     break;
  289. }
  290.         sym = curtoksym;
  291.         if (curtokmeaning && curtokmeaning->kind == MK_MODULE) {
  292.             found = 1;
  293. } else if (strlist_cifind(permimports, sym->name)) {
  294.             found = 2;   /* built-in module, there already! */
  295.         } else {
  296.             found = 0;
  297.             sl = strlist_cifind(importfrom, sym->name);
  298.             name = (sl) ? format_none((char *)sl->value) : NULL;
  299.             if (name) {
  300.                 if (tryimport(sym, name, "pas", 1))
  301.                     found = 1;
  302.             } else {
  303.                 for (sl = importdirs; sl && !found; sl = sl->next) {
  304.                     if (tryimport(sym, format_s(sl->s, curtokcase), NULL, 0))
  305.                         found = 1;
  306.                 }
  307.             }
  308.         }
  309.         if (found == 1) {
  310.             if (!inheader) {
  311.                 sl = strlist_cifind(includefrom, curtokmeaning->name);
  312.                 name = (sl) ? (char *)sl->value :
  313.     format_ss(*headerfnfmt2 ? headerfnfmt2 : headerfnfmt,
  314.       infname, curtokmeaning->name);
  315.                 if (name && !strlist_find(includedfiles, name)) {
  316.                     strlist_insert(&includedfiles, name);
  317.                     if (*name_HSYMBOL)
  318.                         output(format_s("#ifndef %sn", format_s(name_HSYMBOL, sym->name)));
  319.                     if (*name == '"' || *name == '<')
  320.                         output(format_s("#include %sn", name));
  321.                     else
  322.                         out_include(name, quoteincludes);
  323.                     if (*name_HSYMBOL)
  324.                         output("#endifn");
  325.                     outsection(minorspace);
  326.                 }
  327.             }
  328.             import_ctx(curtokmeaning);
  329. } else if (curtokmeaning) {
  330.     /* Modula-2, importing a single ident */
  331.     /* Ignored for now, since we always import whole modules */
  332.         } else if (found == 0) {
  333.             warning(format_s("Could not find module %s [271]", sym->name));
  334.             if (!inheader) {
  335.                 out_include(format_ss(*headerfnfmt2?headerfnfmt2:headerfnfmt,
  336.       sym->name, sym->name),
  337.     quoteincludes);
  338.             }
  339.         }
  340.         gettok();
  341.     } while (curtok == TOK_COMMA);
  342.     if (isfrom) {
  343. checkkeyword(TOK_IMPORT);
  344. if (wneedtok(TOK_IMPORT)) {
  345.     do {
  346. gettok();
  347. if (curtok == TOK_IDENT)
  348.     gettok();
  349.     } while (curtok == TOK_COMMA);
  350. }
  351.     }
  352.     if (!wneedtok(TOK_SEMI))
  353. skippasttoken(TOK_SEMI);
  354.     outsection(minorspace);
  355. }
  360. void do_include(blkind)
  361. Token blkind;
  362. {
  363.     FILE *oldfile = outf;
  364.     int savelnum = outf_lnum;
  365.     char fname[256];
  367.     outsection(majorspace);
  368.     strcpy(fname, curtokbuf);
  369.     removesuffix(fname);
  370.     strcat(fname, ".c");
  371.     if (!strcmp(fname, codefname)) {
  372.         warning("Include file name conflict! [272]");
  373.         badinclude();
  374.         return;
  375.     }
  376.     saveoldfile(fname);
  377.     outf = fopen(fname, "w");
  378.     if (!outf) {
  379.         outf = oldfile;
  380.         perror(fname);
  381.         badinclude();
  382.         return;
  383.     }
  384.     outf_lnum = 1;
  385.     output(format_ss("n/* Include file %s from %s */nn", fname, codefname));
  386.     if (blkind == TOK_END)
  387.         gettok();
  388.     else
  389.         curtok = blkind;
  390.     p_block(blockkind);
  391.     output("nn/* End. */nn");
  392.     fclose(outf);
  393.     outf = oldfile;
  394.     outf_lnum = savelnum;
  395.     if (curtok != TOK_EOF) {
  396.         warning("Junk at end of include file ignored [273]");
  397.     }
  398.     outsection(majorspace);
  399.     if (*includefnfmt)
  400. out_include(format_s(includefnfmt, fname), 1);
  401.     else
  402. out_include(fname, 1);
  403.     outsection(majorspace);
  404.     pop_input();
  405.     getline();
  406.     gettok();
  407. }
  412. /* blockkind is one of:
  413.        TOK_PROGRAM:     Global declarations of a program
  414.        TOK_FUNCTION:    Declarations local to a procedure or function
  415.        TOK_IMPORT:      Import text read from a module
  416.        TOK_EXPORT:      Export section of a module
  417.        TOK_IMPLEMENT:   Implementation section of a module
  418.        TOK_END:         None of the above
  419. */
  421. void p_block(blkind)
  422. Token blkind;
  423. {
  424.     Token saveblockkind = blockkind;
  425.     Token lastblockkind = TOK_END;
  427.     blockkind = blkind;
  428.     for (;;) {
  429. while (curtok == TOK_INTFONLY) {
  430.     include_as_import();
  431.     gettok();
  432. }
  433.         if (curtok == TOK_CONST || curtok == TOK_TYPE ||
  434.     curtok == TOK_VAR || curtok == TOK_VALUE) {
  435.             while (curtok == TOK_CONST || curtok == TOK_TYPE ||
  436.    curtok == TOK_VAR || curtok == TOK_VALUE) {
  437.                 lastblockkind = curtok;
  438.                 switch (curtok) {
  440.                     case TOK_CONST:
  441.                         p_constdecl();
  442.                         break;
  444.                     case TOK_TYPE:
  445.                         p_typedecl();
  446.                         break;
  448.                     case TOK_VAR:
  449.                         p_vardecl();
  450.                         break;
  452.     case TOK_VALUE:
  453. p_valuedecl();
  454. break;
  456.     default:
  457. break;
  458.                 }
  459.             }
  460.             if ((blkind == TOK_PROGRAM ||
  461.                  blkind == TOK_EXPORT ||
  462.                  blkind == TOK_IMPLEMENT) &&
  463.                 (curtok != TOK_BEGIN || !mainlocals)) {
  464.                 outsection(majorspace);
  465.                 if (declarevars(curctx, 0))
  466.                     outsection(majorspace);
  467.             }
  468.         } else {
  469.     checkmodulewords();
  470.     checkkeyword(TOK_SEGMENT);
  471.     if (curtok == TOK_SEGMENT) {
  472. note("SEGMENT or OVERLAY keyword ignored [259]");
  473. gettok();
  474.     }
  475.     p_attributes();
  476.             switch (curtok) {
  478.                 case TOK_LABEL:
  479.                     p_labeldecl();
  480.                     break;
  482.                 case TOK_IMPORT:
  483.                 case TOK_FROM:
  484.                     p_import(0);
  485.                     break;
  487. case TOK_EXPORT:
  488.     do {
  489. gettok();
  490. checkkeyword(TOK_QUALIFIED);
  491. if (curtok == TOK_QUALIFIED)
  492.     gettok();
  493. wneedtok(TOK_IDENT);
  494.     } while (curtok == TOK_COMMA);
  495.     if (!wneedtok(TOK_SEMI))
  496. skippasttoken(TOK_SEMI);
  497.     break;
  499.                 case TOK_MODULE:
  500.     p_nested_module();
  501.                     break;
  503.                 case TOK_PROCEDURE:
  504.                     p_function(0);
  505.                     break;
  507.                 case TOK_FUNCTION:
  508.                     p_function(1);
  509.                     break;
  511.                 case TOK_INCLUDE:
  512.                     if (blockkind == TOK_PROGRAM ||
  513.                         blockkind == TOK_IMPLEMENT ||
  514. (blockkind == TOK_FUNCTION && !collectnest)) {
  515.                         do_include(lastblockkind);
  516.                     } else {
  517.                         badinclude();
  518.                     }
  519.                     break;
  521.                 default:
  522.     if (curtok == TOK_BEGIN && blockkind == TOK_IMPORT) {
  523. warning("BEGIN encountered in interface text [274]");
  524. skipparens();
  525. if (curtok == TOK_SEMI)
  526.     gettok();
  527. break;
  528.     }
  529.                     blockkind = saveblockkind;
  530.                     return;
  531.             }
  532.             lastblockkind = TOK_END;
  533.         }
  534.     }
  535. }
  540. Static void skipunitheader()
  541. {
  542.     if (curtok == TOK_LPAR || curtok == TOK_LBR) {
  543. skipparens();
  544.     }
  545. }
  548. Static void skiptomodule()
  549. {
  550.     skipping_module++;
  551.     while (curtok != TOK_MODULE) {
  552.         if (curtok == TOK_END) {
  553.             gettok();
  554.             if (curtok == TOK_DOT)
  555.                 break;
  556.         } else
  557.             gettok();
  558.     }
  559.     skipping_module--;
  560. }
  564. Static void p_moduleinit(mod)
  565. Meaning *mod;
  566. {
  567.     Stmt *sp;
  568.     Strlist *sl;
  570.     if (curtok != TOK_BEGIN && curtok != TOK_END) {
  571. wexpecttok(TOK_END);
  572. skiptotoken2(TOK_BEGIN, TOK_END);
  573.     }
  574.     if (curtok == TOK_BEGIN || initialcalls) {
  575. echoprocname(mod);
  576. sp = p_body();
  577. strlist_mix(&mod->comments, curcomments);
  578. curcomments = NULL;
  579. if (ansiC != 0)
  580.     output("void ");
  581. output(format_s(name_UNITINIT, mod->name));
  582. if (void_args)
  583.     output("(void)n");
  584. else
  585.     output("()n");
  586. outcontext = mod;
  587. out_block(sp, BR_FUNCTION, 10000);
  588. free_stmt(sp);
  589. /* The following must come after out_block! */
  590. sl = strlist_append(&initialcalls,
  591.     format_s("%s()",
  592.      format_s(name_UNITINIT, mod->name)));
  593. sl->value = 1;
  594.     } else
  595. wneedtok(TOK_END);
  596. }
  600. Static void p_nested_module()
  601. {
  602.     Meaning *mp;
  604.     if (!modula2) {
  605. note("Ignoring nested module [260]");
  606. p_module(1, 0);
  607. return;
  608.     }
  609.     note("Nested modules not fully supported [261]");
  610.     checkmodulewords();
  611.     wneedtok(TOK_MODULE);
  612.     wexpecttok(TOK_IDENT);
  613.     mp = addmeaning(curtoksym, MK_MODULE);
  614.     mp->anyvarflag = 0;
  615.     gettok();
  616.     skipunitheader();
  617.     wneedtok(TOK_SEMI);
  618.     p_block(TOK_IMPLEMENT);
  619.     p_moduleinit(mp);
  620.     if (curtok == TOK_IDENT)
  621. gettok();
  622.     wneedtok(TOK_SEMI);
  623. }
  627. Static int p_module(ignoreit, isdefn)
  628. int ignoreit;
  629. int isdefn;    /* Modula-2: 0=local module, 1=DEFINITION, 2=IMPLEMENTATION */
  630. {
  631.     Meaning *mod, *mp;
  632.     Strlist *sl;
  633.     int kind;
  634.     char *cp;
  636.     checkmodulewords();
  637.     wneedtok(TOK_MODULE);
  638.     wexpecttok(TOK_IDENT);
  639.     if (curtokmeaning && curtokmeaning->kind == MK_MODULE && isdefn == 2) {
  640. mod = curtokmeaning;
  641. import_ctx(mod);
  642. for (mp = mod->cbase; mp; mp = mp->cnext)
  643.     if (mp->kind == MK_FUNCTION)
  644. mp->isforward = 1;
  645.     } else {
  646. mod = addmeaning(curtoksym, MK_MODULE);
  647.     }
  648.     mod->anyvarflag = 0;
  649.     pushctx(mod);
  650.     gettok();
  651.     skipunitheader();
  652.     wneedtok(TOK_SEMI);
  653.     if (ignoreit || 
  654.         (requested_module && strcicmp(requested_module, mod->name))) {
  655.         if (!quietmode)
  656.     if (outf == stdout)
  657. fprintf(stderr, "Skipping over module "%s"n", mod->name);
  658.     else
  659. printf("Skipping over module "%s"n", mod->name);
  660. checkmodulewords();
  661.         while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  662.             p_import(1);
  663. checkmodulewords();
  664. if (curtok == TOK_EXPORT)
  665.     gettok();
  666.         strlist_empty(&curcomments);
  667.         p_block(TOK_IMPORT);
  668.         setup_module(mod->sym->name, 0);
  669. checkmodulewords();
  670.         if (curtok == TOK_IMPLEMENT) {
  671.             skiptomodule();
  672.         } else {
  673.             if (!wneedtok(TOK_END))
  674. skippasttoken(TOK_END);
  675.             if (curtok == TOK_SEMI)
  676.                 gettok();
  677.         }
  678.         popctx();
  679.         strlist_empty(&curcomments);
  680.         return 0;
  681.     }
  682.     found_module = 1;
  683.     if (isdefn != 2) {
  684. if (!*hdrfname) {
  685.     sl = strlist_cifind(includefrom, mod->name);
  686.     if (sl)
  687. cleanheadername(hdrfname, (char *)sl->value);
  688.     else
  689. strcpy(hdrfname, format_ss(headerfnfmt, infname, mod->name));
  690. }
  691. saveoldfile(hdrfname);
  692. hdrf = fopen(hdrfname, "w");
  693. if (!hdrf) {
  694.     perror(hdrfname);
  695.     error("Could not open output file for header");
  696. }
  697. outsection(majorspace);
  698. if (usevextern && my_strchr(name_GSYMBOL, '%'))
  699.     output(format_s("#define %sn", format_s(name_GSYMBOL, mod->sym->name)));
  700. out_include(hdrfname, quoteincludes);
  701. outsection(majorspace);
  702. select_outfile(hdrf);
  703. output(format_s("/* Header for module %s, generated by p2c */n", mod->name));
  704. if (*name_HSYMBOL) {
  705.     cp = format_s(name_HSYMBOL, mod->sym->name);
  706.     output(format_ss("#ifndef %sn#define %sn", cp, cp));
  707. }
  708. outsection(majorspace);
  709. checkmodulewords();
  710. while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  711.     p_import(0);
  712. checkmodulewords();
  713. if (curtok == TOK_EXPORT)
  714.     gettok();
  715. checkmodulewords();
  716. while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  717.     p_import(0);
  718. outsection(majorspace);
  719. if (usevextern) {
  720.     output(format_s("#ifdef %sn# define vexternn#elsen",
  721.     format_s(name_GSYMBOL, mod->sym->name)));
  722.     output("# define vextern externn#endifn");
  723. }
  724. checkmodulewords();
  725. p_block(TOK_EXPORT);
  726. setup_module(mod->sym->name, 1);
  727. outsection(majorspace);
  728. if (usevextern)
  729.     output("#undef vexternn");
  730. outsection(minorspace);
  731. if (*name_HSYMBOL)
  732.     output(format_s("#endif /*%s*/n", format_s(name_HSYMBOL, mod->sym->name)));
  733. output("n/* End. */nn");
  734. select_outfile(codef);
  735. fclose(hdrf);
  736. *hdrfname = 0;
  737. redeclarevars(mod);
  738. declarevars(mod, 0);
  739.     }
  740.     checkmodulewords();
  741.     if (curtok != TOK_END) {
  742. if (!modula2 && !implementationmodules)
  743.     wneedtok(TOK_IMPLEMENT);
  744. import_ctx(mod);
  745.         p_block(TOK_IMPLEMENT);
  746. flushcomments(NULL, -1, -1);
  747. p_moduleinit(mod);
  748.         kind = 1;
  749.     } else {
  750.         kind = 0;
  751.         if (!wneedtok(TOK_END))
  752.     skippasttoken(TOK_END);
  753.     }
  754.     if (curtok == TOK_IDENT)
  755. gettok();
  756.     if (curtok == TOK_SEMI)
  757.         gettok();
  758.     popctx();
  759.     return kind;
  760. }
  765. int p_search(fname, ext, need)
  766. char *fname, *ext;
  767. int need;
  768. {
  769.     char infnbuf[300];
  770.     FILE *fp;
  771.     Meaning *mod;
  772.     int savesysprog, savecopysource;
  773.     int outerimportmark, importmark, mypermflag;
  775.     strcpy(infnbuf, fname);
  776.     fixfname(infnbuf, ext);
  777.     fp = fopen(infnbuf, "r");
  778.     if (!fp) {
  779.         if (need)
  780.             perror(infnbuf);
  781. if (logf)
  782.     fprintf(logf, "(Unable to open search file "%s")n", infnbuf);
  783.         return 0;
  784.     }
  785.     flushcomments(NULL, -1, -1);
  786.     ignore_directives++;
  787.     savesysprog = sysprog_flag;
  788.     sysprog_flag |= 3;
  789.     savecopysource = copysource;
  790.     copysource = 0;
  791.     outerimportmark = numimports;   /*obsolete*/
  792.     importmark = push_imports();
  793.     clearprogress();
  794.     push_input_file(fp, infnbuf, 0);
  795.     do {
  796. strlist_empty(&curcomments);
  797. checkmodulewords();
  798. permflag = 0;
  799. if (curtok == TOK_DEFINITION) {
  800.     gettok();
  801.     checkmodulewords();
  802. } else if (curtok == TOK_IMPLEMENT && modula2) {
  803.     gettok();
  804.     checkmodulewords();
  805.     warning("IMPLEMENTATION module in search text! [275]");
  806. }
  807.         if (!wneedtok(TOK_MODULE))
  808.     break;
  809.         if (!wexpecttok(TOK_IDENT))
  810.     break;
  811.         mod = addmeaning(curtoksym, MK_MODULE);
  812.         mod->anyvarflag = 0;
  813.         if (!quietmode && !showprogress)
  814.     if (outf == stdout)
  815. fprintf(stderr, "Reading import text for "%s"n", mod->name);
  816.     else
  817. printf("Reading import text for "%s"n", mod->name);
  818. if (verbose)
  819.     fprintf(logf, "%s, %d/%d: Reading import text for "%s"n",
  820.     infname, inf_lnum, outf_lnum, mod->name);
  821.         pushctx(mod);
  822.         gettok();
  823.         skipunitheader();
  824.         wneedtok(TOK_SEMI);
  825. mypermflag = permflag;
  826.         if (debug>0) printf("Found module %sn", mod->name);
  827. checkmodulewords();
  828.         while (curtok == TOK_IMPORT || curtok == TOK_FROM)
  829.             p_import(1);
  830. checkmodulewords();
  831. if (curtok == TOK_EXPORT)
  832.     gettok();
  833.         strlist_empty(&curcomments);
  834.         p_block(TOK_IMPORT);
  835.         setup_module(mod->sym->name, 0);
  836. if (mypermflag) {
  837.     strlist_add(&permimports, mod->sym->name)->value = (long)mod;
  838.     perm_import(mod);
  839. }
  840. checkmodulewords();
  841. if (curtok == TOK_END) {
  842.     gettok();
  843.     if (curtok == TOK_SEMI)
  844. gettok();
  845. } else {
  846.     wexpecttok(TOK_IMPLEMENT);
  847.     if (importall) {
  848. skiptomodule();
  849.             }
  850.         }
  851.         popctx();
  852.     } while (curtok == TOK_MODULE);
  853.     pop_imports(importmark);
  854.     unimport(outerimportmark);
  855.     sysprog_flag = savesysprog;
  856.     copysource = savecopysource;
  857.     ignore_directives--;
  858.     pop_input();
  859.     strlist_empty(&curcomments);
  860.     clearprogress();
  861.     return 1;
  862. }
  867. void p_program()
  868. {
  869.     Meaning *prog;
  870.     Stmt *sp;
  871.     int nummods, isdefn = 0;
  873.     flushcomments(NULL, -1, -1);
  874.     output(format_s("n#include %sn", p2c_h_name));
  875.     outsection(majorspace);
  876.     p_attributes();
  877.     ignore_attributes();
  878.     checkmodulewords();
  879.     if (modula2) {
  880. if (curtok == TOK_MODULE) {
  881.     curtok = TOK_PROGRAM;
  882. } else {
  883.     if (curtok == TOK_DEFINITION) {
  884. isdefn = 1;
  885. gettok();
  886. checkmodulewords();
  887.     } else if (curtok == TOK_IMPLEMENT) {
  888. isdefn = 2;
  889. gettok();
  890. checkmodulewords();
  891.     }
  892. }
  893.     }
  894.     switch (curtok) {
  896.         case TOK_MODULE:
  897.     if (implementationmodules)
  898. isdefn = 2;
  899.             nummods = 0;
  900.             while (curtok == TOK_MODULE) {
  901.                 if (p_module(0, isdefn)) {
  902.                     nummods++;
  903.                     if (nummods == 2 && !requested_module)
  904.                         warning("Multiple modules in one source file may not work correctly [276]");
  905.                 }
  906.             }
  907.     wneedtok(TOK_DOT);
  908.             break;
  910.         default:
  911.             if (curtok == TOK_PROGRAM) {
  912.                 gettok();
  913.                 if (!wexpecttok(TOK_IDENT))
  914.     skiptotoken(TOK_IDENT);
  915.                 prog = addmeaning(curtoksym, MK_MODULE);
  916.                 gettok();
  917.                 if (curtok == TOK_LPAR) {
  918.                     while (curtok != TOK_RPAR) {
  919.                         if (curtok == TOK_IDENT &&
  920.                             strcicmp(curtokbuf, "INPUT") &&
  921.                             strcicmp(curtokbuf, "OUTPUT") &&
  922.     strcicmp(curtokbuf, "KEYBOARD") &&
  923.     strcicmp(curtokbuf, "LISTING")) {
  924.     if (literalfilesflag == 2) {
  925. strlist_add(&literalfiles, curtokbuf);
  926.     } else
  927. note(format_s("Unexpected name "%s" in program header [262]",
  928.       curtokcase));
  929.                         }
  930.                         gettok();
  931.                     }
  932.                     gettok();
  933.                 }
  934. if (curtok == TOK_LBR)
  935.     skipparens();
  936.                 wneedtok(TOK_SEMI);
  937.             } else {
  938.                 prog = addmeaning(findsymbol("program"), MK_MODULE);
  939.             }
  940.             prog->anyvarflag = 1;
  941.             if (requested_module && strcicmp(requested_module, prog->name) &&
  942.                                     strcicmp(requested_module, "program")) {
  943.                 for (;;) {
  944.                     skiptomodule();
  945.                     if (curtok == TOK_DOT)
  946.                         break;
  947.                      (void)p_module(0, 2);
  948.                 }
  949. gettok();
  950.                 break;
  951.             }
  952.             pushctx(prog);
  953.             p_block(TOK_PROGRAM);
  954.             echoprocname(prog);
  955.     flushcomments(NULL, -1, -1);
  956.     if (curtok != TOK_EOF) {
  957. sp = p_body();
  958. strlist_mix(&prog->comments, curcomments);
  959. curcomments = NULL;
  960. if (fullprototyping > 0) {
  961.     output(format_s("main(int argc, %s *argv[])", charname));
  962. } else {
  963.     output("main(argc, argv)n");
  964.     singleindent(argindent);
  965.     output("int argc;n");
  966.     singleindent(argindent);
  967.     output(format_s("%s *argv[];n", charname));
  968. }
  969. outcontext = prog;
  970. out_block(sp, BR_FUNCTION, 10000);
  971. free_stmt(sp);
  972. popctx();
  973. if (curtok == TOK_SEMI)
  974.     gettok();
  975. else 
  976.     wneedtok(TOK_DOT);
  977.     }
  978.             break;
  980.     }
  981.     if (curtok != TOK_EOF) {
  982.         warning("Junk at end of input file ignored [277]");
  983.     }
  984. }
  990. /* End. */