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

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

编译器/解释器

开发平台：

Others

INTEXPR.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.  * Evaluate an expression which should be known at compile time.
  24.  * This uses recursive descent.  It is roughly analogous to the
  25.  * primary expression handler except it returns a value rather than
  26.  * an enode list
  27.  */
  28. #include        <stdio.h>
  29. #include        "expr.h"
  30. #include        "c.h"
  31. #include "errors.h"
  33. extern enum e_sym lastst;
  34. extern char lastid[];
  35. extern long ival;
  36. extern TABLE defsyms;
  37. extern TYP stdint, stdchar,stduns, stdunsigned, stdlong, *head;
  38. extern int prm_cmangle;
  39. static long ieprimary(TYP **tp)   
  40. /*
  41.  * PRimary integer
  42.  *    defined(MACRO)
  43.  *    id
  44.  *    iconst
  45.  *    (cast )intexpr
  46.  *    (intexpr)
  47.  */
  48. {       long     temp=0;
  49.         SYM     *sp;
  50. if (tp)
  51. *tp = &stdint;
  52.         if(lastst == id) {
  53. char *lid = lastid;
  54. if (prm_cmangle)
  55. lid++;
  56.                  sp = gsearch(lastid);
  57.                  if(sp == NULL) {
  58. gensymerror(ERR_UNDEFINED,lastid);
  59.                         getsym();
  60.                         return 0;
  61.                         }
  62.                  if(sp->storage_class != sc_const && sp->tp->type != bt_enum) {
  63.                         generror(ERR_NEEDCONST,0,0);
  64.                         getsym();
  65.                         return 0;
  66.                         }
  67.                  getsym();
  68.                  return sp->value.i;
  69.         }
  70.         else if(lastst == iconst) {
  71.                 temp = ival;
  72.                 getsym();
  73.                 return temp;
  74.                 }
  75.         else if(lastst == lconst) {
  76. if (tp)
  77. *tp = &stdlong;
  78.                 temp = ival;
  79.                 getsym();
  80.                 return temp;
  81.                 }
  82.         else if(lastst == iuconst) {
  83. if (tp)
  84. *tp = &stduns;
  85.                 temp = ival;
  86.                 getsym();
  87.                 return temp;
  88.                 }
  89.         else if(lastst == luconst) {
  90. if (tp)
  91. *tp = &stdunsigned;
  92.                 temp = ival;
  93.                 getsym();
  94.                 return temp;
  95.                 }
  96.         else if(lastst == cconst) {
  97. if (tp)
  98. *tp = &stdchar;
  99.                 temp = ival;
  100.                 getsym();
  101.                 return temp;
  102.                 }
  103. else if (lastst == openpa) {
  104. getsym();
  105. if (castbegin(lastst)) {
  106. decl(0);
  107. decl1();
  108. needpunc(closepa,0);
  109. if (tp)
  110.   *tp = head;
  111. return intexpr(0);
  112. }
  113. else {
  114.    temp = intexpr(tp);
  115. return(temp);
  116. }
  117. }
  118.         getsym();
  119.         generror(ERR_NEEDCONST,0,0);
  120.         return 0;
  121. }
  122. /*
  123.  * Integer unary
  124.  *   - unary
  125.  *   ! unary
  126.  *   ~unary
  127.  *   primary
  128.  */
  129. static long ieunary(TYP **tp)
  130. {
  131. long temp;
  132. switch (lastst) {
  133. case minus:
  134. getsym();
  135. temp = -ieunary(tp);
  136. break;
  137. case not:
  138. getsym();
  139. temp = !ieunary(tp);
  140. break;
  141. case compl:
  142. getsym();
  143. temp = ~ieunary(tp);
  144. break;
  145. default:
  146. temp = ieprimary(tp);
  147. break;
  148. }
  149. return(temp);
  150. }
  151. static long iemultops(TYP **tp)
  152. /* Multiply ops */
  153. {
  154. long val1 = ieunary(tp),val2;
  155. while (lastst == star || lastst == divide || lastst == modop) {
  156. TYP *tp1;
  157. long oper = lastst;
  158. getsym();
  159. val2 = ieunary(&tp1);
  160. switch(oper) {
  161. case star:
  162. val1 = val1 * val2;
  163. break;
  164. case divide:
  165. val1 = val1 / val2;
  166. break;
  167. case modop:
  168. val1 = val1 % val2;
  169. break;
  170. }
  171. if (tp)
  172. *tp = maxsize(*tp,tp1);
  173. }
  174. return(val1);
  175. }
  176. static long ieaddops(TYP **tp)
  177. /* Add ops */
  178. {
  179. long val1 = iemultops(tp),val2;
  180. while (lastst == plus || lastst == minus) {
  181. long oper = lastst;
  182. TYP *tp1;
  183. getsym();
  184. val2 = iemultops(&tp1);
  185. if (oper == plus) 
  186. val1 = val1 + val2;
  187. else
  188. val1 = val1 - val2;
  189. if (tp)
  190. *tp = maxsize(*tp,tp1);
  191. }
  192. return(val1);
  193. }
  194. static long ieshiftops(TYP **tp)
  195. /* Shift ops */
  196. {
  197. long val1 = ieaddops(tp), val2;
  198. while (lastst == lshift || lastst == rshift) {
  199. long oper = lastst;
  200. TYP *tp1;
  201. getsym();
  202. val2 = ieaddops(&tp1);
  203. if (oper == lshift)
  204. val1 <<= val2;
  205. else
  206. val1 >>= val2;
  207. if (tp)
  208. *tp = maxsize(*tp,tp1);
  209. }
  210. return(val1);
  211. }
  212. static long ierelation(TYP **tp)
  213. /* non-eq relations */
  214. {
  215. long val1 = ieshiftops(tp), val2;
  216. while (lastst == lt || lastst == gt || lastst == leq || lastst == geq) {
  217. long oper = lastst;
  218. TYP *tp1;
  219. getsym();
  220. val2 = ieshiftops(&tp1);
  221. switch(oper) {
  222. case lt:
  223. val1 = val1 < val2;
  224. break;
  225. case gt:
  226. val1 = val1 > val2;
  227. break;
  228. case leq:
  229. val1 = val1 <= val2;
  230. break;
  231. case geq:
  232. val1 = val1 >= val2;
  233. break;
  234. }
  235. if (tp)
  236. *tp = maxsize(*tp,tp1);
  237. }
  238. return(val1);
  239. }
  240. static long ieequalops(TYP **tp)
  241. /* eq relations */
  242. {
  243. long val1 = ierelation(tp),val2;
  244. while (lastst == eq || lastst == neq) {
  245. long oper = lastst;
  246. TYP *tp1;
  247. getsym();
  248. val2 = ierelation(&tp1);
  249. if (oper == neq)
  250. val1 = val1 != val2;
  251. else
  252. val1 = val1 == val2;
  253. if (tp)
  254. *tp = maxsize(*tp,tp1);
  255. }
  256. return(val1);
  257. }
  258. static long ieandop(TYP **tp)
  259. /* and op */
  260. {
  261. long val1 = ieequalops(tp),val2;
  262. while (lastst == and) {
  263. TYP *tp1;
  264. getsym();
  265. val2 = ieequalops(&tp1);
  266. val1 = val1 & val2;
  267. if (tp)
  268. *tp = maxsize(*tp,tp1);
  269. }
  270. return(val1);
  271. }
  272. static long iexorop(TYP **tp)
  273. /* xor op */
  274. {
  275. long val1 = ieandop(tp),val2;
  276. while (lastst == uparrow) {
  277. TYP *tp1;
  278. getsym();
  279. val2 = ieandop(&tp1);
  280. val1 = val1 ^ val2;
  281. if (tp)
  282. *tp = maxsize(*tp,tp1);
  283. }         
  284. return(val1);
  285. }
  286. static long ieorop(TYP **tp)
  287. /* or op */
  288. {
  289. long val1 = iexorop(tp),val2;
  290. while (lastst == or) {
  291. TYP *tp1;
  292. getsym();
  293. val2 = iexorop(&tp1);
  294. val1 = val1 | val2;
  295. if (tp)
  296. *tp = maxsize(*tp,tp1);
  297. }
  298. return(val1);
  299. }
  300. static long ielandop(TYP **tp)
  301. /* logical and op */
  302. {
  303. long val1 = ieorop(tp),val2;
  304. while (lastst == land) {
  305. TYP *tp1;
  306. getsym();
  307. val2 = ieorop(&tp1);
  308. val1 = val1 && val2;
  309. if (tp)
  310. *tp = maxsize(*tp,tp1);
  311. }
  312. return(val1);
  313. }
  314. static long ielorop(TYP **tp)
  315. /* logical or op */
  316. {
  317. long val1 = ielandop(tp),val2;
  318. while (lastst == lor) {
  319. TYP *tp1;
  320. getsym();
  321. val2 = ielandop(&tp1);
  322. val1 = val1 || val2;
  323. if (tp)
  324. *tp = maxsize(*tp,tp1);
  325. }
  326. return(val1);
  327. }
  328. static long iecondop(TYP **tp)
  329. /* Hook op */
  330. {
  331. long val1 = ielorop(tp),val2, val3;
  332. if (lastst == hook) {
  333. TYP *tp1, *tp2;
  334. getsym();
  335. val2 = iecondop(&tp1);
  336. needpunc(colon,0);
  337. val3 = iecondop(&tp2);
  338. if (val1)
  339. val1 = val2;
  340. else
  341. val1 = val3;
  342. if (tp)
  343. *tp = maxsize(tp2,tp1);
  344. }
  345. return(val1);
  346. }
  347. long intexpr(TYP **tp)
  348. /* Integer expressions */
  349. {
  350. return(iecondop(tp));
  351. }