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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
FUNC.C
资源名称：c_compiler.zip　[点击查看]
上传用户：hlzzc88
上传日期：2007-01-06
资源大小：220k
文件大小：10k
源码类别：

编译器/解释器

开发平台：

Others

FUNC.C：源码内容
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1997, 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 either the original sources or derived sources 
  11.  * are distributed along with any executables derived from the originals.
  12.  *
  13.  * The author is not responsible for any damages that may arise from use
  14.  * of this software, either idirect or consequential.
  15.  *
  16.  * v1.35 March 1997
  17.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  18.  *
  19.  * Credits to Mathew Brandt for original K&R C compiler
  20.  *
  21.  */
  22. #include        <stdio.h>
  23. #include "list.h"
  24. #include        "expr.h"
  25. #include        "c.h"
  26. #include "errors.h"
  28. extern int ispascal;
  29. extern FILE *listFile;
  30. extern enum e_sym lastst;
  31. extern long firstlabel,nextlabel;
  32. extern char lastid[];
  33. extern TABLE gsyms,lsyms;
  34. extern int global_flag;
  35. extern int stdaddrsize, stdretblocksize;
  36. extern int stackadd,stackmod;
  37. extern TYP *head, *tail;
  38. extern char declid[100];
  39. extern int prm_listfile;
  40. extern int prm_cplusplus;
  41. extern int stdintsize;
  42. extern int goodcode;
  43. extern int prm_linkreg;
  44. extern TABLE lsyms;
  46. int block_nesting;
  48. TABLE oldlsym;
  49. LIST *varlisthead,*varlisttail;
  51. static int skm_func[] = { closepa,begin,semicolon,0 };
  53. SYM *currentfunc=0;
  55. /*      function compilation routines           */
  56. void funcini(void)
  57. {
  58. currentfunc = 0;
  59. }
  60. void declfuncarg(int isint)
  61. {       char    *names[50];             /* 50 parameters maximum */
  62.         int     nparms, poffset, i, isinline;
  63.         SYM     *sp1, *sp2, *spsave[50], *oldargs=0;
  64. TYP *temp, *temp1;
  65. char oldeclare[100];
  66. char *nm;
  67. if (prm_linkreg && !isint)
  68.          poffset = stdretblocksize;            /* size of return block */
  69. else
  70.          poffset = 0;            /* size of return block */
  71.         nparms = 0;
  72. temp = head;
  73. temp1 = tail;
  74. if (!prm_cplusplus) {
  75. sp2 = gsearch(declid);
  76. if (sp2) {
  77. oldargs = sp2->tp->lst.head;
  78. }
  79. }
  80. temp->lst.head = temp->lst.tail = 0;
  81. if (lastst == kw_void) {
  82. getsym();
  83. if (lastst != closepa) {
  84. backup(lastst);
  85. lastst = kw_void;
  86. }
  87. else {
  88. temp->lst.head = (SYM *)-1;
  89. getsym();
  90.   goto verify;
  91. }
  92. }
  93. else
  94. if (lastst == closepa) {
  95. getsym();
  96. goto verify;
  97. }
  98. strcpy(oldeclare,declid);
  99.         if(!prm_cplusplus && lastst == id && 
  100. ((sp1 = search(nm=litlate(lastid),&gsyms)) ==0 || sp1->storage_class != sc_type) 
  101. && ((sp1 = search(nm,&lsyms)) ==0 || sp1->storage_class != sc_type)) {
  102.               /* declare parameters */
  103. global_flag = 0;
  104.                 while(lastst == id) {
  105.                         names[nparms++] = nm;
  106.                         getsym();
  107.                         if( lastst == comma)
  108.                                 getsym();
  109.                         else
  110.                                 break;
  111.                         }
  112. global_flag = 1;
  113.                 needpunc(closepa,skm_func);
  114.                 doargdecl(sc_member,0,0,&temp->lst,isinline = FALSE);      /* declare parameters */
  115. }
  116. else {
  117. doargdecl(sc_member,names,&nparms,&temp->lst,isinline = TRUE);
  118. needpunc(closepa,skm_func);
  119. }
  120. strcpy(declid,oldeclare);
  121. if (!ispascal && 
  122. (temp->btp->type == bt_struct || temp->btp->type == bt_union))
  123. poffset += stdaddrsize;
  125.         for(i = 0;i < nparms;++i) {
  126.             if ((sp1 = search(names[i],&temp->lst)) == 0 && !isinline)
  127.               sp1 = makeint(litlate(names[i]),&temp->lst);
  128. if (sp1->tp)
  129. sp1->tp->uflags |= UF_DEFINED;
  130. sp1->funcparm = TRUE;
  131. spsave[i] = sp1;
  132.             sp1->storage_class = sc_auto;
  133. }
  134. /*
  135.  * parameter allocation.  Have to do things backwards if this
  136.  * function has the _pascal declarator
  137.  */
  138. if (!ispascal)
  139.          for(i = 0;i < nparms;++i) {
  140. sp1 = spsave[i];
  141. if( sp1->tp->type != bt_pointer && sp1->tp->size < stdintsize)
  142. {
  143. sp1->value.i = poffset + funcvaluesize(sp1->tp->size);
  144. poffset += stdintsize;
  145. }
  146. else
  147. {
  148. sp1->value.i = poffset;
  149. if (sp1->tp->type == bt_pointer)
  150. poffset += stdaddrsize;
  151. else
  152. poffset += sp1->tp->size;
  153. }
  154. }
  155. else
  156.          for(i = nparms-1;i >=0;--i) {
  157. sp1 = spsave[i];
  158. if( sp1->tp->type != bt_pointer && sp1->tp->size < stdintsize)
  159. {
  160. sp1->value.i = poffset + funcvaluesize(sp1->tp->size);
  161. poffset += stdintsize;
  162. }
  163. else
  164. {
  165. sp1->value.i = poffset;
  166. if (sp1->tp->type == bt_pointer)
  167. poffset += stdintsize;
  168. else
  169. poffset += sp1->tp->size;
  170. }
  171. }
  172. if (!isinline) {
  173. temp->lst.head = temp->lst.tail = 0;
  174. for (i=0; i < nparms; i++)
  175. insert(spsave[i],&temp->lst);
  176. }
  177. #ifdef CPLUSPLUS
  178. if (prm_cplusplus && temp->lst.head == 0)
  179. temp->lst.head = (SYM *) -1; /* () is equiv to (void) in cpp */
  180. #endif
  181. verify:
  182. head = temp;
  183. tail = temp1;
  184. #ifdef CPLUSPLUS
  185. if (prm_cplusplus)
  186. return;
  187. #endif
  189. if (oldargs && head->sname) {
  190. SYM *newargs = head->lst.head;
  191. while (oldargs && newargs) {
  192. if (!checktype(oldargs->tp,newargs->tp))
  193. gensymerror(ERR_ARGMISMATCH,newargs->name);
  194. if (oldargs == (SYM *)-1 || newargs == (SYM *)-1)
  195. break;
  196. oldargs = oldargs->next;
  197. newargs = newargs->next;
  198. }
  199. if (oldargs && oldargs != (SYM *)-1)
  200. gensymerror(ERR_ARGLENSHORT,head->sname);
  201. if (newargs && newargs != (SYM *)-1)
  202. gensymerror(ERR_ARGLENLONG,head->sname);
  203. }
  204. if (sp2 && !checktype(sp2->tp->btp,head->btp))
  205. gensymerror(ERR_DECLMISMATCH,sp2->name);
  206. }
  207. void check_funcused(TABLE *oldlsym, TABLE *lsyms)
  208. {
  209. /* oldlsym Must BE 0 at the end of a function */
  210. SYM *sym1;
  211. if (oldlsym && oldlsym->head == lsyms->head) {
  212. return;
  213. }
  214. sym1 = lsyms->head;
  215. while (sym1 && (!oldlsym || sym1 != oldlsym->head)) {
  216. if (sym1->tp->type != bt_func && sym1->tp->type != bt_ifunc
  217. && sym1->storage_class != sc_type) {
  218. if (!(sym1->tp->uflags & UF_USED)) {
  219. if (sym1->storage_class == sc_label) {
  220. if (!oldlsym)
  221. gensymerror(ERR_UNUSEDLABEL,sym1->name);
  222. }
  223. else gensymerror(ERR_SYMUNUSED,sym1->name);
  224. }
  225. if (sym1->tp->uflags & UF_ASSIGNED)
  226. gensymerror(ERR_SYMASSIGNED,sym1->name);
  227. if (!oldlsym && sym1->storage_class == sc_ulabel)
  228. gensymerror(ERR_UNDEFLABEL,sym1->name);
  229. }
  230. sym1 = sym1->next;
  231. }
  232. }
  233. void funcbody(SYM *sp)
  234. /*
  235.  */
  236. {
  237. SYM *sp1 = sp->tp->lst.head, *sp2;
  238. varlisthead = 0;
  239.         global_flag = 0;
  240. if (sp1 != (SYM *)-1) {
  241. while (sp1) {
  242. if (sp1->name[0] != '*') {
  243. sp2 = xalloc(sizeof(SYM));
  244. memcpy(sp2,sp1,sizeof(SYM));
  245. insert(sp2,&lsyms);
  246. }
  247. sp1 = sp1->next;
  248. }
  249. }
  250. currentfunc = sp;
  251.         cseg();
  252. firstlabel = nextlabel;
  253. if (sp->storage_class == sc_global)
  254. globaldef(sp);
  255. goodcode &= ~GF_RETURN;
  256.         block();
  257. check_funcused(0,&lsyms);
  258. if (prm_listfile && varlisthead) {
  259. LIST *q = varlisthead;
  260.        fprintf(listFile,"nn*** local symbol table ***nn");
  261. while (q) {
  262. SYM *sp = q->data;
  263. while (sp) {
  264. list_var(sp,0);
  265. sp = sp->next;
  266. }
  267. q = q->link;
  268. }
  269. }
  270. if (sp->tp->btp->type != bt_void && !(goodcode &GF_RETURN)) 
  271. generror(ERR_FUNCRETVAL,0,0);
  272.         nl();
  273. currentfunc = 0;
  275.         release_local();        /* release local symbols */
  276.    lsyms.head = 0;
  277. oldlsym.head = oldlsym.tail = 0;
  278.         global_flag = 1;
  279. }
  281. SYM     *makeint(char *name, TABLE *table)
  282. {       SYM     *sp;
  283.         TYP     *tp;
  284. global_flag++;
  285.         sp = xalloc(sizeof(SYM));
  286.         tp = xalloc(sizeof(TYP));
  287. global_flag--;
  288.         tp->type = bt_long;
  289.         tp->size = 4;
  290.         tp->btp = tp->lst.head = 0;
  291.         tp->sname = 0;
  292.         sp->name = name;
  293.         sp->storage_class = sc_auto;
  294.         sp->tp = tp;
  295.         insert(sp,table);
  296.         return sp;
  297. }
  298. void addblocklist(SYM *sp)
  299. {
  300. LIST *l;
  301. if (!sp) return;
  302. l = xalloc(sizeof(LIST));
  303. l->link = 0;
  304. l->data = sp;
  305. if (varlisthead)
  306. varlisttail = varlisttail->link = l;
  307. else
  308. varlisthead = varlisttail = l;
  309. }
  310. void block(void)
  311. {       
  312. SNODE *snp3;
  313. block_nesting = 1;
  314. lastst = 0;
  315. snp3 = snp_line();
  316. lastst = begin;
  317. needpunc(begin,0);
  318.         dodecl(sc_auto);
  319. cseg();
  320. if (snp3)
  321. snp3->next = compound();
  322. else
  323. snp3 = compound();
  324. addblocklist(lsyms.head);
  325.         genfunc(snp3);
  326.         flush_peep();
  327. }
  328. void gather_labels(TABLE *oldlsym, TABLE *lsyms)
  329. {
  330. TABLE sym;
  331. sym.head = 0;
  332. if (oldlsym->head == lsyms->head) {
  333. return;
  334. }
  335. else {
  336. SYM *sp = lsyms->head,*r = oldlsym->head;
  337. lsyms->head = 0;
  338. while (sp && sp != r) {
  339. SYM *q = sp->next;
  340. sp->next = 0;
  341. if (sp->storage_class == sc_label || sp->storage_class == sc_ulabel) {
  342. if (!oldlsym->head) {
  343. oldlsym->head = oldlsym->tail = sp;
  344. }
  345. else {
  346. oldlsym->tail->next = sp;
  347. oldlsym->tail = sp;
  348. }
  349. }
  350. else
  351. if (!lsyms->head)
  352. lsyms->head = lsyms->tail = sp;
  353. else
  354. lsyms->tail = lsyms->tail->next = sp;
  355. sp = q;
  356. }
  357. if (oldlsym->tail)
  358. oldlsym->tail->next = 0;
  359. }
  360. }
  361. SNODE *compoundblock(void)
  362. {
  363. SNODE *snp;
  364. TABLE oldoldlsym;
  365. SYM *q;
  366. block_nesting++;
  367. oldoldlsym = oldlsym;
  368. oldlsym = lsyms;
  369. dodecl(sc_auto);
  370. cseg();
  371. snp = compound();
  372. check_funcused(&oldlsym,&lsyms);
  373. q = lsyms.head;
  374. gather_labels(&oldlsym,&lsyms);
  375. while (q && q->next != oldlsym.head)
  376. q = q->next;
  377. if (q) 
  378. q->next = 0;
  379. addblocklist(lsyms.head);
  381. lsyms = oldlsym;
  382. oldlsym.head = oldoldlsym.head;
  383. block_nesting--;
  384. return(snp);
  385. }