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

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

编译器/解释器

开发平台：

Others

CMAIN.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. /*
  23.  * The following symbols must be defined on the compile command line:
  24.  *    PROGNAME
  25.  *    ENVNAME
  26.  *    GLBDEFINE
  27.  *   SOURCEXT
  28.  */
  29. #include        <stdio.h>
  30. #include <malloc.h>
  31. #include  <string.h>
  32. #include  <setjmp.h>
  33. #include <signal.h>
  34. #include <stdlib.h>
  35. #include "utype.h"
  36. #include "cmdline.h"
  37. #include        "expr.h"
  38. #include "errors.h"
  39. #include        "c.h"
  40. #include  "diag.h"
  42. #define VERSION 151
  44. typedef struct list {
  45. struct list *link;
  46. void *data;
  47. } LIST;
  49. extern char GLBDEFINE[],SOURCEXT[],ENVNAME[],PROGNAME[];
  51. extern ERRORS *errlist;
  52. extern TABLE    tagtable;
  53. extern int      total_errors;
  54. extern int diagcount;
  55. extern char *errfile;
  56. extern TABLE gsyms;
  58. FILE            *inputFile = 0, *listFile = 0, *outputFile = 0, *cppFile = 0, *errFile = 0;
  59. int stoponerr = 0;
  60. LIST *clist = 0;
  61. LIST *deflist = 0;
  62. int prm_linkreg = TRUE;
  63. int prm_stackcheck = FALSE;
  64. int prm_warning = TRUE;
  65. #ifdef OBJEXT
  66. int prm_asmfile = FALSE;
  67. #else
  68. int prm_asmfile = TRUE;
  69. #endif
  70. int prm_ansi = FALSE;
  71. int prm_listfile = FALSE;
  72. int prm_maxerr = 25;
  73. int prm_diag = FALSE;
  74. int prm_bss = TRUE;
  75. int prm_cppfile = FALSE;
  76. int prm_packing = FALSE;
  77. int prm_revbits = FALSE;
  78. int prm_lines = TRUE;
  79. int prm_cplusplus = FALSE;
  80. int prm_cmangle = TRUE;
  81. int basear = 1, basedr = 1, basefr = 1;
  82. int prm_debug = FALSE;
  83. int version = VERSION;
  84. int prm_errfile = FALSE;
  86. char *prm_searchpath = 0;
  87. jmp_buf ctrlcreturn;
  88. int file_count = 0;
  90. char     *infile, listfile[40],outfile[40],cppfile[40],errorfile[40];
  91. void bool_setup(char select, char *string);
  92. void err_setup(char select, char *string);
  93. void incl_setup(char select, char *string);
  94. void def_setup(char select, char *string);
  95. void codegen_setup(char select, char *string);
  96. void optimize_setup(char select, char *string);
  97. void warning_setup(char select, char *string);
  98. void parsefile(char select, char *string);
  100. /* setup for ARGS.C */
  101. ARGLIST ArgList[] = {
  102.   { 'i', ARG_BOOL, bool_setup },
  103.   { 'e', ARG_BOOL, bool_setup },
  104.   { 'f', ARG_CONCATSTRING, parsefile },
  105.   { 'l', ARG_BOOL, bool_setup },
  106. #ifdef OBJEXT
  107.   { 'v', ARG_BOOL, bool_setup },
  108. #endif
  109.   { 'w', ARG_CONCATSTRING, warning_setup },
  110.   { 'A', ARG_BOOL, bool_setup },
  111.   { 'C', ARG_CONCATSTRING, codegen_setup },
  112.   { 'O', ARG_CONCATSTRING, optimize_setup },
  113.   { 'E', ARG_CONCATSTRING, err_setup },
  114.   { 'I', ARG_CONCATSTRING, incl_setup },
  115. { 'D', ARG_CONCATSTRING, def_setup },
  116. #ifdef OBJEXT
  117.   { 'S', ARG_BOOL, bool_setup },
  118. #endif
  119.   { 0, 0, 0 }
  120. };
  124. void bool_setup(char select, char *string)
  125. /*
  126.  * activation routine (callback) for boolean command line arguments
  127.  */
  128. {
  129. int bool = (int)string;
  130. if (select == 'S')
  131. prm_asmfile = bool;
  132.   if (select == 'l')
  133. prm_listfile = bool;
  134. if (select == 'i')
  135. prm_cppfile = bool;
  136. if (select == 'e')
  137. prm_errfile = bool;
  138. if (select == 'v')
  139. prm_debug = bool;
  140. if (select == 'A')
  141. prm_ansi = bool;
  142. }
  143. void codegen_setup(char select, char *string)
  144. /*
  145.  * activation for code-gen type command line arguments
  146.  */
  147. {
  148. int bool = TRUE;
  149. while (*string) {
  150. switch (*string) {
  151. case 'd':
  152. prm_diag = bool;
  153. break;
  154. case 'p':
  155. prm_packing = bool;
  156. break;
  157. case 'r':
  158. prm_revbits = bool;
  159. break;
  160. case 'b':
  161. prm_bss=bool;
  162. break;
  163. case 'l':
  164. prm_lines = bool;
  165. break;
  166. case 'm':
  167. prm_cmangle = bool;
  168. break;
  169. case 'S':
  170. prm_stackcheck = bool;
  171. break;
  172. case 'R':
  173. prm_linkreg = bool;
  174. break;
  175. case '-':
  176. bool = FALSE;
  177. break;
  178. case '+':
  179. bool = TRUE;
  180. break;
  181. default:
  182. if (!confcodegen(*string,bool)) 
  183. fatal("Illegal codegen parameter ");
  184. }
  185. string++;
  186. }
  187. }
  188. void optimize_setup(char select, char *string)
  189. /*
  190.  * activation for optimizer command line arguments
  191.  */
  192. {
  193. int bool = TRUE;
  194. while (*string) {
  195. switch (*string) {
  196. case 'R':
  197. string++;
  198. while (*string && *string != '+' && *string != '-') {
  199. switch (*string++) {
  200. case 'a':
  201. basear = bool;
  202. break;
  203. case 'd':
  204. basedr = bool;
  205. break;
  206. case 'f':
  207. basefr = bool;
  208. break;
  209. default:
  210. goto errorx;
  211. }
  212. if (!*string)
  213. return;
  214. }
  215. break;
  216. case '-':
  217. bool = FALSE;
  218. break;
  219. case '+':
  220. bool = TRUE;
  221. break;
  222. default:
  223. errorx:
  224. fatal("Illegal optimizer parameter");
  225. }
  226. string++;
  227. }
  228. }
  229. void err_setup(char select, char *string)
  230. /*
  231.  * activation for the max errs argument
  232.  */
  233. {
  234. prm_maxerr = atoi(string);
  235. }
  236. void incl_setup(char select, char * string)
  237. /*
  238.  * activation for include paths
  239.  */
  240. {
  241. if (prm_searchpath)
  242. prm_searchpath = realloc(prm_searchpath,strlen(string)+strlen(prm_searchpath)+1);
  243. else {
  244. prm_searchpath = malloc(strlen(string)+1);
  245. prm_searchpath[0] = 0;
  246. }
  247. strcat(prm_searchpath,string);
  248. }
  249. void def_setup(char select, char *string)
  250. /*
  251.  * activation for command line #defines
  252.  */
  253. {
  254. char *s = malloc(strlen(string)+1);
  255. LIST *l = malloc(sizeof(LIST));
  256. strcpy(s,string);
  257. l->link = deflist;
  258. deflist = l;
  259. l->data = s;
  260. }
  261. void setglbdefs(void)
  262. /*
  263.  * function declares any global defines from the command line and also
  264.  * declares a couple of other macros so we can tell what the compiler is
  265.  * doing
  266.  */
  267. {
  268. LIST *l = deflist;
  269. while (l) {
  270. char *s = l->data;
  271. char *n = s;
  272. while (*s && *s != '=')
  273. s++;
  274. if (*s == '=')
  275. *s++=0;
  276. glbdefine(n,s);
  277. l = l->link;
  278. }
  279. #ifdef CPLUSPLUS
  280. if (prm_cplusplus) {
  281. glbdefine("__cplusplus","");
  282. }
  283. #endif
  284. glbdefine(GLBDEFINE,"");
  285. }
  286. void InsertAnyFile(FILE *inf, FILE *outf, char *filename, char *path, int drive)
  287. /*
  288.  * Insert a file name onto the list of files to process
  289.  */
  291. {
  292.   char *newbuffer, buffer[100],*p = buffer;
  293. LIST *r = &clist;
  295. file_count++;
  297. if (drive != -1) {
  298. *p++ = (char)(drive + 'A');
  299. *p++ = ':';
  300. }
  301. if (path) {
  302. strcpy(p,path);
  303. strcat(p,"\");
  304. }
  305. else
  306. *p = 0;
  307.   /* Allocate buffer and make .C if no extension */
  308. strcat(buffer,filename);
  309.   AddExt(buffer,".C");
  310.   newbuffer = (char *) malloc(strlen(buffer) + 1);
  311.   strcpy(newbuffer,buffer);
  313.   /* Insert file */
  314. while (r->link)
  315. r = r->link;
  316. r->link = malloc(sizeof(LIST));
  317. r = r->link;
  318. r->link = 0;
  319. r->data = newbuffer;
  320. }
  321. void dumperrs(FILE *file);
  322. void setfile(char *buf,char *orgbuf,char *ext)
  323. /*
  324.  * Get rid of a file path an add an extension to the file name
  325.  */
  326. {
  327. char *p = strrchr(orgbuf,'\');
  328. if (!p) p = orgbuf;
  329. else p++;
  330. strcpy(buf,p);
  331. StripExt(buf);
  332. AddExt(buf,ext);
  333. }
  334. int parse_arbitrary(char *string)
  335. /*
  336.  * take a C string and and convert it to ARGC, ARGV format and then run
  337.  * it through the argument parser
  338.  */
  339. {
  340. char *argv[40];
  341. int rv,i;
  342. int argc = 1;
  343. if (!string || !*string)
  344. return 1;
  345. while (1) {
  346. while (*string == ' ') 
  347. string++;
  348. if (!*string)
  349. break;
  350. argv[argc++] = string;
  351. while (*string && *string != ' ') string++;
  352. if (!*string)
  353. break;
  354. *string = 0;
  355. string++;
  356. }
  357.   rv = parse_args(&argc,argv,TRUE);
  358.   for (i= 1; i < argc; i++)
  359. InsertAnyFile(0,0,argv[i],0,-1);
  360. return rv;
  361. }
  362. void parsefile(char select, char *string)
  363. /*
  364.  * parse arguments from an input file
  365.  */
  366. {
  367. FILE *temp;
  368. if (!(temp = fopen(string,"r")))
  369. fatal("Argument file not found");
  370. while (!feof(temp)) {
  371. char buf[256];
  372. buf[0] = 0;
  373. fgets(buf,256,temp);
  374. if (buf[strlen(buf)-1] == 'n')
  375. buf[strlen(buf)-1] = 0;
  376. if (!parse_arbitrary(buf))
  377. break;
  378. }
  379. fclose(temp);
  380. }
  381. void addinclude(void)
  382. /*
  383.  * Look up the INCLUDE environment variable and append it to the
  384.  * search path
  385.  */
  386. {
  387. char *string = getenv("CCINCL");
  388. if (string && string[0]) {
  389. char temp[500];
  390. strcpy(temp,string);
  391. if (prm_searchpath) {
  392. strcat(temp,";");
  393. strcat(temp,prm_searchpath);
  394. free(prm_searchpath);
  395. }
  396. prm_searchpath = malloc(strlen(temp)+1);
  397. strcpy(prm_searchpath,temp);
  398. }
  399. }
  400. int parseenv(char *name)
  401. /*
  402.  * Parse the environment argument string
  403.  */
  404. {
  405. char *string = getenv(name);
  406. return parse_arbitrary(string);
  407. }
  408. void dumperrs(FILE *file)
  409. {
  410. #ifdef DIAGNOSTICS
  411. if (diagcount)
  412. fprintf(file,"%d Diagnostics detectedn",diagcount);
  413. #endif
  414. if (total_errors)
  415. fprintf(file,"%d Total errorsn",total_errors);
  416. if (prm_diag)
  417. mem_summary();
  418. }
  419. void summary(void)
  420. {       
  421. if (prm_listfile) {
  422.     fprintf(listFile,"fn *** global scope symbol table ***nn");
  423.     list_table(&gsyms,0);
  424. if (tagtable.head) {
  425.      fprintf(listFile,"n *** structures and unions ***nn");
  426.      list_table(&tagtable,0);
  427. }
  428. dumperrs(listFile);
  429.   }
  430. }
  431. void ctrlchandler(int aa)
  432. {
  433. longjmp(ctrlcreturn,1);
  434. }
  435. int main(int argc,char *argv[])
  436. {
  437. char buffer[40];
  438. char *p;
  439.   banner("%s Version %d.%02d Copyright (c) 1994-1997, LADsoft",PROGNAME,VERSION/100,VERSION %100);
  440.   outfile[0] = 0;
  442. /* parse the environment and command line */
  443. /* inpout cfg file has already been parsed */
  444.   if (!parseenv(ENVNAME))
  445.     usage(argv[0]);
  446.   if (!parse_args(&argc, argv, TRUE) || (!file_count && argc == 1))
  447.     usage(argv[0]);
  450. /* tack the environment includes in */
  451. addinclude();
  453. /* processor-dependent initialization */
  454. confsetup();
  456.   /* Scan the command line for file names or response files */
  457. { int i;
  458. for (i=1; i <argc; i++) 
  459. InsertAnyFile(0,0,argv[i],0,-1);
  460. }
  463.   /* Set up a ctrl-C handler so we can exit the prog */
  464. signal(SIGINT,ctrlchandler);
  465. if (setjmp(ctrlcreturn))
  466. exit(1);
  467. /* loop through and compile all the files on the file list */
  468. while (clist) {
  469. inasmini();
  470. memini();
  471.   symini();
  472. stmtini();
  473. kwini();
  474. initini();
  475. preprocini();
  476. exprini();
  477. declini();
  478. funcini();
  479. peepini();
  480. outcodeini();
  481. regini();
  482. printf("file: %sn",clist->data);
  483.   strcpy(buffer,clist->data);
  484. #ifdef OBJEXT
  485. if (prm_asmfile)
  486. #endif
  487. setfile(outfile,buffer,SOURCEXT);
  488. #ifdef OBJEXT
  489. else
  490. setfile(outfile,buffer,OBJEXT);
  491. #endif
  492. setfile(cppfile,buffer,".I");
  493. setfile(listfile,buffer,".LST");
  494. setfile(errorfile,buffer,".ERR");
  495. prm_cplusplus = FALSE;
  496.   AddExt(buffer,".C");
  497. #ifdef CPLUSPLUS
  498. p = strrchr(buffer,'.');
  499. if (*(p-1) != '.') {
  500. if (p[1] == 'c' || p[1] == 'C')
  501. if (p[2] == 'p' || p[2] == 'P')
  502. if (p[3] == 'p' || p[3] == 'P')
  503. prm_cplusplus = TRUE;
  504. }
  505. #endif
  506. infile = errfile = litlate(buffer);
  508. if (prm_cppfile) {
  509. if (!(cppFile = fopen(cppfile,"w")))
  510. fatal("Can't open cpp file %s",cppfile);
  511. }
  512.    if (!(inputFile = fopen(infile,"r")))
  513.      fatal("Can't open input file %s",infile);
  514.    if (!(outputFile = fopen(outfile,"w"))) {
  515.      fclose(inputFile);
  516.      fatal("Can't open output file %s",outfile);
  517.   }
  518. if (prm_asmfile)
  519. asm_header();
  520.   if (prm_listfile)
  521.    if (!(listFile = fopen(listfile,"w"))) {
  522.      fclose(inputFile);
  523.     fclose(outputFile);
  524.      fatal("Can't open list file %s",listfile);
  525.    }
  526.   if (prm_errfile)
  527.    if (!(errFile = fopen(errorfile,"w"))) {
  528. fclose(listFile);
  529.      fclose(inputFile);
  530.     fclose(outputFile);
  531.      fatal("Can't open error file %s",errorfile);
  532.    }
  533. initerr();
  534.   initsym();
  535. setglbdefs();
  536.    getch();
  537.    getsym();
  538.   compile();
  539. summary();
  540.    release_global();
  541. dumperrs(stdout);
  542.   fclose(inputFile);
  543. if (prm_asmfile) {
  544.    fclose(outputFile);
  545. }
  546.    if (prm_listfile)
  547.      fclose(listFile);
  548.    if (prm_errfile)
  549.      fclose(errFile);
  550.    if (prm_cppfile)
  551.      fclose(cppFile);
  552. clist = clist->link;
  554. /* Remove the ASM file if there are errors */
  555. if (total_errors)
  556. remove(outfile);
  558. /* Remove the ERR file if no warnings / errors */
  559. if (!errlist && prm_errfile)
  560. remove(errorfile);
  562. /* Flag to stop if there are any errors */
  563. stoponerr |= total_errors;
  564. }
  565.   if (stoponerr)
  566.     return(1);
  567.   else
  568.     return(0);
  569. }