home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / ENTERPRS / CPM / UTILS / S / SMC21SRC.LZH / CC41.C < prev    next >
Text File  |  2000-06-30  |  6KB  |  345 lines
  1.   /*
  2. ** print all assembler info before any code is generated
  3. */
  4. header()  {
  5.   beglab=getlabel();                      /*42*/
  6.   }
  7.  
  8. /*
  9. ** print any assembler stuff needed at the end
  10. */
  11. trailer()  {  
  12. #ifndef LINK
  13.  
  14.   if((beglab == 1)|(beglab > 9000))
  15.  
  16. #endif /* LINK */
  17.  
  18.   nl();                 /*keep last ";" from blanking first EXT*/
  19.  
  20.   cptr=STARTGLB;                        /*37*/
  21.   while(cptr<ENDGLB)  {                                   /*37*/
  22.     if(cptr[IDENT]==FUNCTION && cptr[CLASS]==AUTOEXT)     /*37*/
  23.       external(cptr+NAME);                                /*37*/
  24.  
  25.     if(cptr[IDENT]==FUNCTION && cptr[CLASS]==STATIC &&    /*force loading*/
  26.        astreq(cptr+NAME,"MAIN",NAMEMAX))                   /*of csyslib if*/
  27.        ol("_LINK:: EXT _MAIN");                            /*main program*/
  28.  
  29.     cptr+=SYMMAX;                                         /*37*/
  30.     }
  31.   ol("END");
  32.   }
  33.  
  34. /*
  35. ** load # args before function call
  36. */
  37. loadargc(val) int val; {
  38.   if(search("NOCCARGC", macn, NAMESIZE+2, MACNEND, MACNBR, 0)==0) {
  39.     if(val) {                                   /*35*/
  40.       ot("MVI A,");
  41.       outdec(val);
  42.       nl();
  43.       }                                           /*35*/
  44.     else ol("XRA A");                             /*35*/
  45.     }
  46.   }
  47.  
  48. /*
  49. ** declare entry point
  50. */
  51. entry() {
  52.   outstr(ssname);
  53.   col();
  54.  
  55. #ifdef LINK
  56.  
  57.     col();                                  /*28*/
  58.  
  59. #endif /* LINK */
  60.  
  61.   nl();
  62.   }
  63.  
  64. /*
  65. ** declare external reference
  66. */
  67. external(name) char *name; {
  68.  
  69. #ifdef LINK
  70.  
  71.     ot("EXT ");
  72.     ol(name);
  73.  
  74. #endif /* LINK */
  75.  
  76.   }
  77.  
  78. /*
  79. ** fetch object indirect to primary register
  80. */
  81. indirect(lval) int lval[]; {
  82.   if(lval[1]==CCHAR) ffcall("CCGCHAR##");
  83.   else               ffcall("CCGINT##");
  84.   }
  85.  
  86. /*
  87. ** fetch a static memory cell into primary register
  88. */
  89. getmem(lval)  int lval[]; {
  90.   char *sym;
  91.   sym=lval[0];
  92.   if((sym[IDENT]!=POINTER)&(sym[TYPE]==CCHAR)) {
  93.     ot("LDA ");
  94.     outstr(sym+NAME);
  95.     nl();
  96.     ffcall("CCSXT##");
  97.     }
  98.   else {
  99.     ot("LHLD ");
  100.     outstr(sym+NAME);
  101.     nl();
  102.     }
  103.   }
  104.  
  105. /*
  106. ** fetch addr of the specified symbol into primary register
  107. */
  108. getloc(sym)  char *sym; {
  109.   const(getint(sym+OFFSET, OFFSIZE)-csp);
  110.   ol("DAD SP");
  111.   }
  112.  
  113. /*
  114. ** store primary register into static cell
  115. */
  116. putmem(lval)  int lval[]; {
  117.   char *sym;
  118.   sym=lval[0];
  119.   if((sym[IDENT]!=POINTER)&(sym[TYPE]==CCHAR)) {
  120.     ol("MOV A,L");
  121.     ot("STA ");
  122.     }
  123.   else ot("SHLD ");
  124.   outstr(sym+NAME);
  125.   nl();
  126.   }
  127.  
  128. /*
  129. ** put on the stack the type object in primary register
  130. */
  131. putstk(lval) int lval[]; {
  132.   if(lval[1]==CCHAR) {
  133.     ol("MOV A,L");
  134.     ol("STAX D");
  135.     }
  136.   else ffcall("CCPINT##");
  137.   }
  138.  
  139. /*
  140. ** move primary register to secondary
  141. */
  142. move() {
  143.   ol("MOV D,H");
  144.   ol("MOV E,L");
  145.   }
  146.  
  147. /*
  148. ** swap primary and secondary registers
  149. */
  150. swap() {
  151.   ol("XCHG;;");  /* peephole() uses trailing ";;" */
  152.   }
  153.  
  154. /*
  155. ** partial instruction to get immediate value
  156. ** into the primary register
  157. */
  158. immed() {
  159.   ot("LXI H,");
  160.   }
  161.  
  162. /*
  163. ** partial instruction to get immediate operand
  164. ** into secondary register
  165. */
  166. immed2() {
  167.   ot("LXI D,");
  168.   }
  169.  
  170. /*
  171. ** push primary register onto stack
  172. */
  173. push() {
  174.   ol("PUSH H");
  175.   csp=csp-BPW;
  176.   }
  177.  
  178. /*
  179. ** unpush or pop as required
  180. */
  181. smartpop(lval, start) int lval[]; char *start; {
  182.   if(lval[5])  pop(); /* secondary was used */
  183.   else unpush(start);
  184.   }
  185.  
  186. /*
  187. ** replace a push with a swap
  188. */
  189. unpush(dest) char *dest; {
  190.   int i;
  191.   char *sour;
  192.   sour="XCHG;;";  /* peephole() uses trailing ";;" */
  193.   while(*sour) *dest++ = *sour++;
  194.   sour=stagenext;
  195.   while(--sour > dest) { /* adjust stack references */
  196.     if(streq(sour,"DAD SP")) {
  197.       --sour;
  198.       i=BPW;
  199.       while(isdigit(*(--sour))) {
  200.         if((*sour = *sour-i) < '0') {
  201.           *sour = *sour+10;
  202.           i=1;
  203.           }
  204.         else i=0;
  205.         }
  206.       }
  207.     }
  208.   csp=csp+BPW;
  209.   }
  210.  
  211. /*
  212. ** pop stack to the secondary register
  213. */
  214. pop() {
  215.   ol("POP D");
  216.   csp=csp+BPW;
  217.   }
  218.  
  219. /*
  220. ** swap primary register and stack
  221. */
  222. swapstk() {
  223.   ol("XTHL");
  224.   }
  225.  
  226. /*
  227. ** process switch statement
  228. */
  229. sw() {
  230.   ffcall("CCSWITCH##");
  231.   }
  232.  
  233. /*
  234. ** call specified subroutine name
  235. */
  236. ffcall(sname)  char *sname; {
  237.   ot("CALL ");
  238.   outstr(sname);
  239.   nl();
  240.   }
  241.  
  242. /*
  243. ** return from subroutine
  244. */
  245. ffret() {
  246.   ol("RET");
  247.   }
  248.  
  249. /*
  250. ** perform subroutine call to value on stack
  251. */
  252. callstk() {
  253.   ffcall ("CCDCAL##");                        /*36*/
  254.   }
  255.  
  256. /*
  257. ** jump to internal label number
  258. */
  259. jump(label)  int label; {
  260.   ot("JMP ");
  261.   printlabel(label);
  262.   nl();
  263.   }
  264.  
  265. /*
  266. ** test primary register and jump if false
  267. */
  268. testjump(label)  int label; {
  269.   ol("MOV A,H");
  270.   ol("ORA L");
  271.   ot("JZ ");
  272.   printlabel(label);
  273.   nl();
  274.   }
  275.  
  276. /*
  277. ** test primary register against zero and jump if false
  278. */
  279. zerojump(oper, label, lval) int (*oper)(), label, lval[]; { /*13*/
  280.   clearstage(lval[7], 0);  /* purge conventional code */
  281.   (*oper)(label);                             /*13*/
  282.   }
  283.  
  284. /*
  285. ** define storage according to size
  286. */
  287. defstorage(size) int size; {
  288.   if(size==1) ot("DB ");
  289.   else        ot("DW ");
  290.   }
  291.  
  292. /*
  293. ** point to following object(s)
  294. */
  295. point() {
  296.   ol("DW $+2");
  297.   }
  298.  
  299. /*
  300. ** modify stack pointer to value given
  301. */
  302. modstk(newsp, save)  int newsp, save; {
  303.   int k;
  304.   k=newsp-csp;
  305.   if(k==0)return newsp;
  306.   if(k>=0) {
  307.     if(k<7) {
  308.       if(k&1) {
  309.         ol("INX SP");
  310.         k--;
  311.         }
  312.       while(k) {
  313.         ol("POP B");
  314.         k=k-BPW;
  315.         }
  316.       return newsp;
  317.       }
  318.     }
  319.   if(k<0) {
  320.     if(k>-7) {
  321.       if(k&1) {
  322.         ol("DCX SP");
  323.         k++;
  324.         }
  325.       while(k) {
  326.         ol("PUSH B");
  327.         k=k+BPW;
  328.         }
  329.       return newsp;
  330.       }
  331.     }
  332.   if(save) swap();
  333.   const(k);
  334.   ol("DAD SP");
  335.   ol("SPHL");
  336.   if(save) swap();
  337.   return newsp;
  338.   }
  339.  
  340. /*
  341. ** double primary register
  342. */
  343. doublereg() {
  344.  ol("DAD H");}
  345.