PageRenderTime 87ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/js/lib/Socket.IO-node/support/expresso/deps/jscoverage/js/config/mkdepend/ifparser.c

http://github.com/onedayitwillmake/RealtimeMultiplayerNodeJs
C | 549 lines | 391 code | 86 blank | 72 comment | 121 complexity | f30a8546e956a485428846402ca567af MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, MPL-2.0-no-copyleft-exception, BSD-3-Clause
  1. /*
  2. * $Xorg: ifparser.c,v 1.3 2000/08/17 19:41:50 cpqbld Exp $
  3. *
  4. * Copyright 1992 Network Computing Devices, Inc.
  5. *
  6. * Permission to use, copy, modify, and distribute this software and its
  7. * documentation for any purpose and without fee is hereby granted, provided
  8. * that the above copyright notice appear in all copies and that both that
  9. * copyright notice and this permission notice appear in supporting
  10. * documentation, and that the name of Network Computing Devices may not be
  11. * used in advertising or publicity pertaining to distribution of the software
  12. * without specific, written prior permission. Network Computing Devices makes
  13. * no representations about the suitability of this software for any purpose.
  14. * It is provided ``as is'' without express or implied warranty.
  15. *
  16. * NETWORK COMPUTING DEVICES DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17. * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
  18. * IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE FOR ANY SPECIAL,
  19. * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  20. * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  21. * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  22. * PERFORMANCE OF THIS SOFTWARE.
  23. *
  24. * Author: Jim Fulton
  25. * Network Computing Devices, Inc.
  26. *
  27. * Simple if statement processor
  28. *
  29. * This module can be used to evaluate string representations of C language
  30. * if constructs. It accepts the following grammar:
  31. *
  32. * EXPRESSION := VALUE
  33. * | VALUE BINOP EXPRESSION
  34. * | VALUE '?' EXPRESSION ':' EXPRESSION
  35. *
  36. * VALUE := '(' EXPRESSION ')'
  37. * | '!' VALUE
  38. * | '-' VALUE
  39. * | '+' VALUE
  40. * | '~' VALUE
  41. * | 'defined' '(' variable ')'
  42. * | 'defined' variable
  43. * | # variable '(' variable-list ')'
  44. * | variable
  45. * | number
  46. *
  47. * BINOP := '*' | '/' | '%'
  48. * | '+' | '-'
  49. * | '<<' | '>>'
  50. * | '<' | '>' | '<=' | '>='
  51. * | '==' | '!='
  52. * | '&' | '^' | '|'
  53. * | '&&' | '||'
  54. *
  55. * The normal C order of precedence is supported.
  56. *
  57. *
  58. * External Entry Points:
  59. *
  60. * ParseIfExpression parse a string for #if
  61. */
  62. /* $XFree86: xc/config/makedepend/ifparser.c,v 3.11 2002/09/23 01:48:08 tsi Exp $ */
  63. #include "ifparser.h"
  64. #include <ctype.h>
  65. #include <stdlib.h>
  66. #include <string.h>
  67. /****************************************************************************
  68. Internal Macros and Utilities for Parser
  69. ****************************************************************************/
  70. #define DO(val) if (!(val)) return NULL
  71. #define CALLFUNC(ggg,fff) (*((ggg)->funcs.fff))
  72. #define SKIPSPACE(ccc) while (isspace(*ccc)) ccc++
  73. #define isvarfirstletter(ccc) (isalpha(ccc) || (ccc) == '_')
  74. static const char *
  75. parse_variable (IfParser *g, const char *cp, const char **varp)
  76. {
  77. SKIPSPACE (cp);
  78. if (!isvarfirstletter (*cp))
  79. return CALLFUNC(g, handle_error) (g, cp, "variable name");
  80. *varp = cp;
  81. /* EMPTY */
  82. for (cp++; isalnum(*cp) || *cp == '_'; cp++) ;
  83. return cp;
  84. }
  85. static const char *
  86. parse_number (IfParser *g, const char *cp, long *valp)
  87. {
  88. long base = 10;
  89. SKIPSPACE (cp);
  90. if (!isdigit(*cp))
  91. return CALLFUNC(g, handle_error) (g, cp, "number");
  92. *valp = 0;
  93. if (*cp == '0') {
  94. cp++;
  95. if ((*cp == 'x') || (*cp == 'X')) {
  96. base = 16;
  97. cp++;
  98. } else {
  99. base = 8;
  100. }
  101. }
  102. /* Ignore overflows and assume ASCII, what source is usually written in */
  103. while (1) {
  104. int increment = -1;
  105. if (base == 8) {
  106. if ((*cp >= '0') && (*cp <= '7'))
  107. increment = *cp++ - '0';
  108. } else if (base == 16) {
  109. if ((*cp >= '0') && (*cp <= '9'))
  110. increment = *cp++ - '0';
  111. else if ((*cp >= 'A') && (*cp <= 'F'))
  112. increment = *cp++ - ('A' - 10);
  113. else if ((*cp >= 'a') && (*cp <= 'f'))
  114. increment = *cp++ - ('a' - 10);
  115. } else { /* Decimal */
  116. if ((*cp >= '0') && (*cp <= '9'))
  117. increment = *cp++ - '0';
  118. }
  119. if (increment < 0)
  120. break;
  121. *valp = (*valp * base) + increment;
  122. }
  123. /* Skip trailing qualifiers */
  124. while (*cp == 'U' || *cp == 'u' || *cp == 'L' || *cp == 'l') cp++;
  125. return cp;
  126. }
  127. static const char *
  128. parse_character (IfParser *g, const char *cp, long *valp)
  129. {
  130. char val;
  131. SKIPSPACE (cp);
  132. if (*cp == '\\')
  133. switch (cp[1]) {
  134. case 'n': val = '\n'; break;
  135. case 't': val = '\t'; break;
  136. case 'v': val = '\v'; break;
  137. case 'b': val = '\b'; break;
  138. case 'r': val = '\r'; break;
  139. case 'f': val = '\f'; break;
  140. case 'a': val = '\a'; break;
  141. case '\\': val = '\\'; break;
  142. case '?': val = '\?'; break;
  143. case '\'': val = '\''; break;
  144. case '\"': val = '\"'; break;
  145. case 'x': val = (char) strtol (cp + 2, NULL, 16); break;
  146. default: val = (char) strtol (cp + 1, NULL, 8); break;
  147. }
  148. else
  149. val = *cp;
  150. while (*cp != '\'') cp++;
  151. *valp = (long) val;
  152. return cp;
  153. }
  154. static const char *
  155. parse_value (IfParser *g, const char *cp, long *valp)
  156. {
  157. const char *var, *varend;
  158. *valp = 0;
  159. SKIPSPACE (cp);
  160. if (!*cp)
  161. return cp;
  162. switch (*cp) {
  163. case '(':
  164. DO (cp = ParseIfExpression (g, cp + 1, valp));
  165. SKIPSPACE (cp);
  166. if (*cp != ')')
  167. return CALLFUNC(g, handle_error) (g, cp, ")");
  168. return cp + 1; /* skip the right paren */
  169. case '!':
  170. DO (cp = parse_value (g, cp + 1, valp));
  171. *valp = !(*valp);
  172. return cp;
  173. case '-':
  174. DO (cp = parse_value (g, cp + 1, valp));
  175. *valp = -(*valp);
  176. return cp;
  177. case '+':
  178. DO (cp = parse_value (g, cp + 1, valp));
  179. return cp;
  180. case '~':
  181. DO (cp = parse_value (g, cp + 1, valp));
  182. *valp = ~(*valp);
  183. return cp;
  184. case '#':
  185. DO (cp = parse_variable (g, cp + 1, &var));
  186. SKIPSPACE (cp);
  187. if (*cp != '(')
  188. return CALLFUNC(g, handle_error) (g, cp, "(");
  189. do {
  190. DO (cp = parse_variable (g, cp + 1, &var));
  191. SKIPSPACE (cp);
  192. } while (*cp && *cp != ')');
  193. if (*cp != ')')
  194. return CALLFUNC(g, handle_error) (g, cp, ")");
  195. *valp = 1; /* XXX */
  196. return cp + 1;
  197. case '\'':
  198. DO (cp = parse_character (g, cp + 1, valp));
  199. if (*cp != '\'')
  200. return CALLFUNC(g, handle_error) (g, cp, "'");
  201. return cp + 1;
  202. case 'd':
  203. if (strncmp (cp, "defined", 7) == 0 && !isalnum(cp[7])) {
  204. int paren = 0;
  205. int len;
  206. cp += 7;
  207. SKIPSPACE (cp);
  208. if (*cp == '(') {
  209. paren = 1;
  210. cp++;
  211. }
  212. DO (cp = parse_variable (g, cp, &var));
  213. len = cp - var;
  214. SKIPSPACE (cp);
  215. if (paren && *cp != ')')
  216. return CALLFUNC(g, handle_error) (g, cp, ")");
  217. *valp = (*(g->funcs.eval_defined)) (g, var, len);
  218. return cp + paren; /* skip the right paren */
  219. }
  220. /* fall out */
  221. }
  222. if (isdigit(*cp)) {
  223. DO (cp = parse_number (g, cp, valp));
  224. } else if (!isvarfirstletter(*cp))
  225. return CALLFUNC(g, handle_error) (g, cp, "variable or number");
  226. else {
  227. DO (cp = parse_variable (g, cp, &var));
  228. varend = cp;
  229. SKIPSPACE(cp);
  230. if (*cp != '(') {
  231. *valp = (*(g->funcs.eval_variable)) (g, var, varend - var);
  232. } else {
  233. do {
  234. long dummy;
  235. DO (cp = ParseIfExpression (g, cp + 1, &dummy));
  236. SKIPSPACE(cp);
  237. if (*cp == ')')
  238. break;
  239. if (*cp != ',')
  240. return CALLFUNC(g, handle_error) (g, cp, ",");
  241. } while (1);
  242. *valp = 1; /* XXX */
  243. cp++;
  244. }
  245. }
  246. return cp;
  247. }
  248. static const char *
  249. parse_product (IfParser *g, const char *cp, long *valp)
  250. {
  251. long rightval;
  252. DO (cp = parse_value (g, cp, valp));
  253. SKIPSPACE (cp);
  254. switch (*cp) {
  255. case '*':
  256. DO (cp = parse_product (g, cp + 1, &rightval));
  257. *valp = (*valp * rightval);
  258. break;
  259. case '/':
  260. DO (cp = parse_product (g, cp + 1, &rightval));
  261. *valp = (*valp / rightval);
  262. break;
  263. case '%':
  264. DO (cp = parse_product (g, cp + 1, &rightval));
  265. *valp = (*valp % rightval);
  266. break;
  267. }
  268. return cp;
  269. }
  270. static const char *
  271. parse_sum (IfParser *g, const char *cp, long *valp)
  272. {
  273. long rightval;
  274. DO (cp = parse_product (g, cp, valp));
  275. SKIPSPACE (cp);
  276. switch (*cp) {
  277. case '+':
  278. DO (cp = parse_sum (g, cp + 1, &rightval));
  279. *valp = (*valp + rightval);
  280. break;
  281. case '-':
  282. DO (cp = parse_sum (g, cp + 1, &rightval));
  283. *valp = (*valp - rightval);
  284. break;
  285. }
  286. return cp;
  287. }
  288. static const char *
  289. parse_shift (IfParser *g, const char *cp, long *valp)
  290. {
  291. long rightval;
  292. DO (cp = parse_sum (g, cp, valp));
  293. SKIPSPACE (cp);
  294. switch (*cp) {
  295. case '<':
  296. if (cp[1] == '<') {
  297. DO (cp = parse_shift (g, cp + 2, &rightval));
  298. *valp = (*valp << rightval);
  299. }
  300. break;
  301. case '>':
  302. if (cp[1] == '>') {
  303. DO (cp = parse_shift (g, cp + 2, &rightval));
  304. *valp = (*valp >> rightval);
  305. }
  306. break;
  307. }
  308. return cp;
  309. }
  310. static const char *
  311. parse_inequality (IfParser *g, const char *cp, long *valp)
  312. {
  313. long rightval;
  314. DO (cp = parse_shift (g, cp, valp));
  315. SKIPSPACE (cp);
  316. switch (*cp) {
  317. case '<':
  318. if (cp[1] == '=') {
  319. DO (cp = parse_inequality (g, cp + 2, &rightval));
  320. *valp = (*valp <= rightval);
  321. } else {
  322. DO (cp = parse_inequality (g, cp + 1, &rightval));
  323. *valp = (*valp < rightval);
  324. }
  325. break;
  326. case '>':
  327. if (cp[1] == '=') {
  328. DO (cp = parse_inequality (g, cp + 2, &rightval));
  329. *valp = (*valp >= rightval);
  330. } else {
  331. DO (cp = parse_inequality (g, cp + 1, &rightval));
  332. *valp = (*valp > rightval);
  333. }
  334. break;
  335. }
  336. return cp;
  337. }
  338. static const char *
  339. parse_equality (IfParser *g, const char *cp, long *valp)
  340. {
  341. long rightval;
  342. DO (cp = parse_inequality (g, cp, valp));
  343. SKIPSPACE (cp);
  344. switch (*cp) {
  345. case '=':
  346. if (cp[1] == '=')
  347. cp++;
  348. DO (cp = parse_equality (g, cp + 1, &rightval));
  349. *valp = (*valp == rightval);
  350. break;
  351. case '!':
  352. if (cp[1] != '=')
  353. break;
  354. DO (cp = parse_equality (g, cp + 2, &rightval));
  355. *valp = (*valp != rightval);
  356. break;
  357. }
  358. return cp;
  359. }
  360. static const char *
  361. parse_band (IfParser *g, const char *cp, long *valp)
  362. {
  363. long rightval;
  364. DO (cp = parse_equality (g, cp, valp));
  365. SKIPSPACE (cp);
  366. switch (*cp) {
  367. case '&':
  368. if (cp[1] != '&') {
  369. DO (cp = parse_band (g, cp + 1, &rightval));
  370. *valp = (*valp & rightval);
  371. }
  372. break;
  373. }
  374. return cp;
  375. }
  376. static const char *
  377. parse_bxor (IfParser *g, const char *cp, long *valp)
  378. {
  379. long rightval;
  380. DO (cp = parse_band (g, cp, valp));
  381. SKIPSPACE (cp);
  382. switch (*cp) {
  383. case '^':
  384. DO (cp = parse_bxor (g, cp + 1, &rightval));
  385. *valp = (*valp ^ rightval);
  386. break;
  387. }
  388. return cp;
  389. }
  390. static const char *
  391. parse_bor (IfParser *g, const char *cp, long *valp)
  392. {
  393. long rightval;
  394. DO (cp = parse_bxor (g, cp, valp));
  395. SKIPSPACE (cp);
  396. switch (*cp) {
  397. case '|':
  398. if (cp[1] != '|') {
  399. DO (cp = parse_bor (g, cp + 1, &rightval));
  400. *valp = (*valp | rightval);
  401. }
  402. break;
  403. }
  404. return cp;
  405. }
  406. static const char *
  407. parse_land (IfParser *g, const char *cp, long *valp)
  408. {
  409. long rightval;
  410. DO (cp = parse_bor (g, cp, valp));
  411. SKIPSPACE (cp);
  412. switch (*cp) {
  413. case '&':
  414. if (cp[1] != '&')
  415. return CALLFUNC(g, handle_error) (g, cp, "&&");
  416. DO (cp = parse_land (g, cp + 2, &rightval));
  417. *valp = (*valp && rightval);
  418. break;
  419. }
  420. return cp;
  421. }
  422. static const char *
  423. parse_lor (IfParser *g, const char *cp, long *valp)
  424. {
  425. long rightval;
  426. DO (cp = parse_land (g, cp, valp));
  427. SKIPSPACE (cp);
  428. switch (*cp) {
  429. case '|':
  430. if (cp[1] != '|')
  431. return CALLFUNC(g, handle_error) (g, cp, "||");
  432. DO (cp = parse_lor (g, cp + 2, &rightval));
  433. *valp = (*valp || rightval);
  434. break;
  435. }
  436. return cp;
  437. }
  438. static const char *
  439. parse_cond(IfParser *g, const char *cp, long *valp)
  440. {
  441. long trueval, falseval;
  442. DO (cp = parse_lor (g, cp, valp));
  443. SKIPSPACE (cp);
  444. switch (*cp) {
  445. case '?':
  446. DO (cp = parse_cond (g, cp + 1, &trueval));
  447. SKIPSPACE (cp);
  448. if (*cp != ':')
  449. return CALLFUNC(g, handle_error) (g, cp, ":");
  450. DO (cp = parse_cond (g, cp + 1, &falseval));
  451. *valp = (*valp ? trueval : falseval);
  452. break;
  453. }
  454. return cp;
  455. }
  456. /****************************************************************************
  457. External Entry Points
  458. ****************************************************************************/
  459. const char *
  460. ParseIfExpression (IfParser *g, const char *cp, long *valp)
  461. {
  462. return parse_cond (g, cp, valp);
  463. }