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

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

编译器/解释器

开发平台：

Others

MANGLE.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. /* Handles name mangling
  23.  */
  24. #include        <stdio.h>
  25. #include <malloc.h>
  26. #include <ctype.h>
  27. #include        "expr.h"
  28. #include        "c.h"
  29. #include  "errors.h"
  31. extern TABLE oldlsym,lsyms,gsyms;
  32. extern int prm_cplusplus,prm_cmangle;
  33. #define HASHTABLESIZE 1023
  35. #ifdef CPLUSPLUS
  36. char destructor_name[] = "$dtr";
  37. char constructor_name[] = "$ctr";
  39. char *tn_void = "void";
  40. char *tn_char = "char";
  41. char *tn_int = "int";
  42. char *tn_long = "long" ;
  43. char *tn_short = "short";
  44. char *tn_unsigned = "unsigned ";
  45. char *tn_ellipse = "...";
  46. char *tn_float = "float";
  47. char *tn_double = "double";
  48. char *tn_longdouble = "long double";
  49. #endif /* CPLUSPLUS */
  51. /* Insert an overloaded function ref into the function table
  52.  */
  53. void funcrefinsert(char *name, char *mangname, TYP *tp, TABLE *tbl)
  54. {
  55. #ifdef CPLUSPLUS
  56. char buf[100];
  57. SYM *sp,*sp1;
  58. sp = xalloc(sizeof(SYM));
  59. buf[0] = '$';
  60. buf[1] = '$';
  61. strcpy(&buf[2],name);
  62. sp->defalt = mangname;
  63. sp->storage_class = sc_defunc;
  64. sp->value.overlist.head = 0;
  65. sp->name = litlate(buf);
  66. sp->tp = tp;
  67. sp1 = search(buf,tbl);
  68. if (sp1)
  69. if (sp1->value.overlist.head == 0)
  70. sp1->value.overlist.head = sp1->value.overlist.tail = sp;
  71. else
  72. sp1->value.overlist.tail = sp1->value.overlist.tail->next = sp;
  73. else
  74. insert(sp,tbl);
  75. #endif
  76. }
  77. #ifdef CPLUSPLUS
  78. /* See if two C++ functions match */
  79. static int fomatch(TYP *tp1, TYP *tp2)
  80. {
  81. SYM *sp1 = tp1->lst.head;
  82. SYM *sp2 = tp2->lst.head;
  83. if (sp1 == (SYM *)-1 && sp2 == (SYM *)-1)
  84. return TRUE;
  85. if (sp1 && sp1->defalt)
  86. return TRUE;
  87. while (sp2 && sp1) {
  88. if (sp1->tp->type == bt_ellipse)
  89. return TRUE;
  90. if (!exactype(sp1->tp, sp2->tp) && !(isscalar(tp1) && isscalar(tp2)))
  91. return FALSE;
  92. if (sp1->defalt)
  93. return TRUE;
  94. sp1 = sp1->next;
  95. sp2 = sp2->next;
  96. }
  97. return sp1 == sp2;
  98. }
  99. #endif
  100. /* Search the tables looking for a match for an argument type list */
  101. SYM *funcovermatch(char *name,TYP *tp)
  102. {
  103. #ifdef CPLUSPLUS
  104. char buf1[100];
  105. TABLE *tbl1, *tbl2;
  106. if (prm_cplusplus) {
  107. SYM *sp2,*sp3,*sp4=0,*sp5=0,*sp6,*sp7;
  108. tbl1 = &lsyms;
  109. tbl2 = &gsyms;
  110. buf1[0] = '$';
  111. buf1[1] = '$';
  112. strcpy(&buf1[2],name);
  113. sp2 = search(buf1,tbl1);
  114. sp3 = search(buf1,tbl2);
  115. if (sp2)
  116. if (fomatch(sp2->tp,tp)) 
  117. sp4 = sp2;
  118. if (sp3)
  119. if (fomatch(sp3->tp,tp)) 
  120. sp5 = sp3;
  121. if (sp4 && sp5) {
  122. genfunc2error(ERR_AMBIGFUNC,sp4->defalt,sp5->defalt);
  123. return gsearch(sp4->defalt);
  124. }
  125. if (sp2) {
  126. sp6 = sp2->value.overlist.head;
  127. while (sp6) {
  128. if (fomatch(sp6->tp,tp)) {
  129. if (sp4) {
  130. genfunc2error(ERR_AMBIGFUNC,sp4->defalt,sp6->defalt);
  131. return gsearch(sp4->defalt);
  132. }
  133. else if (sp5) {
  134. genfunc2error(ERR_AMBIGFUNC,sp5->defalt,sp6->defalt);
  135. return gsearch(sp5->defalt);
  136. }
  137. else sp4 = sp6;
  138. }
  139. sp6 = sp6->next;
  140. }
  141. }
  142. if (sp3) {
  143. sp7 = sp3->value.overlist.head;
  144. while (sp7) {
  145. if (fomatch(sp7->tp,tp)) {
  146. if (sp4) {
  147. genfunc2error(ERR_AMBIGFUNC,sp4->defalt,sp7->defalt);
  148. return gsearch(sp4->defalt);
  149. }
  150. else if (sp5) {
  151. genfunc2error(ERR_AMBIGFUNC,sp5->defalt,sp7->defalt);
  152. return gsearch(sp5->defalt);
  153. }
  154. else sp5 = sp7;
  155. }
  156. sp7 = sp7->next;
  157. }
  158. }
  159. if (sp4)
  160. return gsearch(sp4->defalt);
  161. if (sp5)
  162. return gsearch(sp5->defalt);
  163. }
  164. #endif
  165. return(gsearch(name));
  166. }
  167. #ifdef CPLUSPLUS
  168. /* Mangle one C++ argument */
  169. static char *cpponearg(char *buf,TYP *tp)
  170. {
  171. start:
  172. switch (tp->type) {
  173. case bt_ptrfunc:
  174. *buf++ = 'q';
  175. buf = cppargs(buf,tp->lst.head);
  176. *buf++ = '$';
  177. tp = tp->btp;
  178. goto start;
  179. case bt_struct:
  180. case bt_union:
  181. case bt_class:
  182. case bt_enum:
  183. sprintf(buf,"%d%s",strlen(tp->sname+1),tp->sname+1);
  184. buf = buf + strlen(buf);
  185. break;
  186. case bt_unsignedshort:
  187. *buf++ = 'u';
  188. case bt_short:
  189. *buf++ = 's';
  190. break;
  191. case bt_unsigned:
  192. *buf++ = 'u';
  193. case bt_long:
  194. *buf++ = 'i';
  195. break;
  196. case bt_unsignedchar:
  197. *buf++ = 'u';
  198. case bt_char:
  199. *buf++ = 'c';
  200. break;
  201. case bt_float:
  202. *buf++ = 'f';
  203. break;
  204. case bt_double:
  205. *buf++ = 'd';
  206. break;
  207. case bt_longdouble:
  208. *buf++ = 'g';
  209. break;
  210. case bt_pointer:
  211. *buf++ = 'p';
  212. tp = tp->btp;
  213. goto start;
  214. case bt_ref:
  215. *buf++ = 'r';
  216. tp = tp->btp;
  217. goto start;
  218. case bt_ellipse:
  219. *buf++ = 'e';
  220. break;
  221. }
  222. *buf = 0;
  223. return buf;
  224. }
  225. /* Mangle an entire C++ function */
  226. static char *cppargs(char *buf,SYM *sp)
  227. {
  228. *buf++ = 'q';
  229. if (sp == (SYM *)-1) {
  230. *buf++ = 'v';
  231. }
  232. else while (sp) {
  233. buf = cpponearg(buf,sp->tp);
  234. sp = sp->next;
  235. }
  236. *buf=0;
  237. return buf + strlen(buf);
  238. }
  239. /* Wrapper for function name mangling */
  240. char * cppmangle(char *name, TYP *tp)
  241. {
  242. char buf[100];
  243. if (*name == 0)
  244. return 0;
  245. if (prm_cmangle)
  246. name++;
  247. sprintf(buf,"@%s$",name);
  248. cppargs(buf+strlen(buf),tp->lst.head);
  249. return(litlate(buf));
  250. }
  252. /* Unmangle a pointer reference */
  253. char * putptr(char *buf, int *ptr, int **ptrs)
  254. {
  255. int *p = *ptrs;
  256. buf = buf+strlen(buf);
  257. while ((*ptr)--) {
  258. *buf++ = ' ';
  259. if (*p++) 
  260. *buf++= '&';
  261. else
  262. *buf++ = '*';
  263. }
  264. *ptr = 0;
  265. *buf = 0;
  266. return buf;
  267. }
  269. /* Argument unmangling for C++ */
  270. static char *unmang1(char *buf, char *name, int *ptr, int **ptrs)
  271. {
  272. start:
  273. if (isdigit(*name)) {
  274. int v = *name++ - '0';
  275. while (isdigit(*name)) 
  276. v = v*10+ *name++ - '0';
  277. while (v--) 
  278. *buf++ = *name++;
  279. *buf = 0;
  280. }
  281. else switch (*name++) {
  282. case 'q': {
  283. char buf1[100],buf2[100];
  284. strcpy(buf1," (*) ");
  285. buf+=5;
  286.   name = unmangcppfunc(buf1,name);
  287. name++;
  288. name = unmang1(buf2,name,ptr,ptrs);
  289. buf = putptr(buf,ptr,ptrs);
  290. strcpy(buf,buf2);
  291. strcat(buf,buf1);
  292. buf = buf +strlen(buf);
  294. }
  295. break;
  296. case 'u':
  297. strcpy(buf,"unsigned ");
  298. buf = buf+9;
  299. switch(*name++) {
  300. case 'i':
  301. strcpy(buf,tn_int);
  302. buf = putptr(buf,ptr,ptrs);
  303. break;
  304. case 'l':
  305. strcpy(buf,tn_long);
  306. buf = putptr(buf,ptr,ptrs);
  307. break;
  308. case 's':
  309. strcpy(buf,tn_short);
  310. buf = putptr(buf,ptr,ptrs);
  311. break;
  312. case 'c':
  313. strcpy(buf,tn_char);
  314. buf = putptr(buf,ptr,ptrs);
  315. break;
  316. }
  317. case 'f':
  318. strcpy(buf,tn_float);
  319. buf = putptr(buf,ptr,ptrs);
  320. break;
  321. case 'd':
  322. strcpy(buf,tn_double);
  323. buf = putptr(buf,ptr,ptrs);
  324. break;
  325. case 'g':
  326. strcpy(buf,tn_longdouble);
  327. buf = putptr(buf,ptr,ptrs);
  328. break;
  329. case 'i':
  330. strcpy(buf,tn_int);
  331. buf = putptr(buf,ptr,ptrs);
  332. break;
  333. case 'l':
  334. strcpy(buf,tn_long);
  335. buf = putptr(buf,ptr,ptrs);
  336. break;
  337. case 's':
  338. strcpy(buf,tn_short);
  339. buf = putptr(buf,ptr,ptrs);
  340. break;
  341. case 'c':
  342. strcpy(buf,tn_char);
  343. buf = putptr(buf,ptr,ptrs);
  344. break;
  345. case 'v':
  346. strcpy(buf,tn_void);
  347. buf = putptr(buf,ptr,ptrs);
  348. break;
  349. case 'p':
  350. (*ptrs)[(*ptr)++] = 0;
  351. goto start;
  352. case 'r':
  353. (*ptrs)[(*ptr)++] = 1;
  354. goto start;
  355. case 'e':
  356. strcpy(buf,tn_ellipse);
  357. break;
  358. case '$':
  359. name--;
  360. return name;
  361. }
  362. return name;
  363. }
  364. /* Unmangle an entire C++ function */
  365. static char * unmangcppfunc(char *buf, char *name)
  366. {
  367. int ptr = 0;
  368. char ptrs[50];
  369. *buf++ = '(';
  370. while (*name && *name != '$') {
  371. name = unmang1(buf,name,&ptr,&ptrs);
  372. buf = buf+strlen(buf);
  373. if (*name && *name != '$')
  374. *buf++ = ',';
  375. else
  376. *buf++ = ')';
  377. }
  378. *buf=0;
  379. return buf;
  380. }
  381. #endif
  382. /* Name unmangling in general */
  383. void unmangle(char *buf, char *name)
  384. {
  385. if (name[0] == '_' && prm_cmangle) {
  386. strcpy(buf,&name[1]);
  387. }
  388. #ifdef CPLUSPLUS
  389. else 
  390. if (name[0] != '@')
  391. strcpy(buf,name);
  392. else {
  393. name++;
  394. while (*name != '$' && *name)
  395. *buf++ = *name++;
  396. if (*name) {
  397. name+=2;
  398. unmangcppfunc(buf,name);
  399. }
  400. else *buf++ = 0;
  401. }
  402. #endif
  403. }