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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
preproc.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：764k
源码类别：

数据库系统

开发平台：

Unix_Linux

preproc.c：源码内容
  1. case 963:
  2. #line 4375 "preproc.y"
  3. { yyval.str = make1_str("cache"); ;
  4.     break;}
  5. case 964:
  6. #line 4376 "preproc.y"
  7. { yyval.str = make1_str("committed"); ;
  8.     break;}
  9. case 965:
  10. #line 4377 "preproc.y"
  11. { yyval.str = make1_str("createdb"); ;
  12.     break;}
  13. case 966:
  14. #line 4378 "preproc.y"
  15. { yyval.str = make1_str("createuser"); ;
  16.     break;}
  17. case 967:
  18. #line 4379 "preproc.y"
  19. { yyval.str = make1_str("cycle"); ;
  20.     break;}
  21. case 968:
  22. #line 4380 "preproc.y"
  23. { yyval.str = make1_str("database"); ;
  24.     break;}
  25. case 969:
  26. #line 4381 "preproc.y"
  27. { yyval.str = make1_str("delimiters"); ;
  28.     break;}
  29. case 970:
  30. #line 4382 "preproc.y"
  31. { yyval.str = make1_str("double"); ;
  32.     break;}
  33. case 971:
  34. #line 4383 "preproc.y"
  35. { yyval.str = make1_str("each"); ;
  36.     break;}
  37. case 972:
  38. #line 4384 "preproc.y"
  39. { yyval.str = make1_str("encoding"); ;
  40.     break;}
  41. case 973:
  42. #line 4385 "preproc.y"
  43. { yyval.str = make1_str("exclusive"); ;
  44.     break;}
  45. case 974:
  46. #line 4386 "preproc.y"
  47. { yyval.str = make1_str("forward"); ;
  48.     break;}
  49. case 975:
  50. #line 4387 "preproc.y"
  51. { yyval.str = make1_str("function"); ;
  52.     break;}
  53. case 976:
  54. #line 4388 "preproc.y"
  55. { yyval.str = make1_str("handler"); ;
  56.     break;}
  57. case 977:
  58. #line 4389 "preproc.y"
  59. { yyval.str = make1_str("increment"); ;
  60.     break;}
  61. case 978:
  62. #line 4390 "preproc.y"
  63. { yyval.str = make1_str("index"); ;
  64.     break;}
  65. case 979:
  66. #line 4391 "preproc.y"
  67. { yyval.str = make1_str("inherits"); ;
  68.     break;}
  69. case 980:
  70. #line 4392 "preproc.y"
  71. { yyval.str = make1_str("insensitive"); ;
  72.     break;}
  73. case 981:
  74. #line 4393 "preproc.y"
  75. { yyval.str = make1_str("instead"); ;
  76.     break;}
  77. case 982:
  78. #line 4394 "preproc.y"
  79. { yyval.str = make1_str("isnull"); ;
  80.     break;}
  81. case 983:
  82. #line 4395 "preproc.y"
  83. { yyval.str = make1_str("key"); ;
  84.     break;}
  85. case 984:
  86. #line 4396 "preproc.y"
  87. { yyval.str = make1_str("language"); ;
  88.     break;}
  89. case 985:
  90. #line 4397 "preproc.y"
  91. { yyval.str = make1_str("lancompiler"); ;
  92.     break;}
  93. case 986:
  94. #line 4398 "preproc.y"
  95. { yyval.str = make1_str("location"); ;
  96.     break;}
  97. case 987:
  98. #line 4399 "preproc.y"
  99. { yyval.str = make1_str("match"); ;
  100.     break;}
  101. case 988:
  102. #line 4400 "preproc.y"
  103. { yyval.str = make1_str("maxvalue"); ;
  104.     break;}
  105. case 989:
  106. #line 4401 "preproc.y"
  107. { yyval.str = make1_str("minvalue"); ;
  108.     break;}
  109. case 990:
  110. #line 4402 "preproc.y"
  111. { yyval.str = make1_str("mode"); ;
  112.     break;}
  113. case 991:
  114. #line 4403 "preproc.y"
  115. { yyval.str = make1_str("next"); ;
  116.     break;}
  117. case 992:
  118. #line 4404 "preproc.y"
  119. { yyval.str = make1_str("nocreatedb"); ;
  120.     break;}
  121. case 993:
  122. #line 4405 "preproc.y"
  123. { yyval.str = make1_str("nocreateuser"); ;
  124.     break;}
  125. case 994:
  126. #line 4406 "preproc.y"
  127. { yyval.str = make1_str("nothing"); ;
  128.     break;}
  129. case 995:
  130. #line 4407 "preproc.y"
  131. { yyval.str = make1_str("notnull"); ;
  132.     break;}
  133. case 996:
  134. #line 4408 "preproc.y"
  135. { yyval.str = make1_str("of"); ;
  136.     break;}
  137. case 997:
  138. #line 4409 "preproc.y"
  139. { yyval.str = make1_str("oids"); ;
  140.     break;}
  141. case 998:
  142. #line 4410 "preproc.y"
  143. { yyval.str = make1_str("only"); ;
  144.     break;}
  145. case 999:
  146. #line 4411 "preproc.y"
  147. { yyval.str = make1_str("operator"); ;
  148.     break;}
  149. case 1000:
  150. #line 4412 "preproc.y"
  151. { yyval.str = make1_str("option"); ;
  152.     break;}
  153. case 1001:
  154. #line 4413 "preproc.y"
  155. { yyval.str = make1_str("password"); ;
  156.     break;}
  157. case 1002:
  158. #line 4414 "preproc.y"
  159. { yyval.str = make1_str("prior"); ;
  160.     break;}
  161. case 1003:
  162. #line 4415 "preproc.y"
  163. { yyval.str = make1_str("privileges"); ;
  164.     break;}
  165. case 1004:
  166. #line 4416 "preproc.y"
  167. { yyval.str = make1_str("procedural"); ;
  168.     break;}
  169. case 1005:
  170. #line 4417 "preproc.y"
  171. { yyval.str = make1_str("read"); ;
  172.     break;}
  173. case 1006:
  174. #line 4419 "preproc.y"
  175. { yyval.str = make1_str("relative"); ;
  176.     break;}
  177. case 1007:
  178. #line 4420 "preproc.y"
  179. { yyval.str = make1_str("rename"); ;
  180.     break;}
  181. case 1008:
  182. #line 4421 "preproc.y"
  183. { yyval.str = make1_str("returns"); ;
  184.     break;}
  185. case 1009:
  186. #line 4422 "preproc.y"
  187. { yyval.str = make1_str("row"); ;
  188.     break;}
  189. case 1010:
  190. #line 4423 "preproc.y"
  191. { yyval.str = make1_str("rule"); ;
  192.     break;}
  193. case 1011:
  194. #line 4424 "preproc.y"
  195. { yyval.str = make1_str("scroll"); ;
  196.     break;}
  197. case 1012:
  198. #line 4425 "preproc.y"
  199. { yyval.str = make1_str("sequence"); ;
  200.     break;}
  201. case 1013:
  202. #line 4426 "preproc.y"
  203. { yyval.str = make1_str("serial"); ;
  204.     break;}
  205. case 1014:
  206. #line 4427 "preproc.y"
  207. { yyval.str = make1_str("serializable"); ;
  208.     break;}
  209. case 1015:
  210. #line 4428 "preproc.y"
  211. { yyval.str = make1_str("share"); ;
  212.     break;}
  213. case 1016:
  214. #line 4429 "preproc.y"
  215. { yyval.str = make1_str("start"); ;
  216.     break;}
  217. case 1017:
  218. #line 4430 "preproc.y"
  219. { yyval.str = make1_str("statement"); ;
  220.     break;}
  221. case 1018:
  222. #line 4431 "preproc.y"
  223. { yyval.str = make1_str("stdin"); ;
  224.     break;}
  225. case 1019:
  226. #line 4432 "preproc.y"
  227. { yyval.str = make1_str("stdout"); ;
  228.     break;}
  229. case 1020:
  230. #line 4433 "preproc.y"
  231. { yyval.str = make1_str("time"); ;
  232.     break;}
  233. case 1021:
  234. #line 4434 "preproc.y"
  235. { yyval.str = make1_str("timestamp"); ;
  236.     break;}
  237. case 1022:
  238. #line 4435 "preproc.y"
  239. { yyval.str = make1_str("timezone_hour"); ;
  240.     break;}
  241. case 1023:
  242. #line 4436 "preproc.y"
  243. { yyval.str = make1_str("timezone_minute"); ;
  244.     break;}
  245. case 1024:
  246. #line 4437 "preproc.y"
  247. { yyval.str = make1_str("trigger"); ;
  248.     break;}
  249. case 1025:
  250. #line 4438 "preproc.y"
  251. { yyval.str = make1_str("trusted"); ;
  252.     break;}
  253. case 1026:
  254. #line 4439 "preproc.y"
  255. { yyval.str = make1_str("type"); ;
  256.     break;}
  257. case 1027:
  258. #line 4440 "preproc.y"
  259. { yyval.str = make1_str("valid"); ;
  260.     break;}
  261. case 1028:
  262. #line 4441 "preproc.y"
  263. { yyval.str = make1_str("version"); ;
  264.     break;}
  265. case 1029:
  266. #line 4442 "preproc.y"
  267. { yyval.str = make1_str("zone"); ;
  268.     break;}
  269. case 1030:
  270. #line 4443 "preproc.y"
  271. { yyval.str = make1_str("at"); ;
  272.     break;}
  273. case 1031:
  274. #line 4444 "preproc.y"
  275. { yyval.str = make1_str("bool"); ;
  276.     break;}
  277. case 1032:
  278. #line 4445 "preproc.y"
  279. { yyval.str = make1_str("break"); ;
  280.     break;}
  281. case 1033:
  282. #line 4446 "preproc.y"
  283. { yyval.str = make1_str("call"); ;
  284.     break;}
  285. case 1034:
  286. #line 4447 "preproc.y"
  287. { yyval.str = make1_str("connect"); ;
  288.     break;}
  289. case 1035:
  290. #line 4448 "preproc.y"
  291. { yyval.str = make1_str("continue"); ;
  292.     break;}
  293. case 1036:
  294. #line 4449 "preproc.y"
  295. { yyval.str = make1_str("deallocate"); ;
  296.     break;}
  297. case 1037:
  298. #line 4450 "preproc.y"
  299. { yyval.str = make1_str("disconnect"); ;
  300.     break;}
  301. case 1038:
  302. #line 4451 "preproc.y"
  303. { yyval.str = make1_str("found"); ;
  304.     break;}
  305. case 1039:
  306. #line 4452 "preproc.y"
  307. { yyval.str = make1_str("go"); ;
  308.     break;}
  309. case 1040:
  310. #line 4453 "preproc.y"
  311. { yyval.str = make1_str("goto"); ;
  312.     break;}
  313. case 1041:
  314. #line 4454 "preproc.y"
  315. { yyval.str = make1_str("identified"); ;
  316.     break;}
  317. case 1042:
  318. #line 4455 "preproc.y"
  319. { yyval.str = make1_str("immediate"); ;
  320.     break;}
  321. case 1043:
  322. #line 4456 "preproc.y"
  323. { yyval.str = make1_str("indicator"); ;
  324.     break;}
  325. case 1044:
  326. #line 4457 "preproc.y"
  327. { yyval.str = make1_str("int"); ;
  328.     break;}
  329. case 1045:
  330. #line 4458 "preproc.y"
  331. { yyval.str = make1_str("long"); ;
  332.     break;}
  333. case 1046:
  334. #line 4459 "preproc.y"
  335. { yyval.str = make1_str("off"); ;
  336.     break;}
  337. case 1047:
  338. #line 4460 "preproc.y"
  339. { yyval.str = make1_str("open"); ;
  340.     break;}
  341. case 1048:
  342. #line 4461 "preproc.y"
  343. { yyval.str = make1_str("prepare"); ;
  344.     break;}
  345. case 1049:
  346. #line 4462 "preproc.y"
  347. { yyval.str = make1_str("release"); ;
  348.     break;}
  349. case 1050:
  350. #line 4463 "preproc.y"
  351. { yyval.str = make1_str("section"); ;
  352.     break;}
  353. case 1051:
  354. #line 4464 "preproc.y"
  355. { yyval.str = make1_str("short"); ;
  356.     break;}
  357. case 1052:
  358. #line 4465 "preproc.y"
  359. { yyval.str = make1_str("signed"); ;
  360.     break;}
  361. case 1053:
  362. #line 4466 "preproc.y"
  363. { yyval.str = make1_str("sqlerror"); ;
  364.     break;}
  365. case 1054:
  366. #line 4467 "preproc.y"
  367. { yyval.str = make1_str("sqlprint"); ;
  368.     break;}
  369. case 1055:
  370. #line 4468 "preproc.y"
  371. { yyval.str = make1_str("sqlwarning"); ;
  372.     break;}
  373. case 1056:
  374. #line 4469 "preproc.y"
  375. { yyval.str = make1_str("stop"); ;
  376.     break;}
  377. case 1057:
  378. #line 4470 "preproc.y"
  379. { yyval.str = make1_str("struct"); ;
  380.     break;}
  381. case 1058:
  382. #line 4471 "preproc.y"
  383. { yyval.str = make1_str("unsigned"); ;
  384.     break;}
  385. case 1059:
  386. #line 4472 "preproc.y"
  387. { yyval.str = make1_str("var"); ;
  388.     break;}
  389. case 1060:
  390. #line 4473 "preproc.y"
  391. { yyval.str = make1_str("whenever"); ;
  392.     break;}
  393. case 1061:
  394. #line 4485 "preproc.y"
  395. { yyval.str = yyvsp[0].str; ;
  396.     break;}
  397. case 1062:
  398. #line 4486 "preproc.y"
  399. { yyval.str = make1_str("abort"); ;
  400.     break;}
  401. case 1063:
  402. #line 4487 "preproc.y"
  403. { yyval.str = make1_str("analyze"); ;
  404.     break;}
  405. case 1064:
  406. #line 4488 "preproc.y"
  407. { yyval.str = make1_str("binary"); ;
  408.     break;}
  409. case 1065:
  410. #line 4489 "preproc.y"
  411. { yyval.str = make1_str("case"); ;
  412.     break;}
  413. case 1066:
  414. #line 4490 "preproc.y"
  415. { yyval.str = make1_str("cluster"); ;
  416.     break;}
  417. case 1067:
  418. #line 4491 "preproc.y"
  419. { yyval.str = make1_str("coalesce"); ;
  420.     break;}
  421. case 1068:
  422. #line 4492 "preproc.y"
  423. { yyval.str = make1_str("constraint"); ;
  424.     break;}
  425. case 1069:
  426. #line 4493 "preproc.y"
  427. { yyval.str = make1_str("copy"); ;
  428.     break;}
  429. case 1070:
  430. #line 4494 "preproc.y"
  431. { yyval.str = make1_str("current"); ;
  432.     break;}
  433. case 1071:
  434. #line 4495 "preproc.y"
  435. { yyval.str = make1_str("do"); ;
  436.     break;}
  437. case 1072:
  438. #line 4496 "preproc.y"
  439. { yyval.str = make1_str("else"); ;
  440.     break;}
  441. case 1073:
  442. #line 4497 "preproc.y"
  443. { yyval.str = make1_str("end"); ;
  444.     break;}
  445. case 1074:
  446. #line 4498 "preproc.y"
  447. { yyval.str = make1_str("explain"); ;
  448.     break;}
  449. case 1075:
  450. #line 4499 "preproc.y"
  451. { yyval.str = make1_str("extend"); ;
  452.     break;}
  453. case 1076:
  454. #line 4500 "preproc.y"
  455. { yyval.str = make1_str("false"); ;
  456.     break;}
  457. case 1077:
  458. #line 4501 "preproc.y"
  459. { yyval.str = make1_str("foreign"); ;
  460.     break;}
  461. case 1078:
  462. #line 4502 "preproc.y"
  463. { yyval.str = make1_str("group"); ;
  464.     break;}
  465. case 1079:
  466. #line 4503 "preproc.y"
  467. { yyval.str = make1_str("listen"); ;
  468.     break;}
  469. case 1080:
  470. #line 4504 "preproc.y"
  471. { yyval.str = make1_str("load"); ;
  472.     break;}
  473. case 1081:
  474. #line 4505 "preproc.y"
  475. { yyval.str = make1_str("lock"); ;
  476.     break;}
  477. case 1082:
  478. #line 4506 "preproc.y"
  479. { yyval.str = make1_str("move"); ;
  480.     break;}
  481. case 1083:
  482. #line 4507 "preproc.y"
  483. { yyval.str = make1_str("new"); ;
  484.     break;}
  485. case 1084:
  486. #line 4508 "preproc.y"
  487. { yyval.str = make1_str("none"); ;
  488.     break;}
  489. case 1085:
  490. #line 4509 "preproc.y"
  491. { yyval.str = make1_str("nullif"); ;
  492.     break;}
  493. case 1086:
  494. #line 4510 "preproc.y"
  495. { yyval.str = make1_str("order"); ;
  496.     break;}
  497. case 1087:
  498. #line 4511 "preproc.y"
  499. { yyval.str = make1_str("position"); ;
  500.     break;}
  501. case 1088:
  502. #line 4512 "preproc.y"
  503. { yyval.str = make1_str("precision"); ;
  504.     break;}
  505. case 1089:
  506. #line 4513 "preproc.y"
  507. { yyval.str = make1_str("reset"); ;
  508.     break;}
  509. case 1090:
  510. #line 4514 "preproc.y"
  511. { yyval.str = make1_str("setof"); ;
  512.     break;}
  513. case 1091:
  514. #line 4515 "preproc.y"
  515. { yyval.str = make1_str("show"); ;
  516.     break;}
  517. case 1092:
  518. #line 4516 "preproc.y"
  519. { yyval.str = make1_str("table"); ;
  520.     break;}
  521. case 1093:
  522. #line 4517 "preproc.y"
  523. { yyval.str = make1_str("then"); ;
  524.     break;}
  525. case 1094:
  526. #line 4518 "preproc.y"
  527. { yyval.str = make1_str("transaction"); ;
  528.     break;}
  529. case 1095:
  530. #line 4519 "preproc.y"
  531. { yyval.str = make1_str("true"); ;
  532.     break;}
  533. case 1096:
  534. #line 4520 "preproc.y"
  535. { yyval.str = make1_str("vacuum"); ;
  536.     break;}
  537. case 1097:
  538. #line 4521 "preproc.y"
  539. { yyval.str = make1_str("verbose"); ;
  540.     break;}
  541. case 1098:
  542. #line 4522 "preproc.y"
  543. { yyval.str = make1_str("when"); ;
  544.     break;}
  545. case 1099:
  546. #line 4526 "preproc.y"
  547. {
  548. if (QueryIsRule)
  549. yyval.str = make1_str("current");
  550. else
  551. yyerror("CURRENT used in non-rule query");
  552. ;
  553.     break;}
  554. case 1100:
  555. #line 4533 "preproc.y"
  556. {
  557. if (QueryIsRule)
  558. yyval.str = make1_str("new");
  559. else
  560. yyerror("NEW used in non-rule query");
  561. ;
  562.     break;}
  563. case 1101:
  564. #line 4549 "preproc.y"
  565. {
  566. yyval.str = make5_str(yyvsp[-2].str, make1_str(","), yyvsp[0].str, make1_str(","), yyvsp[-1].str);
  567.                 ;
  568.     break;}
  569. case 1102:
  570. #line 4553 "preproc.y"
  571. {
  572.                  yyval.str = make1_str("NULL,NULL,NULL,"DEFAULT"");
  573.                 ;
  574.     break;}
  575. case 1103:
  576. #line 4558 "preproc.y"
  577. {
  578.        yyval.str = make3_str(make1_str("NULL,"), yyvsp[0].str, make1_str(",NULL"));
  579. ;
  580.     break;}
  581. case 1104:
  582. #line 4563 "preproc.y"
  583. {
  584.   /* old style: dbname[@server][:port] */
  585.   if (strlen(yyvsp[-1].str) > 0 && *(yyvsp[-1].str) != '@')
  586.   {
  587.     sprintf(errortext, "parse error at or near '%s'", yyvsp[-1].str);
  588.     yyerror(errortext);
  589.   }
  591.   yyval.str = make5_str(make1_str("""), yyvsp[-2].str, yyvsp[-1].str, yyvsp[0].str, make1_str("""));
  592. ;
  593.     break;}
  594. case 1105:
  595. #line 4574 "preproc.y"
  596. {
  597.   /* new style: <tcp|unix>:postgresql://server[:port][/dbname] */
  598.                   if (strncmp(yyvsp[-4].str, "://", 3) != 0)
  599.   {
  600.     sprintf(errortext, "parse error at or near '%s'", yyvsp[-4].str);
  601.     yyerror(errortext);
  602.   }
  604.   if (strncmp(yyvsp[-5].str, "unix", 4) == 0 && strncmp(yyvsp[-4].str + 3, "localhost", 9) != 0)
  605.   {
  606.     sprintf(errortext, "unix domain sockets only work on 'localhost' but not on '%9.9s'", yyvsp[-4].str);
  607.                     yyerror(errortext);
  608.   }
  610.   if (strncmp(yyvsp[-5].str, "unix", 4) != 0 && strncmp(yyvsp[-5].str, "tcp", 3) != 0)
  611.   {
  612.     sprintf(errortext, "only protocols 'tcp' and 'unix' are supported");
  613.                     yyerror(errortext);
  614.   }
  616.   yyval.str = make4_str(make5_str(make1_str("""), yyvsp[-5].str, yyvsp[-4].str, yyvsp[-3].str, make1_str("/")), yyvsp[-1].str, yyvsp[0].str, make1_str("""));
  617. ;
  618.     break;}
  619. case 1106:
  620. #line 4597 "preproc.y"
  621. {
  622.   yyval.str = yyvsp[0].str;
  623. ;
  624.     break;}
  625. case 1107:
  626. #line 4601 "preproc.y"
  627. {
  628.   yyval.str = mm_strdup(yyvsp[0].str);
  629.   yyval.str[0] = '"';
  630.   yyval.str[strlen(yyval.str) - 1] = '"';
  631.   free(yyvsp[0].str);
  632. ;
  633.     break;}
  634. case 1108:
  635. #line 4609 "preproc.y"
  636. {
  637.   if (strcmp(yyvsp[0].str, "postgresql") != 0 && strcmp(yyvsp[0].str, "postgres") != 0)
  638.   {
  639.     sprintf(errortext, "parse error at or near '%s'", yyvsp[0].str);
  640.     yyerror(errortext);
  641.   }
  643.   if (strcmp(yyvsp[-1].str, "tcp") != 0 && strcmp(yyvsp[-1].str, "unix") != 0)
  644.   {
  645.     sprintf(errortext, "Illegal connection type %s", yyvsp[-1].str);
  646.     yyerror(errortext);
  647.   }
  649.   yyval.str = make3_str(yyvsp[-1].str, make1_str(":"), yyvsp[0].str);
  650. ;
  651.     break;}
  652. case 1109:
  653. #line 4626 "preproc.y"
  654. {
  655.   if (strcmp(yyvsp[-1].str, "@") != 0 && strcmp(yyvsp[-1].str, "://") != 0)
  656.   {
  657.     sprintf(errortext, "parse error at or near '%s'", yyvsp[-1].str);
  658.     yyerror(errortext);
  659.   }
  661.   yyval.str = make2_str(yyvsp[-1].str, yyvsp[0].str);
  662.         ;
  663.     break;}
  664. case 1110:
  665. #line 4636 "preproc.y"
  666. { yyval.str = yyvsp[0].str; ;
  667.     break;}
  668. case 1111:
  669. #line 4637 "preproc.y"
  670. { yyval.str = make1_str(""); ;
  671.     break;}
  672. case 1112:
  673. #line 4639 "preproc.y"
  674. { yyval.str = yyvsp[0].str; ;
  675.     break;}
  676. case 1113:
  677. #line 4640 "preproc.y"
  678. { yyval.str = make3_str(yyvsp[-2].str, make1_str("."), yyvsp[0].str); ;
  679.     break;}
  680. case 1114:
  681. #line 4642 "preproc.y"
  682. { yyval.str = make2_str(make1_str(":"), yyvsp[0].str); ;
  683.     break;}
  684. case 1115:
  685. #line 4643 "preproc.y"
  686. { yyval.str = make1_str(""); ;
  687.     break;}
  688. case 1116:
  689. #line 4645 "preproc.y"
  690. { yyval.str = yyvsp[0].str; ;
  691.     break;}
  692. case 1117:
  693. #line 4646 "preproc.y"
  694. { yyval.str = make1_str("NULL"); ;
  695.     break;}
  696. case 1118:
  697. #line 4648 "preproc.y"
  698. { yyval.str = yyvsp[0].str; ;
  699.     break;}
  700. case 1119:
  701. #line 4649 "preproc.y"
  702. { yyval.str = make1_str("NULL,NULL"); ;
  703.     break;}
  704. case 1120:
  705. #line 4652 "preproc.y"
  706. {
  707.                         yyval.str = make2_str(yyvsp[0].str, make1_str(",NULL"));
  708.         ;
  709.     break;}
  710. case 1121:
  711. #line 4656 "preproc.y"
  712. {
  713.          yyval.str = make3_str(yyvsp[-2].str, make1_str(","), yyvsp[0].str);
  714.                 ;
  715.     break;}
  716. case 1122:
  717. #line 4660 "preproc.y"
  718. {
  719.          yyval.str = make3_str(yyvsp[-3].str, make1_str(","), yyvsp[0].str);
  720.                 ;
  721.     break;}
  722. case 1123:
  723. #line 4664 "preproc.y"
  724. {
  725.          yyval.str = make3_str(yyvsp[-2].str, make1_str(","), yyvsp[0].str);
  726.                 ;
  727.     break;}
  728. case 1124:
  729. #line 4668 "preproc.y"
  730. { if (yyvsp[0].str[0] == '"')
  731. yyval.str = yyvsp[0].str;
  732.   else
  733. yyval.str = make3_str(make1_str("""), yyvsp[0].str, make1_str("""));
  734. ;
  735.     break;}
  736. case 1125:
  737. #line 4673 "preproc.y"
  738. { yyval.str = yyvsp[0].str; ;
  739.     break;}
  740. case 1126:
  741. #line 4674 "preproc.y"
  742. { yyval.str = make3_str(make1_str("""), yyvsp[0].str, make1_str(""")); ;
  743.     break;}
  744. case 1127:
  745. #line 4677 "preproc.y"
  746. { /* check if we have a char variable */
  747. struct variable *p = find_variable(yyvsp[0].str);
  748. enum ECPGttype typ = p->type->typ;
  750. /* if array see what's inside */
  751. if (typ == ECPGt_array)
  752. typ = p->type->u.element->typ;
  754.                         switch (typ)
  755.                         {
  756.                             case ECPGt_char:
  757.                             case ECPGt_unsigned_char:
  758.                                 yyval.str = yyvsp[0].str;
  759.                                 break;
  760.                             case ECPGt_varchar:
  761.                                 yyval.str = make2_str(yyvsp[0].str, make1_str(".arr"));
  762.                                 break;
  763.                             default:
  764.                                 yyerror("invalid datatype");
  765.                                 break;
  766.                         }
  767. ;
  768.     break;}
  769. case 1128:
  770. #line 4701 "preproc.y"
  771. {
  772. if (strlen(yyvsp[-1].str) == 0)
  773. yyerror("parse error");
  775. if (strcmp(yyvsp[-1].str, "?") != 0)
  776. {
  777. sprintf(errortext, "parse error at or near %s", yyvsp[-1].str);
  778. yyerror(errortext);
  779. }
  781. yyval.str = make2_str(make1_str("?"), yyvsp[0].str);
  782. ;
  783.     break;}
  784. case 1129:
  785. #line 4713 "preproc.y"
  786. { yyval.str = make1_str(""); ;
  787.     break;}
  788. case 1130:
  789. #line 4720 "preproc.y"
  790. {
  791. struct cursor *ptr, *this;
  792. struct variable *thisquery = (struct variable *)mm_alloc(sizeof(struct variable));
  794. for (ptr = cur; ptr != NULL; ptr = ptr->next)
  795. {
  796. if (strcmp(yyvsp[-4].str, ptr->name) == 0)
  797. {
  798.         /* re-definition is a bug */
  799. sprintf(errortext, "cursor %s already defined", yyvsp[-4].str);
  800. yyerror(errortext);
  801.                 }
  802.          }
  804.          this = (struct cursor *) mm_alloc(sizeof(struct cursor));
  806.          /* initial definition */
  807.         this->next = cur;
  808.         this->name = yyvsp[-4].str;
  809. this->connection = connection;
  810.         this->command =  cat4_str(make1_str("declare"), mm_strdup(yyvsp[-4].str), yyvsp[-3].str, make1_str("cursor for ?"));
  811. this->argsresult = NULL;
  813. thisquery->type = &ecpg_query;
  814. thisquery->brace_level = 0;
  815. thisquery->next = NULL;
  816. thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement("")") + strlen(yyvsp[0].str));
  817. sprintf(thisquery->name, "ECPGprepared_statement("%s")", yyvsp[0].str);
  819. this->argsinsert = NULL;
  820. add_variable(&(this->argsinsert), thisquery, &no_indicator); 
  822.          cur = this;
  824. yyval.str = cat3_str(make1_str("/*"), mm_strdup(this->command), make1_str("*/"));
  825. ;
  826.     break;}
  827. case 1131:
  828. #line 4762 "preproc.y"
  829. { yyval.str = make3_str(make1_str("ECPGdeallocate(__LINE__, ""), yyvsp[0].str, make1_str("");")); ;
  830.     break;}
  831. case 1132:
  832. #line 4768 "preproc.y"
  833. {
  834. fputs("/* exec sql begin declare section */", yyout);
  835.         output_line_number();
  836. ;
  837.     break;}
  838. case 1133:
  839. #line 4773 "preproc.y"
  840. {
  841. fprintf(yyout, "%s/* exec sql end declare section */", yyvsp[-1].str);
  842. free(yyvsp[-1].str);
  843. output_line_number();
  844. ;
  845.     break;}
  846. case 1134:
  847. #line 4779 "preproc.y"
  848. {;
  849.     break;}
  850. case 1135:
  851. #line 4781 "preproc.y"
  852. {;
  853.     break;}
  854. case 1136:
  855. #line 4784 "preproc.y"
  856. {
  857. yyval.str = make1_str("");
  858. ;
  859.     break;}
  860. case 1137:
  861. #line 4788 "preproc.y"
  862. {
  863. yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str);
  864. ;
  865.     break;}
  866. case 1138:
  867. #line 4793 "preproc.y"
  868. {
  869. actual_storage[struct_level] = mm_strdup(yyvsp[0].str);
  870. ;
  871.     break;}
  872. case 1139:
  873. #line 4797 "preproc.y"
  874. {
  875. actual_type[struct_level].type_enum = yyvsp[0].type.type_enum;
  876. actual_type[struct_level].type_dimension = yyvsp[0].type.type_dimension;
  877. actual_type[struct_level].type_index = yyvsp[0].type.type_index;
  878. ;
  879.     break;}
  880. case 1140:
  881. #line 4803 "preproc.y"
  882. {
  883.   yyval.str = cat4_str(yyvsp[-5].str, yyvsp[-3].type.type_str, yyvsp[-1].str, make1_str(";n"));
  884. ;
  885.     break;}
  886. case 1141:
  887. #line 4807 "preproc.y"
  888. { yyval.str = make1_str("extern"); ;
  889.     break;}
  890. case 1142:
  891. #line 4808 "preproc.y"
  892. { yyval.str = make1_str("static"); ;
  893.     break;}
  894. case 1143:
  895. #line 4809 "preproc.y"
  896. { yyval.str = make1_str("signed"); ;
  897.     break;}
  898. case 1144:
  899. #line 4810 "preproc.y"
  900. { yyval.str = make1_str("const"); ;
  901.     break;}
  902. case 1145:
  903. #line 4811 "preproc.y"
  904. { yyval.str = make1_str("register"); ;
  905.     break;}
  906. case 1146:
  907. #line 4812 "preproc.y"
  908. { yyval.str = make1_str("auto"); ;
  909.     break;}
  910. case 1147:
  911. #line 4813 "preproc.y"
  912. { yyval.str = make1_str(""); ;
  913.     break;}
  914. case 1148:
  915. #line 4816 "preproc.y"
  916. {
  917. yyval.type.type_enum = yyvsp[0].type_enum;
  918. yyval.type.type_str = mm_strdup(ECPGtype_name(yyvsp[0].type_enum));
  919. yyval.type.type_dimension = -1;
  920.    yyval.type.type_index = -1;
  921. ;
  922.     break;}
  923. case 1149:
  924. #line 4823 "preproc.y"
  925. {
  926. yyval.type.type_enum = ECPGt_varchar;
  927. yyval.type.type_str = make1_str("");
  928. yyval.type.type_dimension = -1;
  929.    yyval.type.type_index = -1;
  930. ;
  931.     break;}
  932. case 1150:
  933. #line 4830 "preproc.y"
  934. {
  935. yyval.type.type_enum = ECPGt_struct;
  936. yyval.type.type_str = yyvsp[0].str;
  937. yyval.type.type_dimension = -1;
  938.    yyval.type.type_index = -1;
  939. ;
  940.     break;}
  941. case 1151:
  942. #line 4837 "preproc.y"
  943. {
  944. yyval.type.type_enum = ECPGt_union;
  945. yyval.type.type_str = yyvsp[0].str;
  946. yyval.type.type_dimension = -1;
  947.    yyval.type.type_index = -1;
  948. ;
  949.     break;}
  950. case 1152:
  951. #line 4844 "preproc.y"
  952. {
  953. yyval.type.type_str = yyvsp[0].str;
  954. yyval.type.type_enum = ECPGt_int;
  956. yyval.type.type_dimension = -1;
  957.    yyval.type.type_index = -1;
  958. ;
  959.     break;}
  960. case 1153:
  961. #line 4852 "preproc.y"
  962. {
  963. /* this is for typedef'ed types */
  964. struct typedefs *this = get_typedef(yyvsp[0].str);
  966. yyval.type.type_str = (this->type->type_enum == ECPGt_varchar) ? make1_str("") : mm_strdup(this->name);
  967.                         yyval.type.type_enum = this->type->type_enum;
  968. yyval.type.type_dimension = this->type->type_dimension;
  969.    yyval.type.type_index = this->type->type_index;
  970. struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
  971. ;
  972.     break;}
  973. case 1154:
  974. #line 4864 "preproc.y"
  975. {
  976. yyval.str = cat4_str(yyvsp[-3].str, make1_str("{"), yyvsp[-1].str, make1_str("}"));
  977. ;
  978.     break;}
  979. case 1155:
  980. #line 4868 "preproc.y"
  981. { yyval.str = cat2_str(make1_str("enum"), yyvsp[0].str); ;
  982.     break;}
  983. case 1156:
  984. #line 4871 "preproc.y"
  985. {
  986.     ECPGfree_struct_member(struct_member_list[struct_level]);
  987.     free(actual_storage[struct_level--]);
  988.     yyval.str = cat4_str(yyvsp[-3].str, make1_str("{"), yyvsp[-1].str, make1_str("}"));
  989. ;
  990.     break;}
  991. case 1157:
  992. #line 4878 "preproc.y"
  993. {
  994.     ECPGfree_struct_member(struct_member_list[struct_level]);
  995.     free(actual_storage[struct_level--]);
  996.     yyval.str = cat4_str(yyvsp[-3].str, make1_str("{"), yyvsp[-1].str, make1_str("}"));
  997. ;
  998.     break;}
  999. case 1158:
  1000. #line 4885 "preproc.y"
  1001. {
  1002.             struct_member_list[struct_level++] = NULL;
  1003.             if (struct_level >= STRUCT_DEPTH)
  1004.                  yyerror("Too many levels in nested structure definition");
  1005.     yyval.str = cat2_str(make1_str("struct"), yyvsp[0].str);
  1006. ;
  1007.     break;}
  1008. case 1159:
  1009. #line 4893 "preproc.y"
  1010. {
  1011.             struct_member_list[struct_level++] = NULL;
  1012.             if (struct_level >= STRUCT_DEPTH)
  1013.                  yyerror("Too many levels in nested structure definition");
  1014.     yyval.str = cat2_str(make1_str("union"), yyvsp[0].str);
  1015. ;
  1016.     break;}
  1017. case 1160:
  1018. #line 4900 "preproc.y"
  1019. { yyval.str = make1_str(""); ;
  1020.     break;}
  1021. case 1161:
  1022. #line 4901 "preproc.y"
  1023. { yyval.str = yyvsp[0].str; ;
  1024.     break;}
  1025. case 1162:
  1026. #line 4903 "preproc.y"
  1027. { yyval.type_enum = ECPGt_short; ;
  1028.     break;}
  1029. case 1163:
  1030. #line 4904 "preproc.y"
  1031. { yyval.type_enum = ECPGt_unsigned_short; ;
  1032.     break;}
  1033. case 1164:
  1034. #line 4905 "preproc.y"
  1035. { yyval.type_enum = ECPGt_int; ;
  1036.     break;}
  1037. case 1165:
  1038. #line 4906 "preproc.y"
  1039. { yyval.type_enum = ECPGt_unsigned_int; ;
  1040.     break;}
  1041. case 1166:
  1042. #line 4907 "preproc.y"
  1043. { yyval.type_enum = ECPGt_long; ;
  1044.     break;}
  1045. case 1167:
  1046. #line 4908 "preproc.y"
  1047. { yyval.type_enum = ECPGt_unsigned_long; ;
  1048.     break;}
  1049. case 1168:
  1050. #line 4909 "preproc.y"
  1051. { yyval.type_enum = ECPGt_float; ;
  1052.     break;}
  1053. case 1169:
  1054. #line 4910 "preproc.y"
  1055. { yyval.type_enum = ECPGt_double; ;
  1056.     break;}
  1057. case 1170:
  1058. #line 4911 "preproc.y"
  1059. { yyval.type_enum = ECPGt_bool; ;
  1060.     break;}
  1061. case 1171:
  1062. #line 4912 "preproc.y"
  1063. { yyval.type_enum = ECPGt_char; ;
  1064.     break;}
  1065. case 1172:
  1066. #line 4913 "preproc.y"
  1067. { yyval.type_enum = ECPGt_unsigned_char; ;
  1068.     break;}
  1069. case 1173:
  1070. #line 4915 "preproc.y"
  1071. { yyval.type_enum = ECPGt_varchar; ;
  1072.     break;}
  1073. case 1174:
  1074. #line 4918 "preproc.y"
  1075. {
  1076. yyval.str = yyvsp[0].str;
  1077. ;
  1078.     break;}
  1079. case 1175:
  1080. #line 4922 "preproc.y"
  1081. {
  1082. yyval.str = cat3_str(yyvsp[-2].str, make1_str(","), yyvsp[0].str);
  1083. ;
  1084.     break;}
  1085. case 1176:
  1086. #line 4927 "preproc.y"
  1087. {
  1088. struct ECPGtype * type;
  1089.                         int dimension = yyvsp[-1].index.index1; /* dimension of array */
  1090.                         int length = yyvsp[-1].index.index2;    /* lenght of string */
  1091.                         char dim[14L], ascii_len[12];
  1093. adjust_array(actual_type[struct_level].type_enum, &dimension, &length, actual_type[struct_level].type_dimension, actual_type[struct_level].type_index, strlen(yyvsp[-3].str));
  1095. switch (actual_type[struct_level].type_enum)
  1096. {
  1097.    case ECPGt_struct:
  1098.    case ECPGt_union:
  1099.                                if (dimension < 0)
  1100.                                    type = ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum);
  1101.                                else
  1102.                                    type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum), dimension); 
  1104.                                yyval.str = make4_str(yyvsp[-3].str, mm_strdup(yyvsp[-2].str), yyvsp[-1].index.str, yyvsp[0].str);
  1105.                                break;
  1106.                            case ECPGt_varchar:
  1107.                                if (dimension == -1)
  1108.                                    type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length);
  1109.                                else
  1110.                                    type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length), dimension);
  1112.                                switch(dimension)
  1113.                                {
  1114.                                   case 0:
  1115.   case -1:
  1116.                                   case 1:
  1117.                                       *dim = '';
  1118.                                       break;
  1119.                                   default:
  1120.                                       sprintf(dim, "[%d]", dimension);
  1121.                                       break;
  1122.                                }
  1123.        sprintf(ascii_len, "%d", length);
  1125.                                if (length == 0)
  1126.    yyerror ("pointer to varchar are not implemented");
  1128.        if (dimension == 0)
  1129.    yyval.str = make4_str(make5_str(mm_strdup(actual_storage[struct_level]), make1_str(" struct varchar_"), mm_strdup(yyvsp[-2].str), make1_str(" { int len; char arr["), mm_strdup(ascii_len)), make1_str("]; } *"), mm_strdup(yyvsp[-2].str), yyvsp[0].str);
  1130.        else
  1131.                                    yyval.str = make5_str(make5_str(mm_strdup(actual_storage[struct_level]), make1_str(" struct varchar_"), mm_strdup(yyvsp[-2].str), make1_str(" { int len; char arr["), mm_strdup(ascii_len)), make1_str("]; } "), mm_strdup(yyvsp[-2].str), mm_strdup(dim), yyvsp[0].str);
  1133.                                break;
  1134.                            case ECPGt_char:
  1135.                            case ECPGt_unsigned_char:
  1136.                                if (dimension == -1)
  1137.                                    type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length);
  1138.                                else
  1139.                                    type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length), dimension);
  1141.        yyval.str = make4_str(yyvsp[-3].str, mm_strdup(yyvsp[-2].str), yyvsp[-1].index.str, yyvsp[0].str);
  1142.                                break;
  1143.                            default:
  1144.                                if (dimension < 0)
  1145.                                    type = ECPGmake_simple_type(actual_type[struct_level].type_enum, 1);
  1146.                                else
  1147.                                    type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, 1), dimension);
  1149.        yyval.str = make4_str(yyvsp[-3].str, mm_strdup(yyvsp[-2].str), yyvsp[-1].index.str, yyvsp[0].str);
  1150.                                break;
  1151. }
  1153. if (struct_level == 0)
  1154. new_variable(yyvsp[-2].str, type);
  1155. else
  1156. ECPGmake_struct_member(yyvsp[-2].str, type, &(struct_member_list[struct_level - 1]));
  1158. free(yyvsp[-2].str);
  1159. ;
  1160.     break;}
  1161. case 1177:
  1162. #line 5001 "preproc.y"
  1163. { yyval.str = make1_str(""); ;
  1164.     break;}
  1165. case 1178:
  1166. #line 5002 "preproc.y"
  1167. { yyval.str = make2_str(make1_str("="), yyvsp[0].str); ;
  1168.     break;}
  1169. case 1179:
  1170. #line 5004 "preproc.y"
  1171. { yyval.str = make1_str(""); ;
  1172.     break;}
  1173. case 1180:
  1174. #line 5005 "preproc.y"
  1175. { yyval.str = make1_str("*"); ;
  1176.     break;}
  1177. case 1181:
  1178. #line 5012 "preproc.y"
  1179. {
  1180. /* this is only supported for compatibility */
  1181. yyval.str = cat3_str(make1_str("/* declare statement"), yyvsp[0].str, make1_str("*/"));
  1182. ;
  1183.     break;}
  1184. case 1182:
  1185. #line 5019 "preproc.y"
  1186. { yyval.str = yyvsp[0].str; ;
  1187.     break;}
  1188. case 1183:
  1189. #line 5021 "preproc.y"
  1190. { yyval.str = yyvsp[0].str; ;
  1191.     break;}
  1192. case 1184:
  1193. #line 5022 "preproc.y"
  1194. { yyval.str = make1_str("CURRENT"); ;
  1195.     break;}
  1196. case 1185:
  1197. #line 5023 "preproc.y"
  1198. { yyval.str = make1_str("ALL"); ;
  1199.     break;}
  1200. case 1186:
  1201. #line 5024 "preproc.y"
  1202. { yyval.str = make1_str("CURRENT"); ;
  1203.     break;}
  1204. case 1187:
  1205. #line 5026 "preproc.y"
  1206. { yyval.str = yyvsp[0].str; ;
  1207.     break;}
  1208. case 1188:
  1209. #line 5027 "preproc.y"
  1210. { yyval.str = make1_str("DEFAULT"); ;
  1211.     break;}
  1212. case 1189:
  1213. #line 5033 "preproc.y"
  1214. { 
  1215. struct variable *thisquery = (struct variable *)mm_alloc(sizeof(struct variable));
  1217. thisquery->type = &ecpg_query;
  1218. thisquery->brace_level = 0;
  1219. thisquery->next = NULL;
  1220. thisquery->name = yyvsp[0].str;
  1222. add_variable(&argsinsert, thisquery, &no_indicator); 
  1224. yyval.str = make1_str("?");
  1225. ;
  1226.     break;}
  1227. case 1190:
  1228. #line 5046 "preproc.y"
  1229. {
  1230. struct variable *thisquery = (struct variable *)mm_alloc(sizeof(struct variable));
  1232. thisquery->type = &ecpg_query;
  1233. thisquery->brace_level = 0;
  1234. thisquery->next = NULL;
  1235. thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement("")") + strlen(yyvsp[0].str));
  1236. sprintf(thisquery->name, "ECPGprepared_statement("%s")", yyvsp[0].str);
  1238. add_variable(&argsinsert, thisquery, &no_indicator); 
  1239. ;
  1240.     break;}
  1241. case 1191:
  1242. #line 5057 "preproc.y"
  1243. {
  1244. yyval.str = make1_str("?");
  1245. ;
  1246.     break;}
  1247. case 1193:
  1248. #line 5062 "preproc.y"
  1249. { yyval.str = make3_str(make1_str("""), yyvsp[0].str, make1_str(""")); ;
  1250.     break;}
  1251. case 1194:
  1252. #line 5068 "preproc.y"
  1253. { yyval.str = yyvsp[0].str; ;
  1254.     break;}
  1255. case 1195:
  1256. #line 5073 "preproc.y"
  1257. {
  1258. yyval.str = yyvsp[-1].str;
  1259. ;
  1260.     break;}
  1261. case 1196:
  1262. #line 5077 "preproc.y"
  1263. { yyval.str = make1_str(""); ;
  1264.     break;}
  1265. case 1197:
  1266. #line 5078 "preproc.y"
  1267. {
  1268. /* yyerror ("open cursor with variables not implemented yet"); */
  1269. yyval.str = make1_str("");
  1270. ;
  1271.     break;}
  1272. case 1200:
  1273. #line 5090 "preproc.y"
  1274. {
  1275. yyval.str = make4_str(make1_str("""), yyvsp[-2].str, make1_str("", "), yyvsp[0].str);
  1276. ;
  1277.     break;}
  1278. case 1201:
  1279. #line 5100 "preproc.y"
  1280. {
  1281. if (strncmp(yyvsp[-1].str, "begin", 5) == 0)
  1282.                         yyerror("RELEASE does not make sense when beginning a transaction");
  1284. fprintf(yyout, "ECPGtrans(__LINE__, %s, "%s");", connection, yyvsp[-1].str);
  1285. whenever_action(0);
  1286. fprintf(yyout, "ECPGdisconnect("");"); 
  1287. whenever_action(0);
  1288. free(yyvsp[-1].str);
  1289. ;
  1290.     break;}
  1291. case 1202:
  1292. #line 5116 "preproc.y"
  1293. {
  1294. yyval.str = yyvsp[0].str;
  1295.                         ;
  1296.     break;}
  1297. case 1203:
  1298. #line 5120 "preproc.y"
  1299. { yyval.str = make1_str("on"); ;
  1300.     break;}
  1301. case 1204:
  1302. #line 5121 "preproc.y"
  1303. { yyval.str = make1_str("off"); ;
  1304.     break;}
  1305. case 1207:
  1306. #line 5130 "preproc.y"
  1307. {
  1308. yyval.str = yyvsp[0].str;
  1309.                         ;
  1310.     break;}
  1311. case 1208:
  1312. #line 5138 "preproc.y"
  1313. {
  1314. /* add entry to list */
  1315. struct typedefs *ptr, *this;
  1316. int dimension = yyvsp[-1].index.index1;
  1317. int length = yyvsp[-1].index.index2;
  1319. for (ptr = types; ptr != NULL; ptr = ptr->next)
  1320. {
  1321. if (strcmp(yyvsp[-4].str, ptr->name) == 0)
  1322. {
  1323.         /* re-definition is a bug */
  1324. sprintf(errortext, "type %s already defined", yyvsp[-4].str);
  1325. yyerror(errortext);
  1326.                 }
  1327. }
  1329. adjust_array(yyvsp[-2].type.type_enum, &dimension, &length, yyvsp[-2].type.type_dimension, yyvsp[-2].type.type_index, strlen(yyvsp[0].str));
  1331.          this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
  1333.          /* initial definition */
  1334.         this->next = types;
  1335.         this->name = yyvsp[-4].str;
  1336. this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
  1337. this->type->type_enum = yyvsp[-2].type.type_enum;
  1338. this->type->type_str = mm_strdup(yyvsp[-4].str);
  1339. this->type->type_dimension = dimension; /* dimension of array */
  1340. this->type->type_index = length;    /* lenght of string */
  1341. this->struct_member_list = struct_member_list[struct_level];
  1343. if (yyvsp[-2].type.type_enum != ECPGt_varchar &&
  1344.     yyvsp[-2].type.type_enum != ECPGt_char &&
  1345.             yyvsp[-2].type.type_enum != ECPGt_unsigned_char &&
  1346.     this->type->type_index >= 0)
  1347.                             yyerror("No multi-dimensional array support for simple data types");
  1349.          types = this;
  1351. yyval.str = cat5_str(cat3_str(make1_str("/* exec sql type"), mm_strdup(yyvsp[-4].str), make1_str("is")), mm_strdup(yyvsp[-2].type.type_str), mm_strdup(yyvsp[-1].index.str), yyvsp[0].str, make1_str("*/"));
  1352. ;
  1353.     break;}
  1354. case 1209:
  1355. #line 5180 "preproc.y"
  1356. {
  1357.                             yyval.index.index1 = 0;
  1358.                             yyval.index.index2 = yyvsp[0].index.index1;
  1359.                             yyval.index.str = cat2_str(make1_str("[]"), yyvsp[0].index.str);
  1360.                         ;
  1361.     break;}
  1362. case 1210:
  1363. #line 5186 "preproc.y"
  1364. {
  1365.                             yyval.index.index1 = 0;
  1366.                             yyval.index.index2 = yyvsp[0].index.index1;
  1367.                             yyval.index.str = cat2_str(make1_str("[]"), yyvsp[0].index.str);
  1368.                         ;
  1369.     break;}
  1370. case 1211:
  1371. #line 5192 "preproc.y"
  1372. {
  1373.     char *txt = mm_alloc(20L);
  1375.     sprintf (txt, "%d", yyvsp[-2].ival);
  1376.                             yyval.index.index1 = yyvsp[-2].ival;
  1377.                             yyval.index.index2 = yyvsp[0].index.index1;
  1378.                             yyval.index.str = cat4_str(make1_str("["), txt, make1_str("]"), yyvsp[0].index.str);
  1379.                         ;
  1380.     break;}
  1381. case 1212:
  1382. #line 5201 "preproc.y"
  1383. {
  1384.     char *txt = mm_alloc(20L);
  1386.     sprintf (txt, "%d", yyvsp[-2].ival);
  1387.                             yyval.index.index1 = yyvsp[-2].ival;
  1388.                             yyval.index.index2 = yyvsp[0].index.index1;
  1389.                             yyval.index.str = cat4_str(make1_str("["), txt, make1_str("]"), yyvsp[0].index.str);
  1390.                         ;
  1391.     break;}
  1392. case 1213:
  1393. #line 5210 "preproc.y"
  1394. {
  1395.                             yyval.index.index1 = -1;
  1396.                             yyval.index.index2 = -1;
  1397.                             yyval.index.str= make1_str("");
  1398.                         ;
  1399.     break;}
  1400. case 1214:
  1401. #line 5218 "preproc.y"
  1402. {
  1403.                             yyval.index.index1 = 0;
  1404.                             yyval.index.index2 = yyvsp[0].index.index1;
  1405.                             yyval.index.str = cat2_str(make1_str("[]"), yyvsp[0].index.str);
  1406.                         ;
  1407.     break;}
  1408. case 1215:
  1409. #line 5224 "preproc.y"
  1410. {
  1411.                             yyval.index.index1 = 0;
  1412.                             yyval.index.index2 = yyvsp[0].index.index1;
  1413.                             yyval.index.str = cat2_str(make1_str("[]"), yyvsp[0].index.str);
  1414.                         ;
  1415.     break;}
  1416. case 1216:
  1417. #line 5230 "preproc.y"
  1418. {
  1419.     char *txt = mm_alloc(20L);
  1421.     sprintf (txt, "%d", yyvsp[-2].ival);
  1422.                             yyval.index.index1 = yyvsp[-2].ival;
  1423.                             yyval.index.index2 = yyvsp[0].index.index1;
  1424.                             yyval.index.str = cat4_str(make1_str("["), txt, make1_str("]"), yyvsp[0].index.str);
  1425.                         ;
  1426.     break;}
  1427. case 1217:
  1428. #line 5239 "preproc.y"
  1429. {
  1430.     char *txt = mm_alloc(20L);
  1432.     sprintf (txt, "%d", yyvsp[-2].ival);
  1433.                             yyval.index.index1 = yyvsp[-2].ival;
  1434.                             yyval.index.index2 = yyvsp[0].index.index1;
  1435.                             yyval.index.str = cat4_str(make1_str("["), txt, make1_str("]"), yyvsp[0].index.str);
  1436.                         ;
  1437.     break;}
  1438. case 1218:
  1439. #line 5248 "preproc.y"
  1440. {
  1441.                             yyval.index.index1 = -1;
  1442.                             yyval.index.index2 = -1;
  1443.                             yyval.index.str= make1_str("");
  1444.                         ;
  1445.     break;}
  1446. case 1219:
  1447. #line 5254 "preproc.y"
  1448. { yyval.str = make1_str("reference"); ;
  1449.     break;}
  1450. case 1220:
  1451. #line 5255 "preproc.y"
  1452. { yyval.str = make1_str(""); ;
  1453.     break;}
  1454. case 1221:
  1455. #line 5258 "preproc.y"
  1456. {
  1457. yyval.type.type_str = make1_str("char");
  1458.                 yyval.type.type_enum = ECPGt_char;
  1459. yyval.type.type_index = -1;
  1460. yyval.type.type_dimension = -1;
  1461. ;
  1462.     break;}
  1463. case 1222:
  1464. #line 5265 "preproc.y"
  1465. {
  1466. yyval.type.type_str = make1_str("varchar");
  1467.                 yyval.type.type_enum = ECPGt_varchar;
  1468. yyval.type.type_index = -1;
  1469. yyval.type.type_dimension = -1;
  1470. ;
  1471.     break;}
  1472. case 1223:
  1473. #line 5272 "preproc.y"
  1474. {
  1475. yyval.type.type_str = make1_str("float");
  1476.                 yyval.type.type_enum = ECPGt_float;
  1477. yyval.type.type_index = -1;
  1478. yyval.type.type_dimension = -1;
  1479. ;
  1480.     break;}
  1481. case 1224:
  1482. #line 5279 "preproc.y"
  1483. {
  1484. yyval.type.type_str = make1_str("double");
  1485.                 yyval.type.type_enum = ECPGt_double;
  1486. yyval.type.type_index = -1;
  1487. yyval.type.type_dimension = -1;
  1488. ;
  1489.     break;}
  1490. case 1225:
  1491. #line 5286 "preproc.y"
  1492. {
  1493. yyval.type.type_str = make1_str("int");
  1494.                 yyval.type.type_enum = ECPGt_int;
  1495. yyval.type.type_index = -1;
  1496. yyval.type.type_dimension = -1;
  1497. ;
  1498.     break;}
  1499. case 1226:
  1500. #line 5293 "preproc.y"
  1501. {
  1502. yyval.type.type_str = make1_str("int");
  1503.                 yyval.type.type_enum = ECPGt_int;
  1504. yyval.type.type_index = -1;
  1505. yyval.type.type_dimension = -1;
  1506. ;
  1507.     break;}
  1508. case 1227:
  1509. #line 5300 "preproc.y"
  1510. {
  1511. yyval.type.type_str = make1_str("short");
  1512.                 yyval.type.type_enum = ECPGt_short;
  1513. yyval.type.type_index = -1;
  1514. yyval.type.type_dimension = -1;
  1515. ;
  1516.     break;}
  1517. case 1228:
  1518. #line 5307 "preproc.y"
  1519. {
  1520. yyval.type.type_str = make1_str("long");
  1521.                 yyval.type.type_enum = ECPGt_long;
  1522. yyval.type.type_index = -1;
  1523. yyval.type.type_dimension = -1;
  1524. ;
  1525.     break;}
  1526. case 1229:
  1527. #line 5314 "preproc.y"
  1528. {
  1529. yyval.type.type_str = make1_str("bool");
  1530.                 yyval.type.type_enum = ECPGt_bool;
  1531. yyval.type.type_index = -1;
  1532. yyval.type.type_dimension = -1;
  1533. ;
  1534.     break;}
  1535. case 1230:
  1536. #line 5321 "preproc.y"
  1537. {
  1538. yyval.type.type_str = make1_str("unsigned int");
  1539.                 yyval.type.type_enum = ECPGt_unsigned_int;
  1540. yyval.type.type_index = -1;
  1541. yyval.type.type_dimension = -1;
  1542. ;
  1543.     break;}
  1544. case 1231:
  1545. #line 5328 "preproc.y"
  1546. {
  1547. yyval.type.type_str = make1_str("unsigned short");
  1548.                 yyval.type.type_enum = ECPGt_unsigned_short;
  1549. yyval.type.type_index = -1;
  1550. yyval.type.type_dimension = -1;
  1551. ;
  1552.     break;}
  1553. case 1232:
  1554. #line 5335 "preproc.y"
  1555. {
  1556. yyval.type.type_str = make1_str("unsigned long");
  1557.                 yyval.type.type_enum = ECPGt_unsigned_long;
  1558. yyval.type.type_index = -1;
  1559. yyval.type.type_dimension = -1;
  1560. ;
  1561.     break;}
  1562. case 1233:
  1563. #line 5342 "preproc.y"
  1564. {
  1565. struct_member_list[struct_level++] = NULL;
  1566. if (struct_level >= STRUCT_DEPTH)
  1567.          yyerror("Too many levels in nested structure definition");
  1568. ;
  1569.     break;}
  1570. case 1234:
  1571. #line 5347 "preproc.y"
  1572. {
  1573. ECPGfree_struct_member(struct_member_list[struct_level--]);
  1574. yyval.type.type_str = cat3_str(make1_str("struct {"), yyvsp[-1].str, make1_str("}"));
  1575. yyval.type.type_enum = ECPGt_struct;
  1576.                 yyval.type.type_index = -1;
  1577.                 yyval.type.type_dimension = -1;
  1578. ;
  1579.     break;}
  1580. case 1235:
  1581. #line 5355 "preproc.y"
  1582. {
  1583. struct_member_list[struct_level++] = NULL;
  1584. if (struct_level >= STRUCT_DEPTH)
  1585.          yyerror("Too many levels in nested structure definition");
  1586. ;
  1587.     break;}
  1588. case 1236:
  1589. #line 5360 "preproc.y"
  1590. {
  1591. ECPGfree_struct_member(struct_member_list[struct_level--]);
  1592. yyval.type.type_str = cat3_str(make1_str("union {"), yyvsp[-1].str, make1_str("}"));
  1593. yyval.type.type_enum = ECPGt_union;
  1594.                 yyval.type.type_index = -1;
  1595.                 yyval.type.type_dimension = -1;
  1596. ;
  1597.     break;}
  1598. case 1237:
  1599. #line 5368 "preproc.y"
  1600. {
  1601. struct typedefs *this = get_typedef(yyvsp[0].str);
  1603. yyval.type.type_str = mm_strdup(yyvsp[0].str);
  1604. yyval.type.type_enum = this->type->type_enum;
  1605. yyval.type.type_dimension = this->type->type_dimension;
  1606. yyval.type.type_index = this->type->type_index;
  1607. struct_member_list[struct_level] = this->struct_member_list;
  1608. ;
  1609.     break;}
  1610. case 1240:
  1611. #line 5381 "preproc.y"
  1612. {
  1613. yyval.str = make1_str("");
  1614. ;
  1615.     break;}
  1616. case 1241:
  1617. #line 5385 "preproc.y"
  1618. {
  1619. yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str);
  1620. ;
  1621.     break;}
  1622. case 1242:
  1623. #line 5391 "preproc.y"
  1624. {
  1625. actual_type[struct_level].type_enum = yyvsp[0].type.type_enum;
  1626. actual_type[struct_level].type_dimension = yyvsp[0].type.type_dimension;
  1627. actual_type[struct_level].type_index = yyvsp[0].type.type_index;
  1628. ;
  1629.     break;}
  1630. case 1243:
  1631. #line 5397 "preproc.y"
  1632. {
  1633. yyval.str = cat3_str(yyvsp[-3].type.type_str, yyvsp[-1].str, make1_str(";"));
  1634. ;
  1635.     break;}
  1636. case 1244:
  1637. #line 5402 "preproc.y"
  1638. {
  1639. yyval.str = yyvsp[0].str;
  1640. ;
  1641.     break;}
  1642. case 1245:
  1643. #line 5406 "preproc.y"
  1644. {
  1645. yyval.str = make3_str(yyvsp[-2].str, make1_str(","), yyvsp[0].str);
  1646. ;
  1647.     break;}
  1648. case 1246:
  1649. #line 5411 "preproc.y"
  1650. {
  1651. int dimension = yyvsp[0].index.index1;
  1652. int length = yyvsp[0].index.index2;
  1653. struct ECPGtype * type;
  1654.                         char dim[14L];
  1656. adjust_array(actual_type[struct_level].type_enum, &dimension, &length, actual_type[struct_level].type_dimension, actual_type[struct_level].type_index, strlen(yyvsp[-2].str));
  1658. switch (actual_type[struct_level].type_enum)
  1659. {
  1660.    case ECPGt_struct:
  1661.    case ECPGt_union:
  1662.                                if (dimension < 0)
  1663.                                    type = ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum);
  1664.                                else
  1665.                                    type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum), dimension); 
  1667.                                break;
  1668.                            case ECPGt_varchar:
  1669.                                if (dimension == -1)
  1670.                                    type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length);
  1671.                                else
  1672.                                    type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length), dimension);
  1674.                                switch(dimension)
  1675.                                {
  1676.                                   case 0:
  1677.                                       strcpy(dim, "[]");
  1678.                                       break;
  1679.   case -1:
  1680.                                   case 1:
  1681.                                       *dim = '';
  1682.                                       break;
  1683.                                   default:
  1684.                                       sprintf(dim, "[%d]", dimension);
  1685.                                       break;
  1686.                                 }
  1688.                                break;
  1689.                            case ECPGt_char:
  1690.                            case ECPGt_unsigned_char:
  1691.                                if (dimension == -1)
  1692.                                    type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length);
  1693.                                else
  1694.                                    type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length), dimension);
  1696.                                break;
  1697.                            default:
  1698.        if (length >= 0)
  1699.                              yyerror("No multi-dimensional array support for simple data types");
  1701.                                if (dimension < 0)
  1702.                                    type = ECPGmake_simple_type(actual_type[struct_level].type_enum, 1);
  1703.                                else
  1704.                                    type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, 1), dimension);
  1706.                                break;
  1707. }
  1709. if (struct_level == 0)
  1710. new_variable(yyvsp[-1].str, type);
  1711. else
  1712. ECPGmake_struct_member(yyvsp[-1].str, type, &(struct_member_list[struct_level - 1]));
  1714. yyval.str = cat3_str(yyvsp[-2].str, yyvsp[-1].str, yyvsp[0].index.str);
  1715. ;
  1716.     break;}
  1717. case 1247:
  1718. #line 5482 "preproc.y"
  1719. {
  1720. struct variable *p = find_variable(yyvsp[-4].str);
  1721. int dimension = yyvsp[-1].index.index1;
  1722. int length = yyvsp[-1].index.index2;
  1723. struct ECPGtype * type;
  1725. adjust_array(yyvsp[-2].type.type_enum, &dimension, &length, yyvsp[-2].type.type_dimension, yyvsp[-2].type.type_index, strlen(yyvsp[0].str));
  1727. switch (yyvsp[-2].type.type_enum)
  1728. {
  1729.    case ECPGt_struct:
  1730.    case ECPGt_union:
  1731.                         if (dimension < 0)
  1732.                             type = ECPGmake_struct_type(struct_member_list[struct_level], yyvsp[-2].type.type_enum);
  1733.                         else
  1734.                             type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], yyvsp[-2].type.type_enum), dimension); 
  1735.                         break;
  1736.                    case ECPGt_varchar:
  1737.                         if (dimension == -1)
  1738.                             type = ECPGmake_simple_type(yyvsp[-2].type.type_enum, length);
  1739.                         else
  1740.                             type = ECPGmake_array_type(ECPGmake_simple_type(yyvsp[-2].type.type_enum, length), dimension);
  1742. break;
  1743.                    case ECPGt_char:
  1744.                    case ECPGt_unsigned_char:
  1745.                         if (dimension == -1)
  1746.                             type = ECPGmake_simple_type(yyvsp[-2].type.type_enum, length);
  1747.                         else
  1748.                             type = ECPGmake_array_type(ECPGmake_simple_type(yyvsp[-2].type.type_enum, length), dimension);
  1750. break;
  1751.    default:
  1752. if (length >= 0)
  1753.                      yyerror("No multi-dimensional array support for simple data types");
  1755.                         if (dimension < 0)
  1756.                             type = ECPGmake_simple_type(yyvsp[-2].type.type_enum, 1);
  1757.                         else
  1758.                             type = ECPGmake_array_type(ECPGmake_simple_type(yyvsp[-2].type.type_enum, 1), dimension);
  1760. break;
  1761. }
  1763. ECPGfree_type(p->type);
  1764. p->type = type;
  1766. yyval.str = cat5_str(cat3_str(make1_str("/* exec sql var"), mm_strdup(yyvsp[-4].str), make1_str("is")), mm_strdup(yyvsp[-2].type.type_str), mm_strdup(yyvsp[-1].index.str), yyvsp[0].str, make1_str("*/"));
  1767. ;
  1768.     break;}
  1769. case 1248:
  1770. #line 5536 "preproc.y"
  1771. {
  1772. when_error.code = yyvsp[0].action.code;
  1773. when_error.command = yyvsp[0].action.command;
  1774. yyval.str = cat3_str(make1_str("/* exec sql whenever sqlerror "), yyvsp[0].action.str, make1_str("; */n"));
  1775. ;
  1776.     break;}
  1777. case 1249:
  1778. #line 5541 "preproc.y"
  1779. {
  1780. when_nf.code = yyvsp[0].action.code;
  1781. when_nf.command = yyvsp[0].action.command;
  1782. yyval.str = cat3_str(make1_str("/* exec sql whenever not found "), yyvsp[0].action.str, make1_str("; */n"));
  1783. ;
  1784.     break;}
  1785. case 1250:
  1786. #line 5546 "preproc.y"
  1787. {
  1788. when_warn.code = yyvsp[0].action.code;
  1789. when_warn.command = yyvsp[0].action.command;
  1790. yyval.str = cat3_str(make1_str("/* exec sql whenever sql_warning "), yyvsp[0].action.str, make1_str("; */n"));
  1791. ;
  1792.     break;}
  1793. case 1251:
  1794. #line 5552 "preproc.y"
  1795. {
  1796. yyval.action.code = W_NOTHING;
  1797. yyval.action.command = NULL;
  1798. yyval.action.str = make1_str("continue");
  1799. ;
  1800.     break;}
  1801. case 1252:
  1802. #line 5557 "preproc.y"
  1803. {
  1804. yyval.action.code = W_SQLPRINT;
  1805. yyval.action.command = NULL;
  1806. yyval.action.str = make1_str("sqlprint");
  1807. ;
  1808.     break;}
  1809. case 1253:
  1810. #line 5562 "preproc.y"
  1811. {
  1812. yyval.action.code = W_STOP;
  1813. yyval.action.command = NULL;
  1814. yyval.action.str = make1_str("stop");
  1815. ;
  1816.     break;}
  1817. case 1254:
  1818. #line 5567 "preproc.y"
  1819. {
  1820.         yyval.action.code = W_GOTO;
  1821.         yyval.action.command = strdup(yyvsp[0].str);
  1822. yyval.action.str = cat2_str(make1_str("goto "), yyvsp[0].str);
  1823. ;
  1824.     break;}
  1825. case 1255:
  1826. #line 5572 "preproc.y"
  1827. {
  1828.         yyval.action.code = W_GOTO;
  1829.         yyval.action.command = strdup(yyvsp[0].str);
  1830. yyval.action.str = cat2_str(make1_str("goto "), yyvsp[0].str);
  1831. ;
  1832.     break;}
  1833. case 1256:
  1834. #line 5577 "preproc.y"
  1835. {
  1836. yyval.action.code = W_DO;
  1837. yyval.action.command = make4_str(yyvsp[-3].str, make1_str("("), yyvsp[-1].str, make1_str(")"));
  1838. yyval.action.str = cat2_str(make1_str("do"), mm_strdup(yyval.action.command));
  1839. ;
  1840.     break;}
  1841. case 1257:
  1842. #line 5582 "preproc.y"
  1843. {
  1844.         yyval.action.code = W_BREAK;
  1845.         yyval.action.command = NULL;
  1846.         yyval.action.str = make1_str("break");
  1847. ;
  1848.     break;}
  1849. case 1258:
  1850. #line 5587 "preproc.y"
  1851. {
  1852. yyval.action.code = W_DO;
  1853. yyval.action.command = make4_str(yyvsp[-3].str, make1_str("("), yyvsp[-1].str, make1_str(")"));
  1854. yyval.action.str = cat2_str(make1_str("call"), mm_strdup(yyval.action.command));
  1855. ;
  1856.     break;}
  1857. case 1259:
  1858. #line 5595 "preproc.y"
  1859. {
  1860. yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str);
  1861. ;
  1862.     break;}
  1863. case 1260:
  1864. #line 5599 "preproc.y"
  1865. { yyval.str = yyvsp[0].str;  ;
  1866.     break;}
  1867. case 1261:
  1868. #line 5601 "preproc.y"
  1869. { yyval.str = yyvsp[0].str;  ;
  1870.     break;}
  1871. case 1262:
  1872. #line 5603 "preproc.y"
  1873. {
  1874. yyval.str = yyvsp[0].str;
  1875. ;
  1876.     break;}
  1877. case 1263:
  1878. #line 5607 "preproc.y"
  1879. { yyval.str = cat2_str(make1_str("-"), yyvsp[0].str); ;
  1880.     break;}
  1881. case 1264:
  1882. #line 5609 "preproc.y"
  1883. {       yyval.str = cat2_str(make1_str("%"), yyvsp[0].str); ;
  1884.     break;}
  1885. case 1265:
  1886. #line 5611 "preproc.y"
  1887. {       yyval.str = cat2_str(yyvsp[-1].str, make1_str("%")); ;
  1888.     break;}
  1889. case 1266:
  1890. #line 5613 "preproc.y"
  1891. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("+"), yyvsp[0].str); ;
  1892.     break;}
  1893. case 1267:
  1894. #line 5615 "preproc.y"
  1895. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("-"), yyvsp[0].str); ;
  1896.     break;}
  1897. case 1268:
  1898. #line 5617 "preproc.y"
  1899. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("/"), yyvsp[0].str); ;
  1900.     break;}
  1901. case 1269:
  1902. #line 5619 "preproc.y"
  1903. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("%"), yyvsp[0].str); ;
  1904.     break;}
  1905. case 1270:
  1906. #line 5621 "preproc.y"
  1907. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("*"), yyvsp[0].str); ;
  1908.     break;}
  1909. case 1271:
  1910. #line 5623 "preproc.y"
  1911. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("<"), yyvsp[0].str); ;
  1912.     break;}
  1913. case 1272:
  1914. #line 5625 "preproc.y"
  1915. { yyval.str = cat3_str(yyvsp[-2].str, make1_str(">"), yyvsp[0].str); ;
  1916.     break;}
  1917. case 1273:
  1918. #line 5627 "preproc.y"
  1919. {       yyval.str = cat2_str(yyvsp[-2].str, make1_str("= NULL")); ;
  1920.     break;}
  1921. case 1274:
  1922. #line 5629 "preproc.y"
  1923. {       yyval.str = cat2_str(make1_str("= NULL"), yyvsp[0].str); ;
  1924.     break;}
  1925. case 1275:
  1926. #line 5631 "preproc.y"
  1927. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("="), yyvsp[0].str); ;
  1928.     break;}
  1929. case 1276:
  1930. #line 5635 "preproc.y"
  1931. { yyval.str = cat2_str(make1_str(";"), yyvsp[0].str); ;
  1932.     break;}
  1933. case 1277:
  1934. #line 5637 "preproc.y"
  1935. { yyval.str = cat2_str(make1_str("|"), yyvsp[0].str); ;
  1936.     break;}
  1937. case 1278:
  1938. #line 5639 "preproc.y"
  1939. {
  1940. yyval.str = cat3_str(yyvsp[-2].str, make1_str("::"), yyvsp[0].str);
  1941. ;
  1942.     break;}
  1943. case 1279:
  1944. #line 5643 "preproc.y"
  1945. {
  1946. yyval.str = cat3_str(make2_str(make1_str("cast("), yyvsp[-3].str), make1_str("as"), make2_str(yyvsp[-1].str, make1_str(")")));
  1947. ;
  1948.     break;}
  1949. case 1280:
  1950. #line 5647 "preproc.y"
  1951. { yyval.str = make3_str(make1_str("("), yyvsp[-1].str, make1_str(")")); ;
  1952.     break;}
  1953. case 1281:
  1954. #line 5649 "preproc.y"
  1955. { yyval.str = cat3_str(yyvsp[-2].str, yyvsp[-1].str, yyvsp[0].str); ;
  1956.     break;}
  1957. case 1282:
  1958. #line 5651 "preproc.y"
  1959. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("like"), yyvsp[0].str); ;
  1960.     break;}
  1961. case 1283:
  1962. #line 5653 "preproc.y"
  1963. { yyval.str = cat3_str(yyvsp[-3].str, make1_str("not like"), yyvsp[0].str); ;
  1964.     break;}
  1965. case 1284:
  1966. #line 5655 "preproc.y"
  1967. { yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str); ;
  1968.     break;}
  1969. case 1285:
  1970. #line 5657 "preproc.y"
  1971. { yyval.str = cat2_str(yyvsp[-1].str, yyvsp[0].str); ;
  1972.     break;}
  1973. case 1286:
  1974. #line 5659 "preproc.y"
  1975. {
  1976. yyval.str = cat2_str(yyvsp[-3].str, make1_str("(*)")); 
  1977. ;
  1978.     break;}
  1979. case 1287:
  1980. #line 5663 "preproc.y"
  1981. {
  1982. yyval.str = cat2_str(yyvsp[-2].str, make1_str("()")); 
  1983. ;
  1984.     break;}
  1985. case 1288:
  1986. #line 5667 "preproc.y"
  1987. {
  1988. yyval.str = make4_str(yyvsp[-3].str, make1_str("("), yyvsp[-1].str, make1_str(")")); 
  1989. ;
  1990.     break;}
  1991. case 1289:
  1992. #line 5671 "preproc.y"
  1993. {
  1994. yyval.str = make1_str("current_date");
  1995. ;
  1996.     break;}
  1997. case 1290:
  1998. #line 5675 "preproc.y"
  1999. {
  2000. yyval.str = make1_str("current_time");
  2001. ;
  2002.     break;}
  2003. case 1291:
  2004. #line 5679 "preproc.y"
  2005. {
  2006. if (atol(yyvsp[-1].str) != 0)
  2007. fprintf(stderr,"CURRENT_TIME(%s) precision not implemented; zero used instead", yyvsp[-1].str);
  2008. yyval.str = make1_str("current_time");
  2009. ;
  2010.     break;}
  2011. case 1292:
  2012. #line 5685 "preproc.y"
  2013. {
  2014. yyval.str = make1_str("current_timestamp");
  2015. ;
  2016.     break;}
  2017. case 1293:
  2018. #line 5689 "preproc.y"
  2019. {
  2020. if (atol(yyvsp[-1].str) != 0)
  2021. fprintf(stderr,"CURRENT_TIMESTAMP(%s) precision not implemented; zero used instead",yyvsp[-1].str);
  2022. yyval.str = make1_str("current_timestamp");
  2023. ;
  2024.     break;}
  2025. case 1294:
  2026. #line 5695 "preproc.y"
  2027. {
  2028. yyval.str = make1_str("current_user");
  2029. ;
  2030.     break;}
  2031. case 1295:
  2032. #line 5699 "preproc.y"
  2033. {
  2034.                  yyval.str = make1_str("user");
  2035.       ;
  2036.     break;}
  2037. case 1296:
  2038. #line 5703 "preproc.y"
  2039. {
  2040. yyval.str = make3_str(make1_str("exists("), yyvsp[-1].str, make1_str(")"));
  2041. ;
  2042.     break;}
  2043. case 1297:
  2044. #line 5707 "preproc.y"
  2045. {
  2046. yyval.str = make3_str(make1_str("extract("), yyvsp[-1].str, make1_str(")"));
  2047. ;
  2048.     break;}
  2049. case 1298:
  2050. #line 5711 "preproc.y"
  2051. {
  2052. yyval.str = make3_str(make1_str("position("), yyvsp[-1].str, make1_str(")"));
  2053. ;
  2054.     break;}
  2055. case 1299:
  2056. #line 5715 "preproc.y"
  2057. {
  2058. yyval.str = make3_str(make1_str("substring("), yyvsp[-1].str, make1_str(")"));
  2059. ;
  2060.     break;}
  2061. case 1300:
  2062. #line 5720 "preproc.y"
  2063. {
  2064. yyval.str = make3_str(make1_str("trim(both"), yyvsp[-1].str, make1_str(")"));
  2065. ;
  2066.     break;}
  2067. case 1301:
  2068. #line 5724 "preproc.y"
  2069. {
  2070. yyval.str = make3_str(make1_str("trim(leading"), yyvsp[-1].str, make1_str(")"));
  2071. ;
  2072.     break;}
  2073. case 1302:
  2074. #line 5728 "preproc.y"
  2075. {
  2076. yyval.str = make3_str(make1_str("trim(trailing"), yyvsp[-1].str, make1_str(")"));
  2077. ;
  2078.     break;}
  2079. case 1303:
  2080. #line 5732 "preproc.y"
  2081. {
  2082. yyval.str = make3_str(make1_str("trim("), yyvsp[-1].str, make1_str(")"));
  2083. ;
  2084.     break;}
  2085. case 1304:
  2086. #line 5736 "preproc.y"
  2087. { yyval.str = cat2_str(yyvsp[-1].str, make1_str("isnull")); ;
  2088.     break;}
  2089. case 1305:
  2090. #line 5738 "preproc.y"
  2091. { yyval.str = cat2_str(yyvsp[-2].str, make1_str("is null")); ;
  2092.     break;}
  2093. case 1306:
  2094. #line 5740 "preproc.y"
  2095. { yyval.str = cat2_str(yyvsp[-1].str, make1_str("notnull")); ;
  2096.     break;}
  2097. case 1307:
  2098. #line 5742 "preproc.y"
  2099. { yyval.str = cat2_str(yyvsp[-3].str, make1_str("is not null")); ;
  2100.     break;}
  2101. case 1308:
  2102. #line 5749 "preproc.y"
  2103. {
  2104. { yyval.str = cat2_str(yyvsp[-2].str, make1_str("is true")); }
  2105. ;
  2106.     break;}
  2107. case 1309:
  2108. #line 5753 "preproc.y"
  2109. {
  2110. { yyval.str = cat2_str(yyvsp[-3].str, make1_str("is not false")); }
  2111. ;
  2112.     break;}
  2113. case 1310:
  2114. #line 5757 "preproc.y"
  2115. {
  2116. { yyval.str = cat2_str(yyvsp[-2].str, make1_str("is false")); }
  2117. ;
  2118.     break;}
  2119. case 1311:
  2120. #line 5761 "preproc.y"
  2121. {
  2122. { yyval.str = cat2_str(yyvsp[-3].str, make1_str("is not true")); }
  2123. ;
  2124.     break;}
  2125. case 1312:
  2126. #line 5765 "preproc.y"
  2127. {
  2128. yyval.str = cat5_str(yyvsp[-4].str, make1_str("between"), yyvsp[-2].str, make1_str("and"), yyvsp[0].str); 
  2129. ;
  2130.     break;}
  2131. case 1313:
  2132. #line 5769 "preproc.y"
  2133. {
  2134. yyval.str = cat5_str(yyvsp[-5].str, make1_str("not between"), yyvsp[-2].str, make1_str("and"), yyvsp[0].str); 
  2135. ;
  2136.     break;}
  2137. case 1314:
  2138. #line 5773 "preproc.y"
  2139. {
  2140. yyval.str = make4_str(yyvsp[-4].str, make1_str(" in ("), yyvsp[-1].str, make1_str(")")); 
  2141. ;
  2142.     break;}
  2143. case 1315:
  2144. #line 5777 "preproc.y"
  2145. {
  2146. yyval.str = make4_str(yyvsp[-5].str, make1_str(" not in ("), yyvsp[-1].str, make1_str(")")); 
  2147. ;
  2148.     break;}
  2149. case 1316:
  2150. #line 5781 "preproc.y"
  2151. {
  2152. yyval.str = cat3_str(yyvsp[-4].str, yyvsp[-3].str, make3_str(make1_str("("), yyvsp[-1].str, make1_str(")"))); 
  2153. ;
  2154.     break;}
  2155. case 1317:
  2156. #line 5785 "preproc.y"
  2157. {
  2158. yyval.str = make4_str(yyvsp[-4].str, make1_str("+("), yyvsp[-1].str, make1_str(")")); 
  2159. ;
  2160.     break;}
  2161. case 1318:
  2162. #line 5789 "preproc.y"
  2163. {
  2164. yyval.str = make4_str(yyvsp[-4].str, make1_str("-("), yyvsp[-1].str, make1_str(")")); 
  2165. ;
  2166.     break;}
  2167. case 1319:
  2168. #line 5793 "preproc.y"
  2169. {
  2170. yyval.str = make4_str(yyvsp[-4].str, make1_str("/("), yyvsp[-1].str, make1_str(")")); 
  2171. ;
  2172.     break;}
  2173. case 1320:
  2174. #line 5797 "preproc.y"
  2175. {
  2176. yyval.str = make4_str(yyvsp[-4].str, make1_str("%("), yyvsp[-1].str, make1_str(")")); 
  2177. ;
  2178.     break;}
  2179. case 1321:
  2180. #line 5801 "preproc.y"
  2181. {
  2182. yyval.str = make4_str(yyvsp[-4].str, make1_str("*("), yyvsp[-1].str, make1_str(")")); 
  2183. ;
  2184.     break;}
  2185. case 1322:
  2186. #line 5805 "preproc.y"
  2187. {
  2188. yyval.str = make4_str(yyvsp[-4].str, make1_str("<("), yyvsp[-1].str, make1_str(")")); 
  2189. ;
  2190.     break;}
  2191. case 1323:
  2192. #line 5809 "preproc.y"
  2193. {
  2194. yyval.str = make4_str(yyvsp[-4].str, make1_str(">("), yyvsp[-1].str, make1_str(")")); 
  2195. ;
  2196.     break;}
  2197. case 1324:
  2198. #line 5813 "preproc.y"
  2199. {
  2200. yyval.str = make4_str(yyvsp[-4].str, make1_str("=("), yyvsp[-1].str, make1_str(")")); 
  2201. ;
  2202.     break;}
  2203. case 1325:
  2204. #line 5817 "preproc.y"
  2205. {
  2206. yyval.str = cat3_str(yyvsp[-5].str, yyvsp[-4].str, make3_str(make1_str("any ("), yyvsp[-1].str, make1_str(")"))); 
  2207. ;
  2208.     break;}
  2209. case 1326:
  2210. #line 5821 "preproc.y"
  2211. {
  2212. yyval.str = make4_str(yyvsp[-5].str, make1_str("+ any("), yyvsp[-1].str, make1_str(")")); 
  2213. ;
  2214.     break;}
  2215. case 1327:
  2216. #line 5825 "preproc.y"
  2217. {
  2218. yyval.str = make4_str(yyvsp[-5].str, make1_str("- any("), yyvsp[-1].str, make1_str(")")); 
  2219. ;
  2220.     break;}
  2221. case 1328:
  2222. #line 5829 "preproc.y"
  2223. {
  2224. yyval.str = make4_str(yyvsp[-5].str, make1_str("/ any("), yyvsp[-1].str, make1_str(")")); 
  2225. ;
  2226.     break;}
  2227. case 1329:
  2228. #line 5833 "preproc.y"
  2229. {
  2230. yyval.str = make4_str(yyvsp[-5].str, make1_str("% any("), yyvsp[-1].str, make1_str(")")); 
  2231. ;
  2232.     break;}
  2233. case 1330:
  2234. #line 5837 "preproc.y"
  2235. {
  2236. yyval.str = make4_str(yyvsp[-5].str, make1_str("* any("), yyvsp[-1].str, make1_str(")")); 
  2237. ;
  2238.     break;}
  2239. case 1331:
  2240. #line 5841 "preproc.y"
  2241. {
  2242. yyval.str = make4_str(yyvsp[-5].str, make1_str("< any("), yyvsp[-1].str, make1_str(")")); 
  2243. ;
  2244.     break;}
  2245. case 1332:
  2246. #line 5845 "preproc.y"
  2247. {
  2248. yyval.str = make4_str(yyvsp[-5].str, make1_str("> any("), yyvsp[-1].str, make1_str(")")); 
  2249. ;
  2250.     break;}
  2251. case 1333:
  2252. #line 5849 "preproc.y"
  2253. {
  2254. yyval.str = make4_str(yyvsp[-5].str, make1_str("= any("), yyvsp[-1].str, make1_str(")")); 
  2255. ;
  2256.     break;}
  2257. case 1334:
  2258. #line 5853 "preproc.y"
  2259. {
  2260. yyval.str = cat3_str(yyvsp[-5].str, yyvsp[-4].str, make3_str(make1_str("all ("), yyvsp[-1].str, make1_str(")"))); 
  2261. ;
  2262.     break;}
  2263. case 1335:
  2264. #line 5857 "preproc.y"
  2265. {
  2266. yyval.str = make4_str(yyvsp[-5].str, make1_str("+ all("), yyvsp[-1].str, make1_str(")")); 
  2267. ;
  2268.     break;}
  2269. case 1336:
  2270. #line 5861 "preproc.y"
  2271. {
  2272. yyval.str = make4_str(yyvsp[-5].str, make1_str("- all("), yyvsp[-1].str, make1_str(")")); 
  2273. ;
  2274.     break;}
  2275. case 1337:
  2276. #line 5865 "preproc.y"
  2277. {
  2278. yyval.str = make4_str(yyvsp[-5].str, make1_str("/ all("), yyvsp[-1].str, make1_str(")")); 
  2279. ;
  2280.     break;}
  2281. case 1338:
  2282. #line 5869 "preproc.y"
  2283. {
  2284. yyval.str = make4_str(yyvsp[-5].str, make1_str("% all("), yyvsp[-1].str, make1_str(")")); 
  2285. ;
  2286.     break;}
  2287. case 1339:
  2288. #line 5873 "preproc.y"
  2289. {
  2290. yyval.str = make4_str(yyvsp[-5].str, make1_str("* all("), yyvsp[-1].str, make1_str(")")); 
  2291. ;
  2292.     break;}
  2293. case 1340:
  2294. #line 5877 "preproc.y"
  2295. {
  2296. yyval.str = make4_str(yyvsp[-5].str, make1_str("< all("), yyvsp[-1].str, make1_str(")")); 
  2297. ;
  2298.     break;}
  2299. case 1341:
  2300. #line 5881 "preproc.y"
  2301. {
  2302. yyval.str = make4_str(yyvsp[-5].str, make1_str("> all("), yyvsp[-1].str, make1_str(")")); 
  2303. ;
  2304.     break;}
  2305. case 1342:
  2306. #line 5885 "preproc.y"
  2307. {
  2308. yyval.str = make4_str(yyvsp[-5].str, make1_str("=all("), yyvsp[-1].str, make1_str(")")); 
  2309. ;
  2310.     break;}
  2311. case 1343:
  2312. #line 5889 "preproc.y"
  2313. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("and"), yyvsp[0].str); ;
  2314.     break;}
  2315. case 1344:
  2316. #line 5891 "preproc.y"
  2317. { yyval.str = cat3_str(yyvsp[-2].str, make1_str("or"), yyvsp[0].str); ;
  2318.     break;}
  2319. case 1345:
  2320. #line 5893 "preproc.y"
  2321. { yyval.str = cat2_str(make1_str("not"), yyvsp[0].str); ;
  2322.     break;}
  2323. case 1346:
  2324. #line 5895 "preproc.y"
  2325. {       yyval.str = yyvsp[0].str; ;
  2326.     break;}
  2327. case 1347:
  2328. #line 5897 "preproc.y"
  2329. {  yyval.str = yyvsp[0].str; ;
  2330.     break;}
  2331. case 1350:
  2332. #line 5902 "preproc.y"
  2333. { reset_variables();;
  2334.     break;}
  2335. case 1351:
  2336. #line 5904 "preproc.y"
  2337. { yyval.str = make1_str(""); ;
  2338.     break;}
  2339. case 1352:
  2340. #line 5905 "preproc.y"
  2341. { yyval.str = make2_str(yyvsp[-1].str, yyvsp[0].str); ;
  2342.     break;}
  2343. case 1353:
  2344. #line 5907 "preproc.y"
  2345. { yyval.str = yyvsp[0].str; ;
  2346.     break;}
  2347. case 1354:
  2348. #line 5908 "preproc.y"
  2349. { yyval.str = make2_str(yyvsp[-1].str, yyvsp[0].str); ;
  2350.     break;}
  2351. case 1355:
  2352. #line 5910 "preproc.y"
  2353. {
  2354. add_variable(&argsresult, find_variable(yyvsp[-1].str), (yyvsp[0].str == NULL) ? &no_indicator : find_variable(yyvsp[0].str)); 
  2355. ;
  2356.     break;}
  2357. case 1356:
  2358. #line 5914 "preproc.y"
  2359. {
  2360. add_variable(&argsinsert, find_variable(yyvsp[-1].str), (yyvsp[0].str == NULL) ? &no_indicator : find_variable(yyvsp[0].str)); 
  2361. ;
  2362.     break;}
  2363. case 1357:
  2364. #line 5918 "preproc.y"
  2365. {
  2366. add_variable(&argsinsert, find_variable(yyvsp[0].str), &no_indicator); 
  2367. yyval.str = make1_str("?");
  2368. ;
  2369.     break;}
  2370. case 1358:
  2371. #line 5923 "preproc.y"
  2372. { yyval.str = yyvsp[0].str; ;
  2373.     break;}
  2374. case 1359:
  2375. #line 5925 "preproc.y"
  2376. { yyval.str = NULL; ;
  2377.     break;}
  2378. case 1360:
  2379. #line 5926 "preproc.y"
  2380. { check_indicator((find_variable(yyvsp[0].str))->type); yyval.str = yyvsp[0].str; ;
  2381.     break;}
  2382. case 1361:
  2383. #line 5927 "preproc.y"
  2384. { check_indicator((find_variable(yyvsp[0].str))->type); yyval.str = yyvsp[0].str; ;
  2385.     break;}
  2386. case 1362:
  2387. #line 5928 "preproc.y"
  2388. { check_indicator((find_variable(yyvsp[0].str))->type); yyval.str = yyvsp[0].str; ;
  2389.     break;}
  2390. case 1363:
  2391. #line 5930 "preproc.y"
  2392. { yyval.str = yyvsp[0].str; ;
  2393.     break;}
  2394. case 1364:
  2395. #line 5931 "preproc.y"
  2396. { yyval.str = yyvsp[0].str; ;
  2397.     break;}
  2398. case 1365:
  2399. #line 5936 "preproc.y"
  2400. { yyval.str = yyvsp[0].str; ;
  2401.     break;}
  2402. case 1366:
  2403. #line 5938 "preproc.y"
  2404. { yyval.str = yyvsp[0].str; ;
  2405.     break;}
  2406. case 1367:
  2407. #line 5940 "preproc.y"
  2408. { yyval.str = yyvsp[0].str; ;
  2409.     break;}
  2410. case 1368:
  2411. #line 5942 "preproc.y"
  2412. {
  2413. yyval.str = make2_str(yyvsp[-1].str, yyvsp[0].str);
  2414. ;
  2415.     break;}
  2416. case 1370:
  2417. #line 5946 "preproc.y"
  2418. { yyval.str = make1_str(";"); ;
  2419.     break;}
  2420. case 1371:
  2421. #line 5948 "preproc.y"
  2422. { yyval.str = yyvsp[0].str; ;
  2423.     break;}
  2424. case 1372:
  2425. #line 5949 "preproc.y"
  2426. { yyval.str = make3_str(make1_str("""), yyvsp[0].str, make1_str(""")); ;
  2427.     break;}
  2428. case 1373:
  2429. #line 5950 "preproc.y"
  2430. { yyval.str = yyvsp[0].str; ;
  2431.     break;}
  2432. case 1374:
  2433. #line 5951 "preproc.y"
  2434. { yyval.str = yyvsp[0].str; ;
  2435.     break;}
  2436. case 1375:
  2437. #line 5952 "preproc.y"
  2438. { yyval.str = make1_str("*"); ;
  2439.     break;}
  2440. case 1376:
  2441. #line 5953 "preproc.y"
  2442. { yyval.str = make1_str("+"); ;
  2443.     break;}
  2444. case 1377:
  2445. #line 5954 "preproc.y"
  2446. { yyval.str = make1_str("-"); ;
  2447.     break;}
  2448. case 1378:
  2449. #line 5955 "preproc.y"
  2450. { yyval.str = make1_str("/"); ;
  2451.     break;}
  2452. case 1379:
  2453. #line 5956 "preproc.y"
  2454. { yyval.str = make1_str("%"); ;
  2455.     break;}
  2456. case 1380:
  2457. #line 5957 "preproc.y"
  2458. { yyval.str = make1_str("auto"); ;
  2459.     break;}
  2460. case 1381:
  2461. #line 5958 "preproc.y"
  2462. { yyval.str = make1_str("bool"); ;
  2463.     break;}
  2464. case 1382:
  2465. #line 5959 "preproc.y"
  2466. { yyval.str = make1_str("char"); ;
  2467.     break;}
  2468. case 1383:
  2469. #line 5960 "preproc.y"
  2470. { yyval.str = make1_str("const"); ;
  2471.     break;}
  2472. case 1384:
  2473. #line 5961 "preproc.y"
  2474. { yyval.str = make1_str("double"); ;
  2475.     break;}
  2476. case 1385:
  2477. #line 5962 "preproc.y"
  2478. { yyval.str = make1_str("enum"); ;
  2479.     break;}
  2480. case 1386:
  2481. #line 5963 "preproc.y"
  2482. { yyval.str = make1_str("extern"); ;
  2483.     break;}
  2484. case 1387:
  2485. #line 5964 "preproc.y"
  2486. { yyval.str = make1_str("float"); ;
  2487.     break;}
  2488. case 1388:
  2489. #line 5965 "preproc.y"
  2490. { yyval.str = make1_str("int"); ;
  2491.     break;}
  2492. case 1389:
  2493. #line 5966 "preproc.y"
  2494. { yyval.str = make1_str("long"); ;
  2495.     break;}
  2496. case 1390:
  2497. #line 5967 "preproc.y"
  2498. { yyval.str = make1_str("register"); ;
  2499.     break;}
  2500. case 1391:
  2501. #line 5968 "preproc.y"
  2502. { yyval.str = make1_str("short"); ;
  2503.     break;}
  2504. case 1392:
  2505. #line 5969 "preproc.y"
  2506. { yyval.str = make1_str("signed"); ;
  2507.     break;}
  2508. case 1393:
  2509. #line 5970 "preproc.y"
  2510. { yyval.str = make1_str("static"); ;
  2511.     break;}
  2512. case 1394:
  2513. #line 5971 "preproc.y"
  2514. { yyval.str = make1_str("struct"); ;
  2515.     break;}
  2516. case 1395:
  2517. #line 5972 "preproc.y"
  2518. { yyval.str = make1_str("union"); ;
  2519.     break;}
  2520. case 1396:
  2521. #line 5973 "preproc.y"
  2522. { yyval.str = make1_str("unsigned"); ;
  2523.     break;}
  2524. case 1397:
  2525. #line 5974 "preproc.y"
  2526. { yyval.str = make1_str("varchar"); ;
  2527.     break;}
  2528. case 1398:
  2529. #line 5975 "preproc.y"
  2530. { yyval.str = make_name(); ;
  2531.     break;}
  2532. case 1399:
  2533. #line 5976 "preproc.y"
  2534. { yyval.str = make1_str("["); ;
  2535.     break;}
  2536. case 1400:
  2537. #line 5977 "preproc.y"
  2538. { yyval.str = make1_str("]"); ;
  2539.     break;}
  2540. case 1401:
  2541. #line 5978 "preproc.y"
  2542. { yyval.str = make1_str("("); ;
  2543.     break;}
  2544. case 1402:
  2545. #line 5979 "preproc.y"
  2546. { yyval.str = make1_str(")"); ;
  2547.     break;}
  2548. case 1403:
  2549. #line 5980 "preproc.y"
  2550. { yyval.str = make1_str("="); ;
  2551.     break;}
  2552. case 1404:
  2553. #line 5981 "preproc.y"
  2554. { yyval.str = make1_str(","); ;
  2555.     break;}
  2556. case 1405:
  2557. #line 5983 "preproc.y"
  2558. { yyval.str = yyvsp[0].str; ;
  2559.     break;}
  2560. case 1406:
  2561. #line 5984 "preproc.y"
  2562. { yyval.str = make3_str(make1_str("""), yyvsp[0].str, make1_str("""));;
  2563.     break;}
  2564. case 1407:
  2565. #line 5985 "preproc.y"
  2566. { yyval.str = yyvsp[0].str; ;
  2567.     break;}
  2568. case 1408:
  2569. #line 5986 "preproc.y"
  2570. { yyval.str = yyvsp[0].str; ;
  2571.     break;}
  2572. case 1409:
  2573. #line 5987 "preproc.y"
  2574. { yyval.str = make1_str(","); ;
  2575.     break;}
  2576. case 1410:
  2577. #line 5989 "preproc.y"
  2578. { yyval.str = yyvsp[0].str; ;
  2579.     break;}
  2580. case 1411:
  2581. #line 5990 "preproc.y"
  2582. { yyval.str = make3_str(make1_str("""), yyvsp[0].str, make1_str(""")); ;
  2583.     break;}
  2584. case 1412:
  2585. #line 5991 "preproc.y"
  2586. { yyval.str = yyvsp[0].str; ;
  2587.     break;}
  2588. case 1413:
  2589. #line 5992 "preproc.y"
  2590. { yyval.str = yyvsp[0].str; ;
  2591.     break;}
  2592. case 1414:
  2593. #line 5993 "preproc.y"
  2594. { yyval.str = make3_str(make1_str("{"), yyvsp[-1].str, make1_str("}")); ;
  2595.     break;}
  2596. case 1415:
  2597. #line 5995 "preproc.y"
  2598. {
  2599.     braces_open++;
  2600.     yyval.str = make1_str("{");
  2601. ;
  2602.     break;}
  2603. case 1416:
  2604. #line 6000 "preproc.y"
  2605. {
  2606.     remove_variables(braces_open--);
  2607.     yyval.str = make1_str("}");
  2608. ;
  2609.     break;}
  2610. }
  2611.    /* the action file gets copied in in place of this dollarsign */
  2612. #line 543 "/usr/share/misc/bison.simple"
  2614.   yyvsp -= yylen;
  2615.   yyssp -= yylen;
  2616. #ifdef YYLSP_NEEDED
  2617.   yylsp -= yylen;
  2618. #endif
  2620. #if YYDEBUG != 0
  2621.   if (yydebug)
  2622.     {
  2623.       short *ssp1 = yyss - 1;
  2624.       fprintf (stderr, "state stack now");
  2625.       while (ssp1 != yyssp)
  2626. fprintf (stderr, " %d", *++ssp1);
  2627.       fprintf (stderr, "n");
  2628.     }
  2629. #endif
  2631.   *++yyvsp = yyval;
  2633. #ifdef YYLSP_NEEDED
  2634.   yylsp++;
  2635.   if (yylen == 0)
  2636.     {
  2637.       yylsp->first_line = yylloc.first_line;
  2638.       yylsp->first_column = yylloc.first_column;
  2639.       yylsp->last_line = (yylsp-1)->last_line;
  2640.       yylsp->last_column = (yylsp-1)->last_column;
  2641.       yylsp->text = 0;
  2642.     }
  2643.   else
  2644.     {
  2645.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  2646.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  2647.     }
  2648. #endif
  2650.   /* Now "shift" the result of the reduction.
  2651.      Determine what state that goes to,
  2652.      based on the state we popped back to
  2653.      and the rule number reduced by.  */
  2655.   yyn = yyr1[yyn];
  2657.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  2658.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  2659.     yystate = yytable[yystate];
  2660.   else
  2661.     yystate = yydefgoto[yyn - YYNTBASE];
  2663.   goto yynewstate;
  2665. yyerrlab:   /* here on detecting error */
  2667.   if (! yyerrstatus)
  2668.     /* If not already recovering from an error, report this error.  */
  2669.     {
  2670.       ++yynerrs;
  2672. #ifdef YYERROR_VERBOSE
  2673.       yyn = yypact[yystate];
  2675.       if (yyn > YYFLAG && yyn < YYLAST)
  2676. {
  2677.   int size = 0;
  2678.   char *msg;
  2679.   int x, count;
  2681.   count = 0;
  2682.   /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
  2683.   for (x = (yyn < 0 ? -yyn : 0);
  2684.        x < (sizeof(yytname) / sizeof(char *)); x++)
  2685.     if (yycheck[x + yyn] == x)
  2686.       size += strlen(yytname[x]) + 15, count++;
  2687.   msg = (char *) malloc(size + 15);
  2688.   if (msg != 0)
  2689.     {
  2690.       strcpy(msg, "parse error");
  2692.       if (count < 5)
  2693. {
  2694.   count = 0;
  2695.   for (x = (yyn < 0 ? -yyn : 0);
  2696.        x < (sizeof(yytname) / sizeof(char *)); x++)
  2697.     if (yycheck[x + yyn] == x)
  2698.       {
  2699. strcat(msg, count == 0 ? ", expecting `" : " or `");
  2700. strcat(msg, yytname[x]);
  2701. strcat(msg, "'");
  2702. count++;
  2703.       }
  2704. }
  2705.       yyerror(msg);
  2706.       free(msg);
  2707.     }
  2708.   else
  2709.     yyerror ("parse error; also virtual memory exceeded");
  2710. }
  2711.       else
  2712. #endif /* YYERROR_VERBOSE */
  2713. yyerror("parse error");
  2714.     }
  2716.   goto yyerrlab1;
  2717. yyerrlab1:   /* here on error raised explicitly by an action */
  2719.   if (yyerrstatus == 3)
  2720.     {
  2721.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  2723.       /* return failure if at end of input */
  2724.       if (yychar == YYEOF)
  2725. YYABORT;
  2727. #if YYDEBUG != 0
  2728.       if (yydebug)
  2729. fprintf(stderr, "Discarding token %d (%s).n", yychar, yytname[yychar1]);
  2730. #endif
  2732.       yychar = YYEMPTY;
  2733.     }
  2735.   /* Else will try to reuse lookahead token
  2736.      after shifting the error token.  */
  2738.   yyerrstatus = 3; /* Each real token shifted decrements this */
  2740.   goto yyerrhandle;
  2742. yyerrdefault:  /* current state does not do anything special for the error token. */
  2744. #if 0
  2745.   /* This is wrong; only states that explicitly want error tokens
  2746.      should shift them.  */
  2747.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  2748.   if (yyn) goto yydefault;
  2749. #endif
  2751. yyerrpop:   /* pop the current state because it cannot handle the error token */
  2753.   if (yyssp == yyss) YYABORT;
  2754.   yyvsp--;
  2755.   yystate = *--yyssp;
  2756. #ifdef YYLSP_NEEDED
  2757.   yylsp--;
  2758. #endif
  2760. #if YYDEBUG != 0
  2761.   if (yydebug)
  2762.     {
  2763.       short *ssp1 = yyss - 1;
  2764.       fprintf (stderr, "Error: state stack now");
  2765.       while (ssp1 != yyssp)
  2766. fprintf (stderr, " %d", *++ssp1);
  2767.       fprintf (stderr, "n");
  2768.     }
  2769. #endif
  2771. yyerrhandle:
  2773.   yyn = yypact[yystate];
  2774.   if (yyn == YYFLAG)
  2775.     goto yyerrdefault;
  2777.   yyn += YYTERROR;
  2778.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  2779.     goto yyerrdefault;
  2781.   yyn = yytable[yyn];
  2782.   if (yyn < 0)
  2783.     {
  2784.       if (yyn == YYFLAG)
  2785. goto yyerrpop;
  2786.       yyn = -yyn;
  2787.       goto yyreduce;
  2788.     }
  2789.   else if (yyn == 0)
  2790.     goto yyerrpop;
  2792.   if (yyn == YYFINAL)
  2793.     YYACCEPT;
  2795. #if YYDEBUG != 0
  2796.   if (yydebug)
  2797.     fprintf(stderr, "Shifting error token, ");
  2798. #endif
  2800.   *++yyvsp = yylval;
  2801. #ifdef YYLSP_NEEDED
  2802.   *++yylsp = yylloc;
  2803. #endif
  2805.   yystate = yyn;
  2806.   goto yynewstate;
  2808.  yyacceptlab:
  2809.   /* YYACCEPT comes here.  */
  2810.   if (yyfree_stacks)
  2811.     {
  2812.       free (yyss);
  2813.       free (yyvs);
  2814. #ifdef YYLSP_NEEDED
  2815.       free (yyls);
  2816. #endif
  2817.     }
  2818.   return 0;
  2820.  yyabortlab:
  2821.   /* YYABORT comes here.  */
  2822.   if (yyfree_stacks)
  2823.     {
  2824.       free (yyss);
  2825.       free (yyvs);
  2826. #ifdef YYLSP_NEEDED
  2827.       free (yyls);
  2828. #endif
  2829.     }
  2830.   return 1;
  2831. }
  2832. #line 6005 "preproc.y"
  2835. void yyerror(char * error)
  2836. {
  2837.     fprintf(stderr, "%s:%d: %sn", input_filename, yylineno, error);
  2838.     exit(PARSE_ERROR);
  2839. }