home *** CD-ROM | disk | FTP | other *** search
/ CD Shareware Magazine 1996 December / CD_shareware_12-96.iso / DOS / Programa / CCDL122.ZIP / SOURCE / OUTCO386.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-06  |  18.5 KB  |  729 lines
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1996, David Lindauer
  5.  * 
  6.  * This compiler is intended for educational use.  It may not be used
  7.  * for profit without the express written consent of the author.
  8.  *
  9.  * It may be freely redistributed, as long as this notice remains intact
  10.  * and sources are distributed along with any executables derived from them.
  11.  *
  12.  * The author is not responsible for damages, either direct or consequential,
  13.  * that may arise from use of this software.
  14.  *
  15.  * v1.5 August 1996
  16.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  17.  *
  18.  * Credits to Mathew Brandt for original K&R C compiler
  19.  *
  20.  */
  21. #include        <stdio.h>
  22. #include        "expr.h"
  23. #include        "c.h"
  24. #include        "gen.h"
  25. #include        "cglbdec.h"
  26.  
  27. typedef struct muldiv {
  28.         struct muldiv * link;
  29.         long value;
  30.         double floatvalue;
  31.         int size;
  32.         int label;
  33. } MULDIV;
  34. /*      variable initialization         */
  35. extern HASHREC **globalhash;
  36. extern int phiused;
  37.  
  38. enum e_gt { nogen, bytegen, wordgen, longgen, floatgen, doublegen, longdoublegen, storagegen,srrefgen };
  39. enum e_sg { noseg, codeseg, dataseg,bssxseg,startupxseg,rundownxseg,cppxseg };
  40.  
  41. extern int    prm_asmfile;
  42. extern int prm_lines;
  43. extern FILE *tempfil;
  44.  
  45. MULDIV *muldivlink = 0;
  46. int           gentype = nogen;        /* Current DC type */
  47. int           curseg = noseg;        /* Current seg */
  48. int        outcol = 0;                /* Curront col (roughly) */
  49. int newlabel;
  50. int needpointer;
  51. static int phiput;
  52. /* Init module */
  53. void outcodeini(void)
  54. {
  55.     gentype = nogen;
  56.     curseg = noseg;
  57.     outcol = 0;
  58.     newlabel = FALSE;
  59.     phiput = FALSE;
  60. }
  61. /* List of opcodes
  62.  * This list MUST be in the same order as the op_ enums 
  63.  */
  64. char * oplst[] = { "LINE#", "LABEL","SEQ@","DB",
  65.     "ADD", "AND", "CALL", "CLD", "CMP", "CMPSB", "CMPSW", "CMPSD",
  66.     "CWD", "CBW", "CBD", "DEC",
  67.     "DIV", "IDIV", "IMUL", "INC", "JB", "JBE","JE", "JL",
  68.     "JLE", "JNC", "JA", "JNE", "JGE", "JG", "JMP", "LEA", "LODSB",
  69.     "LODSW", "LODSD",
  70.     "MOV", "MOVSB", "MOVSW", "MOVSD", "MOVSX", "MOVZX", "MUL", 
  71.     "NEG", "NOT", "OR", "POP", "PUSH", "REP", "REPNZ", "REPZ", 
  72.     "RET", "SAHF", "SAL", "SAR", "SCASB", "SCASW", "SCASD",
  73.     "SHR", "SHL", "STD", "STOSB", "STOSW", "STOSD", "SUB",
  74.     "TEST", "XCHG", "XOR", "DD", "PUSHFD", "IRETD", "PUSHAD", "POPAD",
  75.     "FADD", "FIADD", "FCHS", "FCOM", "FCOMP", "FCOMPP",
  76.     "FDIV", "FIDIV", "FICOM", "FICOMP", "FILD", "FIST", "FISTP",
  77.     "FLD", "FLDZ", "FMUL", "FIMUL", "FPREM", "FSCALE", "FST", "FSTP",
  78.     "FSTCW", "FSTSW", "FSUB", "FISUB", "FTST", "FXCH", "FWAIT"
  79.     };
  80. /*
  81.  * Register a fixup 
  82.  */
  83. /* Put an opcode
  84.  */
  85. void putop(int op)
  86. {       
  87.     if (op > op_fwait)
  88.     diag("illegal opcode.");
  89.     else
  90.       fprintf(tempfil,"\t%s",oplst[op]);
  91. }
  92.  
  93. void putconst(ENODE *offset)
  94. /*
  95.  *      put a constant to the tempfil file.
  96.  */
  97. {       switch( offset->nodetype )
  98.                 {
  99.                                 case en_autoreg:
  100.                 case en_autocon:
  101.                 case en_icon:
  102.                                 case en_acon:
  103.                         fprintf(tempfil,"0%lXH",offset->v.i);
  104.                         break;
  105.                                 case en_rcon:
  106.                                                 fprintf(tempfil,"%f",offset->v.f);
  107.                                                 break;
  108.                                 case en_nalabcon:
  109.                         fprintf(tempfil,"L_%d",offset->v.i);
  110.                         break;
  111.                 case en_labcon:
  112.                         fprintf(tempfil,"CS:L_%d",offset->v.i);
  113.                         break;
  114.                                 case en_napccon:
  115.                 case en_nacon:
  116.                         fprintf(tempfil,"%s",offset->v.p[0]);
  117.                         break;
  118.                 case en_add:
  119.                         putconst(offset->v.p[0]);
  120.                         fprintf(tempfil,"+");
  121.                         putconst(offset->v.p[1]);
  122.                         break;
  123.                 case en_sub:
  124.                         putconst(offset->v.p[0]);
  125.                         fprintf(tempfil,"-");
  126.                         putconst(offset->v.p[1]);
  127.                         break;
  128.                 case en_uminus:
  129.                         fprintf(tempfil,"-");
  130.                         putconst(offset->v.p[0]);
  131.                         break;
  132.                 default:
  133.                         diag("illegal constant node.");
  134.                         break;
  135.                 }
  136. }
  137. void putlen(int l)
  138. /*
  139.  *      append the length field to an instruction.
  140.  */
  141. { 
  142.     if (l!= 10 && l != 8 && l != 6 && l != 4 && l != 1 && l != 2 && l != 0)
  143.      diag("illegal length field.");
  144. }
  145. void putsizedreg(char *string, int reg, int size)
  146. {
  147.     static char *byteregs[] = { "AL","CL","DL","BL","*A","*C","*D","*B" };
  148.     static char *wordregs[] = { "AX", "CX", "DX","BX","SP","BP","SI","DI"  };
  149.     static char *longregs[] = { "EAX", "ECX", "EDX","EBX","ESP","EBP","ESI","EDI" };
  150.   if (size == 4)
  151.         fprintf(tempfil,string,longregs[reg]);
  152.     else if (size == 1)
  153.         fprintf(tempfil,string,byteregs[reg]);
  154.         else
  155.             fprintf(tempfil,string,wordregs[reg]);
  156. }
  157. void pointersize(int size)
  158. {
  159. //    if (needpointer)
  160.         switch (size) {        
  161.             case 10:
  162.                 fprintf(tempfil,"TWORD PTR ");
  163.                 break;
  164.             case 8:
  165.                 fprintf(tempfil,"QWORD PTR ");
  166.                 break;
  167.             case 6:
  168.             case 4:
  169.                 fprintf(tempfil,"DWORD PTR ");
  170.                 break;
  171.             case 2:
  172.                 fprintf(tempfil,"WORD PTR ");
  173.                 break;
  174.             case 1:
  175.                 fprintf(tempfil,"BYTE PTR ");
  176.                 break;
  177.             default:
  178.                 diag("Bad pointer");
  179.         }    
  180. }
  181. void putamode(AMODE *ap,int size)
  182. /*
  183.  *      tempfil a general addressing mode.
  184.  */
  185. {       switch( ap->mode )
  186.                 {
  187.                                 case am_cs:
  188.                                                 fprintf(tempfil,"CS");
  189.                                                 break;
  190.                 case am_immed:
  191.                                                 if (size && (ap->offset->nodetype == en_labcon 
  192.                                                         || ap->offset->nodetype == en_nacon
  193.                                                         || ap->offset->nodetype == en_napccon
  194.                                                         || ap->offset->nodetype == en_nalabcon))
  195.                                                     fprintf(tempfil,"OFFSET ");
  196.                         putconst(ap->offset);
  197.                                                 break;
  198.                 case am_direct:
  199.                                                 pointersize(size);
  200.                                                 fputc('[',tempfil);
  201.                         putconst(ap->offset);
  202.                                                 fputc(']',tempfil);
  203.                         break;
  204.                 case am_dreg:
  205.                                                 putsizedreg("%s",ap->preg,size);
  206.                                                 break;
  207.                                 case am_freg:
  208.                                                 fprintf(tempfil,"ST(%d)",ap->preg);
  209.                                                 break;
  210.                                 case am_indisp:
  211.                                                 pointersize(size);
  212.                                                 putsizedreg("[%s",ap->preg,4);
  213.                                                 if (ap->offset) {
  214.                                                     fputc('+',tempfil);
  215.                                                     putconst(ap->offset);
  216.                                                 }
  217.                                                 fputc(']',tempfil);
  218.                                                 break;
  219.                                 case am_indispscale:
  220.                                                     pointersize(size);
  221.                                                 putsizedreg("[%s+",ap->preg,4);
  222.                                                 putsizedreg("%s",ap->sreg,4);
  223.                                                 if (ap->scale != 1)
  224.                                                     fprintf(tempfil,"*0%XH",ap->scale);
  225.                                                 if (ap->offset) {
  226.                                                     fputc('+',tempfil);
  227.                                                     putconst(ap->offset);
  228.                                                 }
  229.                                                 fputc(']',tempfil);
  230.                                                 break;
  231.                 default:
  232.                         diag("illegal address mode.");
  233.                         break;
  234.                 }
  235. }
  236.  
  237. void put_code(int op,int len,int len2,AMODE *aps,AMODE *apd)
  238. /*
  239.  *      tempfil a generic instruction.
  240.  */
  241. {       
  242.         if (!prm_asmfile)    
  243.             return;
  244.         if (op == op_line) {
  245.             if (!prm_lines)
  246.                 return;
  247.             fprintf(tempfil,";\n; Line %d:\t%s\n;\n",len,(char *)aps);
  248.             return;
  249.         }
  250.         needpointer = (len != len2) || ((!aps || aps->mode !=am_dreg) && (!apd || apd->mode !=am_dreg));
  251.         putop(op);
  252.         putlen(len);
  253.         if( aps != 0 )
  254.                 {
  255.                 fprintf(tempfil,"\t");
  256.         putamode(aps,len);
  257.                 if( apd != 0 )
  258.                         {
  259.                         fprintf(tempfil,",");
  260.                         putamode(apd,len2);
  261.                         }
  262.                 }
  263.   fprintf(tempfil,"\n");
  264. }
  265.  
  266. void gen_strlab(char *s)
  267. /*
  268.  *      generate a named label.
  269.  */
  270. {
  271.         if (prm_asmfile)
  272.             if (curseg == dataseg || curseg == bssxseg) {
  273.                 newlabel = TRUE;
  274.                  fprintf(tempfil,"\n%s",s);
  275.                 outcol = strlen(s)+1;
  276.             }
  277.             else
  278.         fprintf(tempfil,"%s:\n",s);
  279. }
  280.  
  281. void put_label(int lab)
  282. /*
  283.  *      tempfil a compiler generated label.
  284.  */
  285. {
  286.        if (prm_asmfile)
  287.                     fprintf(tempfil,"L_%d:\n",lab);
  288. }
  289.  
  290. void genfloat(float val)
  291. /*
  292.  * Output a float value
  293.  */
  294. {         if (prm_asmfile)
  295.         if( gentype == floatgen && outcol < 60) {
  296.                 fprintf(tempfil,",%f",val);
  297.                 outcol += 8;
  298.                 }
  299.         else    {
  300.                                 if (!newlabel)
  301.                                     nl();
  302.                                 else newlabel = FALSE;
  303.                 fprintf(tempfil,"\tDD\t%f",val);
  304.                 gentype = floatgen;
  305.                 outcol = 19;
  306.                 }
  307. }
  308.  
  309. void gendouble(double val)
  310. /*
  311.  * Output a double value
  312.  */
  313. {         if (prm_asmfile)
  314.         if( gentype == doublegen && outcol < 60) {
  315.                 fprintf(tempfil,",%f",val);
  316.                 outcol += 8;
  317.                 }
  318.         else    {
  319.                                 if (!newlabel)
  320.                                     nl();
  321.                                 else newlabel = FALSE;
  322.                 fprintf(tempfil,"\tDQ\t%f",val);
  323.                 gentype = doublegen;
  324.                 outcol = 19;
  325.                 }
  326. }
  327. void genlongdouble(double val)
  328. /*
  329.  * Output a double value
  330.  */
  331. {         if (prm_asmfile)
  332.         if( gentype == longdoublegen && outcol < 60) {
  333.                 fprintf(tempfil,",%f",val);
  334.                 outcol += 8;
  335.                 }
  336.         else    {
  337.                                 if (!newlabel)
  338.                                     nl();
  339.                                 else newlabel = FALSE;
  340.                 fprintf(tempfil,"\tDT\t%f",val);
  341.                 gentype = longdoublegen;
  342.                 outcol = 19;
  343.                 }
  344. }
  345.  
  346. void genbyte(long val)
  347. /*
  348.  * Output a byte value
  349.  */
  350. {         if (prm_asmfile)
  351.         if( gentype == bytegen && outcol < 60) {
  352.                 fprintf(tempfil,",0%XH",val & 0x00ff);
  353.                 outcol += 4;
  354.                 }
  355.         else    {
  356.                                 if (!newlabel)
  357.                                     nl();
  358.                                 else newlabel = FALSE;
  359.                 fprintf(tempfil,"\tDB\t0%XH",val & 0x00ff);
  360.                 gentype = bytegen;
  361.                 outcol = 19;
  362.                 }
  363. }
  364.  
  365. void genword(long val)
  366. /*
  367.  * Output a word value
  368.  */
  369. {     if (prm_asmfile)
  370.         if( gentype == wordgen && outcol < 58) {
  371.                 fprintf(tempfil,",0%XH",val & 0x0ffff);
  372.                 outcol += 6;
  373.                 }
  374.         else    {
  375.                                 if (!newlabel)
  376.                                     nl();
  377.                                 else newlabel = FALSE;
  378.                 fprintf(tempfil,"\tDW\t0%XH",val & 0x0ffff);
  379.                 gentype = wordgen;
  380.                 outcol = 21;
  381.                 }
  382. }
  383.  
  384. void genlong(long val)
  385. /*
  386.  * Output a long value
  387.  */
  388. {     if (prm_asmfile)
  389.         if( gentype == longgen && outcol < 56) {
  390.                 fprintf(tempfil,",0%lXH",val);
  391.                 outcol += 10;
  392.                 }
  393.         else    {
  394.                                 if (!newlabel)
  395.                                     nl();
  396.                                 else newlabel = FALSE;
  397.                 fprintf(tempfil,"\tDD\t0%lXH",val);
  398.                 gentype = longgen;
  399.                 outcol = 25;
  400.                 }
  401. }
  402.  
  403. void gensrref(char *name, int val)
  404. {
  405.             if (prm_asmfile)
  406.         if( gentype == srrefgen && outcol < 56) {
  407.                 fprintf(tempfil,",%s,%d",name,val);
  408.                 outcol += strlen(name)+1;
  409.                 }
  410.         else    {
  411.                 nl();
  412.                 fprintf(tempfil,"\tDD\t%s,%d",name,val);
  413.                 gentype = srrefgen;
  414.                 outcol = 25;
  415.                 }
  416. }
  417. void genref(SYM *sp,int offset)
  418. /*
  419.  * Output a reference to the data area (also gens fixups )
  420.  */
  421. {       char    sign;
  422.             char buf[40];
  423.         if( offset < 0) {
  424.                 sign = '-';
  425.                 offset = -offset;
  426.                 }
  427.         else
  428.                 sign = '+';
  429.             if (sp->storage_class == sc_static)
  430.                 sprintf(buf,"L_%d%c%d",sp->value.i,sign,offset);
  431.             else
  432.                 sprintf(buf,"%s%c%d",sp->name,sign,offset);
  433.             if (prm_asmfile) {
  434.         if( gentype == longgen && outcol < 55 - strlen(sp->name)) {
  435.                 fprintf(tempfil,",%s",buf);
  436.                 outcol += (11 + strlen(sp->name));
  437.                 }
  438.         else    {
  439.                                 if (!newlabel)
  440.                                     nl();
  441.                                 else newlabel = FALSE;
  442.                 fprintf(tempfil,"\tDD\t%s",buf);
  443.                 outcol = 26 + strlen(sp->name);
  444.                 gentype = longgen;
  445.                 }
  446.             }
  447. }
  448. void genpcref(SYM *sp,int offset)
  449. /*
  450.  * Output a reference to the code area (also gens fixups )
  451.  */
  452. {
  453.     genref(sp,offset);
  454. }
  455. void genstorage(int nbytes)
  456. /*
  457.  * Output bytes of storage
  458.  */
  459. {            if (prm_asmfile) {
  460.                                 if (!newlabel)
  461.                                     nl();
  462.                                 else newlabel = FALSE;
  463.         fprintf(tempfil,"\tDB\t0%XH DUP (?)",nbytes);
  464.                 outcol = 28;
  465.                 gentype = storagegen;
  466.             }
  467. }
  468.  
  469. void gen_labref(int n)
  470. /*
  471.  * Generate a reference to a label
  472.  */
  473. {            if (prm_asmfile)
  474.         if( gentype == longgen && outcol < 58) {
  475.                 fprintf(tempfil,",L_%d",n);
  476.                 outcol += 6;
  477.                 }
  478.         else    {
  479.                                 if (!newlabel)
  480.                                     nl();
  481.                                 else newlabel = FALSE;
  482.                 fprintf(tempfil,"\tDD\tL_%d",n);
  483.                 outcol = 22;
  484.                 gentype = longgen;
  485.                 }
  486. }
  487.  
  488. int     stringlit(char *s)
  489. /*
  490.  *      make s a string literal and return it's label number.
  491.  */
  492. {       struct slit     *lp;
  493.         ++global_flag;          /* always allocate from global space. */
  494.         lp = xalloc(sizeof(struct slit));
  495.         lp->label = nextlabel++;
  496.         lp->str = litlate(s);
  497.         lp->next = strtab;
  498.         strtab = lp;
  499.         --global_flag;
  500.         return lp->label;
  501. }
  502.  
  503. void dumplits(void)
  504. /*
  505.  *      dump the string literal pool.
  506.  */
  507. {       char            *cp;
  508.         while( strtab != 0) {
  509.                 cseg();
  510.                 nl();
  511.                 put_label(strtab->label);
  512.                 cp = strtab->str;
  513.                 while(*cp)
  514.                         genbyte(*cp++);
  515.                 genbyte(0);
  516.                 strtab = strtab->next;
  517.                 }
  518.         nl();
  519. }
  520.  
  521. void nl(void)
  522. /*
  523.  * New line
  524.  */
  525. {    if (prm_asmfile) {
  526.        if(outcol > 0) {
  527.                 fputc('\n',tempfil);
  528.                 outcol = 0;
  529.                 gentype = nogen;
  530.                 }
  531.              if (phiused && !phiput)
  532.                                 fputc(0x1f,outputFile);
  533.          }
  534. }
  535. /*
  536.  * Exit if from a special segment
  537.  */
  538. void exitseg(void)
  539. {
  540.     if (curseg == startupxseg) {
  541.         curseg = noseg;
  542.         fprintf(tempfil,"cstartup\tENDS\n");
  543.     }
  544.     else if (curseg == rundownxseg) {
  545.         curseg = noseg;
  546.         fprintf(tempfil,"crundown\tENDS\n");
  547.     }
  548.     else if (curseg == cppxseg) {
  549.         curseg = noseg;
  550.         fprintf(tempfil,"cppinit\tENDS\n");
  551.     }
  552. }
  553. /*
  554.  * Switch to cseg 
  555.  */
  556. void cseg(void)
  557. {            if (prm_asmfile)
  558.            if( curseg != codeseg) {
  559.                 nl();
  560.                                 exitseg();
  561.                 fprintf(tempfil,"\t.CODE\n");
  562.                 curseg = codeseg;
  563.                 }
  564. }
  565. /*
  566.  * Switch to deseg
  567.  */
  568. void dseg(void)
  569. {     if (prm_asmfile)  
  570.                 if( curseg != dataseg) {
  571.                 nl();
  572.                                 exitseg();
  573.                 fprintf(tempfil,"\t.DATA\n");
  574.                 curseg = dataseg;
  575.                 }
  576. }
  577. /*
  578.  * Switch to bssseg
  579.  */
  580. void bssseg(void)
  581. {     if (prm_asmfile)  
  582.                 if( curseg != bssxseg) {
  583.                 nl();
  584.                                 exitseg();
  585.                 fprintf(tempfil,"\t.DATA?\n");
  586.                 curseg = bssxseg;
  587.                 }
  588. }
  589. /*
  590.  * Switch to startupseg
  591.  */
  592. void startupseg(void)
  593. {     if (prm_asmfile)  
  594.                 if( curseg != startupxseg) {
  595.                 nl();
  596.                                 exitseg();    
  597.                 fprintf(tempfil,"cstartup\tSEGMENT USE32 PUBLIC DWORD \042INITDATA\042\n");
  598.                 curseg = startupxseg;
  599.                 }
  600. }
  601. /*
  602.  * Switch to rundownseg
  603.  */
  604. void rundownseg(void)
  605. {     if (prm_asmfile)  
  606.                 if( curseg != rundownxseg) {
  607.                 nl();
  608.                                 exitseg();
  609.                 fprintf(tempfil,"crundown\tSEGMENT USE32 PUBLIC DWORD \042EXITDATA\042\n");
  610.                 curseg = rundownxseg;
  611.                 }
  612. }
  613. void cppseg(void)
  614. {     if (prm_asmfile)  
  615.                 if( curseg != cppxseg) {
  616.                 nl();
  617.                                 exitseg();
  618.                 fprintf(tempfil,"cppinit\tSEGMENT USE32 PUBLIC DWORD \042CPPDATA\042\n");
  619.                 curseg = cppxseg;
  620.                 }
  621. }
  622. void gen_virtual(char *name)
  623. {
  624.     if (prm_asmfile) {
  625.         nl();
  626.         fprintf(tempfil,"@%s\tSEGMENT VIRTUAL",name);
  627.     }
  628. }
  629. void gen_endvirtual(char *name)
  630. {
  631.     if (prm_asmfile) {
  632.         nl();
  633.         fprintf(tempfil,"@%s\tENDS",name);
  634.     }
  635. }
  636. /*
  637.  * Align
  638.  */
  639. void align(int size)
  640. {
  641.             if (prm_asmfile) {
  642.                 nl();
  643.                 fprintf(tempfil,"\tALIGN\t%d\n",4);
  644.             }
  645. }
  646. /* muldiv val init
  647.  */
  648. void init_muldivval(void)
  649. {
  650.     muldivlink = 0;
  651. }
  652. /*
  653.  * queue muldiv val
  654.  */
  655. void queue_muldivval(int label, long number)
  656. {
  657.     MULDIV *p = xalloc(sizeof(MULDIV));
  658.     p->link = muldivlink;
  659.     p->value = number;
  660.     p->label = label;
  661.     p->size = 0;
  662.     muldivlink = p;
  663. }
  664. void queue_floatval(int label, double number, int size)
  665. {
  666.     MULDIV *p = xalloc(sizeof(MULDIV));
  667.     p->link = muldivlink;
  668.     p->floatvalue = number;
  669.     p->label = label;
  670.     p->size = size;
  671.     muldivlink = p;
  672. }
  673. void dump_muldivval(void)
  674. {
  675.     int tag = FALSE;
  676.     if (prm_asmfile) {
  677.         fprintf(tempfil,"\n");
  678.         if (muldivlink) {
  679.             tag = TRUE;
  680.             align(4);
  681.         }
  682.         while (muldivlink) {
  683.             put_label(muldivlink->label);
  684.             if (muldivlink->size == 0)
  685.                 fprintf(tempfil,"\tDD\t0%xH\n",muldivlink->value);
  686.             else if (muldivlink->size == 6)
  687.                 fprintf(tempfil,"\tDD\t%f\n",muldivlink->floatvalue);
  688.             else
  689.                 fprintf(tempfil,"\tDQ\t%f\n",muldivlink->floatvalue);
  690.             muldivlink = muldivlink->link;
  691.         }
  692.         if (tag)
  693.             fprintf(tempfil,"\n");
  694.     }
  695. }
  696.             
  697. void putexterns(void)
  698. /*
  699.  * Output the fixup tables and the global/external list
  700.  */
  701. {       SYM     *sp;
  702.             int i;
  703.             if (prm_asmfile){
  704.                 nl();
  705.                 exitseg();
  706.                 fprintf(outputFile,"\t.386\n\t.MODEL SMALL\n\n");
  707.                 for (i=0; i < HASHTABLESIZE; i++) {
  708.                     if ((sp=(SYM *) globalhash[i]) != 0) {
  709.                         while (sp) {
  710.                     if( sp->storage_class == sc_external && sp->extflag)
  711.                 fprintf(outputFile,"\tEXTRN\t%s\n",sp->name);
  712.                     else if( sp->storage_class == sc_externalfunc && sp->extflag)
  713.                 fprintf(outputFile,"\tEXTRN\t%s:PROC\n",sp->name);
  714.                     else if( sp->storage_class == sc_global )
  715.                 fprintf(outputFile,"\tPUBLIC\t%s\n",sp->name);
  716.                      sp = sp->next;
  717.                         }
  718.                     }
  719.                 }
  720.                 rewind(tempfil);
  721.                 while (!feof(tempfil)) {
  722.                     char buf[256];
  723.                     buf[0] = 0;
  724.                     fgets(buf,256,tempfil);
  725.                     fputs(buf,outputFile);
  726.                 }
  727.                 fprintf(outputFile,"\tEND\n");
  728.             }
  729. }