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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
parser.cpp
资源名称：Engine_v0.2.tar.gz　[点击查看]
上传用户：qccn516
上传日期：2013-05-02
资源大小：3382k
文件大小：15k
源码类别：

游戏引擎

开发平台：

Visual C++

parser.cpp：源码内容
  1. /* Parser
  2.  *
  3.  * Copyright (C) 2003-2004, Alexander Zaprjagaev <frustum@frustum.org>
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  20. #include "engine.h"
  21. #include "parser.h"
  23. float Parser::variables[26];
  25. /*
  26.  */
  27. Parser::Parser(const char *name) : data(NULL) {
  29. FILE *file = fopen(name,"r");
  30. if(!file) {
  31. fprintf(stderr,"Parse::Parse(): error open "%s" filen",name);
  32. return;
  33. }
  34. fseek(file,0,SEEK_END);
  35. int size = ftell(file);
  36. fseek(file,0,SEEK_SET);
  37. data = new char[size + 1];
  38. memset(data,0,sizeof(char) * (size + 1));
  39. fread(data,sizeof(char),size,file);
  40. fclose(file);
  42. char *s = data;
  43. char *d = data;
  44. int define_ok[32];
  45. int depth = 0;
  47. while(*s) {
  49. // #ifdef, #ifndef, #else, #endif preprocessor
  50. if(*s == '#' && !strncmp(s + 1,"ifdef",5)) {
  51. char define[1024];
  52. sscanf(s + 6,"%s",define);
  53. while(*s != '' && *s != 'n') s++;
  54. if(Engine::isDefine(define) == 1) define_ok[depth++] = 1;
  55. else define_ok[depth++] = 0;
  56. } else if(*s == '#' && !strncmp(s + 1,"ifndef",6)) {
  57. char define[1024];
  58. sscanf(s + 7,"%s",define);
  59. while(*s != '' && *s != 'n') s++;
  60. if(Engine::isDefine(define) == 0) define_ok[depth++] = 1;
  61. else define_ok[depth++] = 0;
  62. } else if(*s == '#' && !strncmp(s + 1,"else",4)) {
  63. while(*s != '' && *s != 'n') s++;
  64. define_ok[depth - 1] = !define_ok[depth - 1];
  65. } else if(*s == '#' && !strncmp(s + 1,"endif",5)) {
  66. while(*s != '' && *s != 'n') s++;
  67. depth--;
  68. }
  70. // C-like comments // and /* */
  71. else if(*s == '/' && *(s + 1) == '/') {
  72. while(*s && *s != 'n') s++;
  73. while(*s && *s == 'n') s++;
  74. *d++ = 'n';
  75. } else if(*s == '/' && *(s + 1) == '*') {
  76. while(*s && (*s != '*' || *(s + 1) != '/')) s++;
  77. s += 2;
  78. while(*s && *s == 'n') s++;
  79. *d++ = 'n';
  80. }
  82. // blocks
  83. else if(*s == '<' && isalpha(*(s + 1))) {
  84. int i = 0;
  85. for(; i < depth; i++) if(define_ok[i] == 0) break;
  86. if(i == depth) {
  87. while(d > data && *(d - 1) == 'n') d--;
  88. *d++ = *s = '';
  89. char *name = ++s;
  90. while(*s && *s != '>') s++;
  91. *s++ = '';
  92. while(*s && strchr(" tnr",*s)) s++;
  93. Block b;
  94. b.pointer = d;
  95. b.use = 0;
  96. blocks[name] = b;
  97. } else {
  98. s++;
  99. }
  100. }
  102. else {
  103. if(depth == 0) *d++ = *s++;
  104. else {
  105. int i = 0;
  106. for(; i < depth; i++) if(define_ok[i] == 0) break;
  107. if(i == depth) *d++ = *s++;
  108. else s++;
  109. }
  110. }
  111. }
  112. while(d > data && *(d - 1) == 'n') d--;
  113. *d = '';
  114. }
  116. Parser::~Parser() {
  117. for(std::map<std::string,Block>::iterator it = blocks.begin(); it != blocks.end(); it++) {
  118. if(!it->second.use) fprintf(stderr,"Parser::~Parser(): warning unused block "%s"n",it->first.c_str());
  119. }
  120. blocks.clear();
  121. delete data;
  122. }
  124. /*
  125.  */
  126. char *Parser::get(const char *name) {
  127. std::map<std::string,Block>::iterator it = blocks.find(name);
  128. if(it == blocks.end()) return NULL;
  129. it->second.use = 1;
  130. char *ret = it->second.pointer;
  131. while(*ret && strchr(" tnr",*ret)) ret++;
  132. char *s = ret + strlen(ret) - 1;
  133. while(s > ret && strchr(" tnr",*s)) s--;
  134. s++;
  135. *s = '';
  136. return ret;
  137. }
  139. /*****************************************************************************/
  140. /*                                                                           */
  141. /* read string                                                               */
  142. /*                                                                           */
  143. /*****************************************************************************/
  145. int Parser::read_string(const char *str,char *dest) {
  146. const char *s = str;
  147. char *d = dest;
  148. while(*s && strchr(" t",*s)) s++;
  149. if(*s == '"') {
  150. s++;
  151. while(*s && *s != '"') *d++ = *s++;
  152. s++;
  153. *d = '';
  154. } else {
  155. while(*s && !strchr(" t",*s)) *d++ = *s++;
  156. *d = '';
  157. }
  158. return s - str;
  159. }
  161. /*****************************************************************************/
  162. /*                                                                           */
  163. /* expressions                                                               */
  164. /*                                                                           */
  165. /*****************************************************************************/
  167. /*
  168.  */
  169. int Parser::priority(char op) {
  170. if(strchr("sScCtTleqfr",op)) return 4;
  171. if(strchr("*/%",op)) return 3;
  172. if(strchr("+-",op)) return 2;
  173. if(strchr("<>!=&|",op)) return 1;
  174. return 0;
  175. }
  177. /*
  178.  */
  179. float Parser::expression(const char *str,const char *variable,float value) {
  180. static struct {
  181. char op;
  182. float num;
  183. } stack[1024];
  184. int stack_depth = 0;
  185. static char stack_op[1024];
  186. int stack_op_depth = 0;
  187. const char *s = str;
  188. int brackets = 0;
  189. while(*s) {
  190. if(*s == '(') brackets++;
  191. else if(*s == ')') brackets--;
  192. s++;
  193. }
  194. if(brackets != 0) {
  195. fprintf(stderr,"Paser::expression(): parse error before '%c'n",brackets > 0 ? '(' : ')');
  196. return 0.0;
  197. }
  198. s = str;
  199. while(*s) {
  200. if(*s == '(') {
  201. stack_op[stack_op_depth++] = *s++;
  202. }
  203. else if(*s == ')') {
  204. while(stack_op_depth > 0 && stack_op[--stack_op_depth] != '(') stack[stack_depth++].op = stack_op[stack_op_depth];
  205. s++;
  206. }
  207. else if(strchr("<>+-*/%",*s)) {
  208. while(stack_op_depth > 0 && priority(*s) <= priority(stack_op[stack_op_depth - 1])) {
  209. stack[stack_depth++].op = stack_op[--stack_op_depth];
  210. }
  211. stack_op[stack_op_depth++] = *s++;
  212. }
  213. else if(!strncmp("==",s,2)) {
  214. stack_op[stack_op_depth++] = '=';
  215. s += 2;
  216. }
  217. else if(!strncmp("!=",s,2)) {
  218. stack_op[stack_op_depth++] = '!';
  219. s += 2;
  220. }
  221. else if(!strncmp("&&",s,2)) {
  222. stack_op[stack_op_depth++] = '&';
  223. s += 2;
  224. }
  225. else if(!strncmp("||",s,2)) {
  226. stack_op[stack_op_depth++] = '|';
  227. s += 2;
  228. }
  229. else if(!strncmp("sin",s,3)) {
  230. stack_op[stack_op_depth++] = 's';
  231. s += 3;
  232. }
  233. else if(!strncmp("asin",s,4)) {
  234. stack_op[stack_op_depth++] = 'S';
  235. s += 4;
  236. }
  237. else if(!strncmp("cos",s,3)) {
  238. stack_op[stack_op_depth++] = 'c';
  239. s += 3;
  240. }
  241. else if(!strncmp("acos",s,4)) {
  242. stack_op[stack_op_depth++] = 'C';
  243. s += 4;
  244. }
  245. else if(!strncmp("tan",s,3)) {
  246. stack_op[stack_op_depth++] = 't';
  247. s += 3;
  248. }
  249. else if(!strncmp("atan",s,4)) {
  250. stack_op[stack_op_depth++] = 'T';
  251. s += 4;
  252. }
  253. else if(!strncmp("log",s,3)) {
  254. stack_op[stack_op_depth++] = 'l';
  255. s += 3;
  256. }
  257. else if(!strncmp("exp",s,3)) {
  258. stack_op[stack_op_depth++] = 'e';
  259. s += 3;
  260. }
  261. else if(!strncmp("sqrt",s,4)) {
  262. stack_op[stack_op_depth++] = 'q';
  263. s += 4;
  264. }
  265. else if(!strncmp("fabs",s,4)) {
  266. stack_op[stack_op_depth++] = 'f';
  267. s += 4;
  268. }
  269. else if(!strncmp("rand",s,4)) {
  270. stack_op[stack_op_depth++] = 'r';
  271. s += 4;
  272. }
  273. else if(strchr("0123456789.",*s)) {
  274. char buf[1024];
  275. char *b = buf;
  276. *b++ = *s++;
  277. while(*s && strchr("0123456789.",*s)) *b++ = *s++;
  278. *b = '';
  279. stack[stack_depth].op = 'n';
  280. stack[stack_depth++].num = atof(buf);
  281. }
  282. else if(variable && !strncmp(variable,s,strlen(variable))) {
  283. stack[stack_depth].op = 'n';
  284. stack[stack_depth++].num = value;
  285. s += 4;
  286. }
  287. else if(!variable && *s == '$') {
  288. s++;
  289. if(!isalpha(*s)) {
  290. fprintf(stderr,"Paser::expression(): unknown variable "%c"n",*s);
  291. return 0.0;
  292. }
  293. stack[stack_depth].op = 'n';
  294. stack[stack_depth++].num = variables[tolower(*s++) - 'a'];
  295. }
  296. else if(strchr(" tnr",*s)) s++;
  297. else {
  298. fprintf(stderr,"Paser::expression(): unknown token "%s"n",s);
  299. return 0.0;
  300. }
  301. }
  302. while(stack_op_depth--) stack[stack_depth++].op = stack_op[stack_op_depth];
  303. for(int tries = 0; tries < 1024; tries++) {
  304. int end = 0;
  305. for(int i = 0, a = -1, b = -1, num = 0; i < stack_depth; i++) {
  306. if(!stack[i].op) continue;
  307. end++;
  308. if(num >= 1 && strchr("sScCtTleqfr",stack[i].op)) {
  309. int c = a;
  310. if(b != -1) c = b;
  311. switch(stack[i].op) {
  312. case 's': stack[i].num = sin(stack[c].num); break;
  313. case 'S': stack[i].num = asin(stack[c].num); break;
  314. case 'c': stack[i].num = cos(stack[c].num); break;
  315. case 'C': stack[i].num = acos(stack[c].num); break;
  316. case 't': stack[i].num = tan(stack[c].num); break;
  317. case 'T': stack[i].num = atan(stack[c].num); break;
  318. case 'l': stack[i].num = log(stack[c].num); break;
  319. case 'e': stack[i].num = exp(stack[c].num); break;
  320. case 'q': stack[i].num = sqrt(stack[c].num); break;
  321. case 'f': stack[i].num = fabs(stack[c].num); break;
  322. case 'r': stack[i].num = rand() / (float)RAND_MAX * stack[c].num; break;
  323. }
  324. stack[i].op = 'n';
  325. stack[c].op = 0;
  326. end += 10;
  327. break;
  328. }
  329. else if(num >= 2 && strchr("<>!=&|+-*/%",stack[i].op)) {
  330. switch(stack[i].op) {
  331. case '<': stack[i].num = stack[a].num < stack[b].num; break;
  332. case '>': stack[i].num = stack[a].num > stack[b].num; break;
  333. case '=': stack[i].num = stack[a].num == stack[b].num; break;
  334. case '!': stack[i].num = stack[a].num != stack[b].num; break;
  335. case '&': stack[i].num = stack[a].num && stack[b].num; break;
  336. case '|': stack[i].num = stack[a].num || stack[b].num; break;
  337. case '+': stack[i].num = stack[a].num + stack[b].num; break;
  338. case '-': stack[i].num = stack[a].num - stack[b].num; break;
  339. case '*': stack[i].num = stack[a].num * stack[b].num; break;
  340. case '/': stack[i].num = stack[a].num / stack[b].num; break;
  341. case '%': stack[i].num = (int)stack[a].num % (int)stack[b].num; break;
  342. }
  343. stack[i].op = 'n';
  344. stack[a].op = stack[b].op = 0;
  345. break;
  346. }
  347. else if(num == 1 && strchr("!+-",stack[i].op)) {
  348. if(stack[i].op == '!') stack[a].num = !stack[a].num;
  349. if(stack[i].op == '-') stack[a].num = -stack[a].num;
  350. stack[i].op = 0;
  351. end += 10;
  352. break;
  353. }
  354. else if(stack[i].op == 'n') {
  355. switch(num++) {
  356. case 0: a = i; break;
  357. case 1: b = i; break;
  358. default: a = b; b = i; break;
  359. }
  360. }
  361. else num = 0;
  362. }
  363. if(end < 3) {
  364. for(int i = 0; i < stack_depth; i++) {
  365. if(stack[i].op == 'n') return stack[i].num;
  366. }
  367. }
  368. }
  369. return 0.0;
  370. }
  372. /*****************************************************************************/
  373. /*                                                                           */
  374. /* simple interpreter                                                        */
  375. /*                                                                           */
  376. /*****************************************************************************/
  378. /*
  379.  */
  380. int Parser::read_token(const char *src,char *dest) {
  381. const char *s = src;
  382. int brackets_0 = 0;
  383. int brackets_1 = 0;
  384. while(*s) {
  385. if(*s == '(') brackets_0++;
  386. else if(*s == ')' && --brackets_0 < 0) break;
  387. else if(*s == '{') brackets_1++;
  388. else if(*s == '}' && --brackets_1 < 0) break;
  389. else if(*s == ';') break;
  390. if(dest) *dest++ = *s++;
  391. else s++;
  392. }
  393. if(dest) *dest = '';
  394. return s - src;
  395. }
  397. /*
  398.  */
  399. int Parser::interpret_eq(const char *src) {
  400. const char *s = src;
  402. while(*s && strchr(" t",*s)) s++;
  403. if(*s++ != '$') throw("Parser::interpret_eq(): missing '$'");
  405. char var = *s++;
  406. if(!isalpha(var)) throw("Parser::interpret_eq(): unknown variable");
  407. var = tolower(var);
  409. int op = 0;
  410. while(*s && strchr(" t",*s)) s++;
  411. if(!strncmp("=",s,1)) { s++; op = 0; }
  412. else if(!strncmp("+=",s,2)) { s += 2; op = 1; }
  413. else if(!strncmp("-=",s,2)) { s += 2; op = 2; }
  414. else if(!strncmp("++",s,2)) { s += 2; op = 3; }
  415. else if(!strncmp("--",s,2)) { s += 2; op = 4; }
  416. else throw("Parser::interpret_eq(): missing '='");
  418. char exp[1024];
  419. s += read_token(s,exp);
  420. if(*s) *s++;
  422. if(op == 0) variables[var - 'a'] = expression(exp);
  423. else if(op == 1) variables[var - 'a'] += expression(exp);
  424. else if(op == 2) variables[var - 'a'] -= expression(exp);
  425. else if(op == 3) variables[var - 'a'] += 1.0f;
  426. else if(op == 3) variables[var - 'a'] -= 1.0f;
  428. return s - src;
  429. }
  431. /*
  432.  */
  433. int Parser::interpret_if(const char *src,char **dest) {
  434. const char *s = src + 2;
  435. char condition[1024];
  437. while(*s && strchr(" t",*s)) s++;
  438. if(*s++ != '(') throw("Parser::interpret_if(): can`t find '('");
  440. s += read_token(s,condition);
  441. if(*s++ != ')') throw("Parser::interpret_if(): can`t find ')'");
  443. while(*s && strchr(" t",*s)) s++;
  444. if(*s++ != '{') throw("Parser::interpret_if(): can`t find '{'");
  446. if(expression(condition)) {
  447. s += interpret_main(s,dest);
  448. while(*s && strchr(" t",*s)) s++;
  449. if(!strncmp("else",s,4)) {
  450. s += 4;
  451. while(*s && strchr(" t",*s)) s++;
  452. if(*s++ != '{') throw("Parser::interpret_if(): can`t find '{'");
  453. s += read_token(s,NULL);
  454. if(*s++ != '}') throw("Parser::interpret_if(): can`t find '}'");
  455. }
  456. } else {
  457. s += read_token(s,NULL);
  458. if(*s++ != '}') throw("Parser::interpret_if(): can`t find '}'");
  459. while(*s && strchr(" t",*s)) s++;
  460. if(!strncmp("else",s,4)) {
  461. s += 4;
  462. while(*s && strchr(" t",*s)) s++;
  463. if(*s++ != '{') throw("Parser::interpret_if(): can`t find '{'");
  464. s += interpret_main(s,dest);
  465. }
  466. }
  467. return s - src;
  468. }
  470. /*
  471.  */
  472. int Parser::interpret_for(const char *src,char **dest) {
  473. const char *s = src + 3;
  474. char condition[1024];
  475. char addition[1024];
  477. while(*s && strchr(" t",*s)) s++;
  478. if(*s++ != '(') throw("Parser::interpret_for(): can`t find '('");
  479. s += interpret_eq(s);
  481. s += read_token(s,condition);
  482. if(*s++ != ';') throw("Parser::interpret_for(): can`t find ';'");
  484. s += read_token(s,addition);
  485. if(*s++ != ')') throw("Parser::interpret_for(): can`t find ')'");
  487. while(*s && strchr(" t",*s)) s++;
  488. if(*s++ != '{') throw("Parser::interpret_for(): can`t find '{'");
  490. const char *begin = NULL;
  491. do {
  492. if(!begin) {
  493. begin = s;
  494. s += interpret_main(begin,dest);
  495. } else interpret_main(begin,dest);
  496. interpret_eq(addition);
  497. } while(expression(condition));
  498. return s - src;
  499. }
  501. /*
  502.  */
  503. int Parser::interpret_main(const char *src,char **dest) {
  504. const char *s = src;
  505. int brackets = 0;
  506. int new_word = 1;
  507. while(*s) {
  508. if(new_word && !strncmp("if",s,2) && strchr("( t",*(s + 2))) {
  509. s += interpret_if(s,dest);
  510. }
  511. else if(new_word && !strncmp("for",s,3) && strchr("( t",*(s + 3))) {
  512. s += interpret_for(s,dest);
  513. }
  514. else if(*s == '$' && (*(s + 1) == '(' || isalpha(*(s + 1)))) {
  515. if(*(s + 1) == '(') {
  516. s += 2;
  517. char exp[1024];
  518. s += read_token(s,exp);
  519. if(*s) *s++;
  520. (*dest) += sprintf(*dest,"%g",expression(exp));
  521. } else {
  522. const char *e = ++s;
  523. while(*e && !strchr("=(){};nr",*e)) e++;
  524. if(*e == '=') s += interpret_eq(s - 1);
  525. else (*dest) += sprintf(*dest,"%g",variables[tolower(*s++ - 'a')]);
  526. }
  527. } else {
  528. if(*s == '{') brackets++;
  529. else if(*s == '}') {
  530. brackets--;
  531. if(brackets < 0) {
  532. s++;
  533. break;
  534. }
  535. }
  536. if(strchr(" tnr",*s)) new_word = 1;
  537. else new_word = 0;
  538. *(*dest)++ = *s++;
  539. }
  540. }
  541. return s - src;
  542. }
  544. /*
  545.  */
  546. const char *Parser::interpret(const char *src) {
  547. if(!src) return NULL;
  549. char *dest = new char[2 * 1024 * 1024]; // 2 Mb
  551. try {
  552. char *d = dest;
  553. interpret_main(src,&d);
  554. *d = '';
  555. }
  556. catch(const char *msg) {
  557. fprintf(stderr,"%sn",msg);
  558. delete dest;
  559. return NULL;
  560. }
  562. return dest;
  563. }