home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ppcsmalleiffel / source.lha / bin_c / compile_to_c11.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  110.3 KB  |  3,199 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_c.h"
  9. T0* r338at(T338* C,T0* a1){
  10. T0* R=NULL;
  11. int _foo=0;
  12. _foo=r338has(C,a1);
  13. R=r943item(((T943*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_has_mem/*24*/);
  14. return R;
  15. }
  16. void r338expand(T338* C){
  17. int _old_size=0;
  18. int _i=0;
  19. C->_item_mem=0;
  20. _old_size=r943count(((T943*)((((T338*)C))->_store/*4*/)));
  21. r429resize(((T429*)((((T338*)C))->_chain/*12*/)),1,(2)*(_old_size));
  22. r52resize(((T52*)((((T338*)C))->_keys/*0*/)),1,(2)*(_old_size));
  23. r943resize(((T943*)((((T338*)C))->_store/*4*/)),1,(2)*(_old_size));
  24. _i=(_old_size)+(1);
  25. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  26. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  27. int b1=(_i)+(1);
  28. int b2=_i;
  29. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  30. }/*]*/
  31. _i=(_i)+(1);
  32. }
  33. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  34. int b1=(((T338*)C))->_free/*16*/;
  35. int b2=_i;
  36. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  37. }/*]*/
  38. C->_free=(_old_size)+(1);
  39. }
  40. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].empty*/
  41. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].free*/
  42. void r338make(T338* C){
  43. C->_modulus=(2)*(32);
  44. {T226*n=malloc(sizeof(*n));
  45. *n=M226;
  46. r226make(n,(((T338*)C))->_modulus/*20*/);
  47. C->_buckets=(T0*)n;
  48. }
  49. {T429*n=malloc(sizeof(*n));
  50. *n=M429;
  51. r429make(n,1,32);
  52. C->_chain=(T0*)n;
  53. }
  54. {T943*n=malloc(sizeof(*n));
  55. *n=M943;
  56. r943make(n,1,32);
  57. C->_store=(T0*)n;
  58. }
  59. {T52*n=malloc(sizeof(*n));
  60. *n=M52;
  61. r52make(n,1,32);
  62. C->_keys=(T0*)n;
  63. }
  64. r338initialize(C);
  65. }
  66. T0* r338item(T338* C,int a1){
  67. T0* R=NULL;
  68. /*IF*/if (((((T338*)C))->_item_mem/*28*/)==(0)) {
  69. r338first(C);
  70. while (!((a1)==((((T338*)C))->_item_mem/*28*/))) {
  71. r338forth(C);
  72. }
  73. R=r943item(((T943*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_item_mem_j/*32*/);
  74. }
  75.  else if (((((T338*)C))->_item_mem/*28*/)<=(a1)) {
  76. while (!((a1)==((((T338*)C))->_item_mem/*28*/))) {
  77. r338forth(C);
  78. }
  79. R=r943item(((T943*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_item_mem_j/*32*/);
  80. }
  81. else {
  82. C->_item_mem=0;
  83. R=r338item(C,a1);
  84. }
  85. /*FI*/return R;
  86. }
  87. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem_i*/
  88. void r338resize(T338* C,int a1){
  89. int _p=0;
  90. int _n=0;
  91. int _i=0;
  92. int _hash=0;
  93. r226copy(((T226*)(oBC672tmp_buckets)),(((T338*)C))->_buckets/*8*/);
  94. r226make(((T226*)((((T338*)C))->_buckets/*8*/)),a1);
  95. _i=0;
  96. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  97. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  98. while (!((_n)==(0))) {
  99. _p=r429item(((T429*)((((T338*)C))->_chain/*12*/)),_n);
  100. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T338*)C))->_keys/*0*/)),_n)))))%(a1);
  101. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  102. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  103. int b2=_n;
  104. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  105. }/*]*/
  106. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  107. /*]*/
  108. _n=_p;
  109. }
  110. _i=(_i)+(1);
  111. }
  112. C->_modulus=a1;
  113. C->_item_mem=0;
  114. }
  115. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem_j*/
  116. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem*/
  117. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].chain*/
  118. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].keys*/
  119. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].buckets*/
  120. int r338has(T338* C,T0* a1){
  121. int R=0;
  122. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  123. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T338*)C))->_modulus/*20*/)]/*)*/;
  124. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  125. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  126. }
  127. }
  128. /*FI*/R=((((T338*)C))->_has_mem/*24*/)!=(0);
  129. return R;
  130. }
  131. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].Min_size*/
  132. void r338forth(T338* C){
  133. int _i=0;
  134. /*IF*/if ((r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_item_mem_j/*32*/))!=(0)) {
  135. C->_item_mem_j=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_item_mem_j/*32*/);
  136. }
  137. else {
  138. _i=((((T338*)C))->_item_mem_i/*36*/)+(1);
  139. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  140. _i=(_i)+(1);
  141. }
  142. C->_item_mem_i=_i;
  143. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  144. }
  145. /*FI*/C->_item_mem=((((T338*)C))->_item_mem/*28*/)+(1);
  146. }
  147. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].store*/
  148. void r338put(T338* C,T0* a1,T0* a2){
  149. int _hash=0;
  150. _hash=(r7hash_code(((T7*)a2)))%((((T338*)C))->_modulus/*20*/);
  151. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  152. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  153. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  154. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  155. }
  156. /*IF*/if (((((T338*)C))->_has_mem/*24*/)==(0)) {
  157. /*IF*/if (((((T338*)C))->_count/*40*/)>=(r943count(((T943*)((((T338*)C))->_store/*4*/))))) {
  158. r338expand(C);
  159. }
  160. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T338*)C))->_keys/*0*/));
  161. T0* b1=a2;
  162. int b2=(((T338*)C))->_free/*16*/;
  163. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  164. }/*]*/
  165. /*[IRF3.6put*/{T943* C1=((T943*)((((T338*)C))->_store/*4*/));
  166. T0* b1=a1;
  167. int b2=(((T338*)C))->_free/*16*/;
  168. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  169. }/*]*/
  170. C->_has_mem=(((T338*)C))->_free/*16*/;
  171. C->_free=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_free/*16*/);
  172. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  173. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  174. int b2=(((T338*)C))->_has_mem/*24*/;
  175. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  176. }/*]*/
  177. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T338*)C))->_has_mem/*24*/);
  178. /*]*/
  179. C->_count=((((T338*)C))->_count/*40*/)+(1);
  180. /*IF*/if (((((T338*)C))->_count/*40*/)>(((((T338*)C))->_modulus/*20*/)*(2))) {
  181. r338resize(C,(2)*((((T338*)C))->_modulus/*20*/));
  182. }
  183. /*FI*/}
  184. /*FI*/}
  185. else {
  186. /*[IRF3.6put*/{T943* C1=((T943*)((((T338*)C))->_store/*4*/));
  187. T0* b1=a1;
  188. int b2=(((T338*)C))->_has_mem/*24*/;
  189. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  190. }/*]*/
  191. }
  192. /*FI*/C->_item_mem=0;
  193. }
  194. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].modulus*/
  195. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].count*/
  196. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].has_mem*/
  197. void r338first(T338* C){
  198. int _i=0;
  199. _i=0;
  200. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  201. _i=(_i)+(1);
  202. }
  203. C->_item_mem_i=_i;
  204. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  205. C->_item_mem=1;
  206. }
  207. void r338initialize(T338* C){
  208. int _i=0;
  209. C->_count=0;
  210. C->_free=1;
  211. C->_has_mem=0;
  212. C->_item_mem=0;
  213. _i=1;
  214. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  215. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  216. int b1=(_i)+(1);
  217. int b2=_i;
  218. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  219. }/*]*/
  220. _i=(_i)+(1);
  221. }
  222. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  223. int b1=0;
  224. int b2=_i;
  225. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  226. }/*]*/
  227. _i=0;
  228. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  229. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  230. /*]*/
  231. _i=(_i)+(1);
  232. }
  233. }
  234. void r79expand(T79* C){
  235. int _old_size=0;
  236. int _i=0;
  237. C->_item_mem=0;
  238. _old_size=r701count(((T701*)((((T79*)C))->_store/*4*/)));
  239. r429resize(((T429*)((((T79*)C))->_chain/*12*/)),1,(2)*(_old_size));
  240. r429resize(((T429*)((((T79*)C))->_keys/*0*/)),1,(2)*(_old_size));
  241. r701resize(((T701*)((((T79*)C))->_store/*4*/)),1,(2)*(_old_size));
  242. _i=(_old_size)+(1);
  243. while (!((_i)==(r429count(((T429*)((((T79*)C))->_chain/*12*/)))))) {
  244. /*[IRF3.6put*/{T429* C1=((T429*)((((T79*)C))->_chain/*12*/));
  245. int b1=(_i)+(1);
  246. int b2=_i;
  247. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  248. }/*]*/
  249. _i=(_i)+(1);
  250. }
  251. /*[IRF3.6put*/{T429* C1=((T429*)((((T79*)C))->_chain/*12*/));
  252. int b1=(((T79*)C))->_free/*16*/;
  253. int b2=_i;
  254. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  255. }/*]*/
  256. C->_free=(_old_size)+(1);
  257. }
  258. /*No:DICTIONARY[TYPE,INTEGER].free*/
  259. void r79make(T79* C){
  260. C->_modulus=(2)*(32);
  261. {T226*n=malloc(sizeof(*n));
  262. *n=M226;
  263. r226make(n,(((T79*)C))->_modulus/*20*/);
  264. C->_buckets=(T0*)n;
  265. }
  266. {T429*n=malloc(sizeof(*n));
  267. *n=M429;
  268. r429make(n,1,32);
  269. C->_chain=(T0*)n;
  270. }
  271. {T701*n=malloc(sizeof(*n));
  272. *n=M701;
  273. r701make(n,1,32);
  274. C->_store=(T0*)n;
  275. }
  276. {T429*n=malloc(sizeof(*n));
  277. *n=M429;
  278. r429make(n,1,32);
  279. C->_keys=(T0*)n;
  280. }
  281. r79initialize(C);
  282. }
  283. T0* r79item(T79* C,int a1){
  284. T0* R=NULL;
  285. /*IF*/if (((((T79*)C))->_item_mem/*28*/)==(0)) {
  286. r79first(C);
  287. while (!((a1)==((((T79*)C))->_item_mem/*28*/))) {
  288. r79forth(C);
  289. }
  290. R=r701item(((T701*)((((T79*)C))->_store/*4*/)),(((T79*)C))->_item_mem_j/*32*/);
  291. }
  292.  else if (((((T79*)C))->_item_mem/*28*/)<=(a1)) {
  293. while (!((a1)==((((T79*)C))->_item_mem/*28*/))) {
  294. r79forth(C);
  295. }
  296. R=r701item(((T701*)((((T79*)C))->_store/*4*/)),(((T79*)C))->_item_mem_j/*32*/);
  297. }
  298. else {
  299. C->_item_mem=0;
  300. R=r79item(C,a1);
  301. }
  302. /*FI*/return R;
  303. }
  304. /*No:DICTIONARY[TYPE,INTEGER].item_mem_i*/
  305. void r79resize(T79* C,int a1){
  306. int _p=0;
  307. int _n=0;
  308. int _i=0;
  309. int _hash=0;
  310. r226copy(((T226*)(oBC672tmp_buckets)),(((T79*)C))->_buckets/*8*/);
  311. r226make(((T226*)((((T79*)C))->_buckets/*8*/)),a1);
  312. _i=0;
  313. while (!((_i)>=((((T79*)C))->_modulus/*20*/))) {
  314. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  315. while (!((_n)==(0))) {
  316. _p=r429item(((T429*)((((T79*)C))->_chain/*12*/)),_n);
  317. _hash=(r2hash_code(r429item(((T429*)((((T79*)C))->_keys/*0*/)),_n)))%(a1);
  318. /*[IRF3.6put*/{T429* C1=((T429*)((((T79*)C))->_chain/*12*/));
  319. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  320. int b2=_n;
  321. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  322. }/*]*/
  323. /*[IRF3.5put*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  324. /*]*/
  325. _n=_p;
  326. }
  327. _i=(_i)+(1);
  328. }
  329. C->_modulus=a1;
  330. C->_item_mem=0;
  331. }
  332. /*No:DICTIONARY[TYPE,INTEGER].item_mem_j*/
  333. /*No:DICTIONARY[TYPE,INTEGER].item_mem*/
  334. /*No:DICTIONARY[TYPE,INTEGER].chain*/
  335. /*No:DICTIONARY[TYPE,INTEGER].keys*/
  336. /*No:DICTIONARY[TYPE,INTEGER].buckets*/
  337. int r79has(T79* C,int a1){
  338. int R=0;
  339. /*IF*/if ((((((T79*)C))->_has_mem/*24*/)==(0))||(!((a1)==(r429item(((T429*)((((T79*)C))->_keys/*0*/)),(((T79*)C))->_has_mem/*24*/))))) {
  340. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[(r2hash_code(a1))%((((T79*)C))->_modulus/*20*/)]/*)*/;
  341. while (!((((((T79*)C))->_has_mem/*24*/)==(0))||((a1)==(r429item(((T429*)((((T79*)C))->_keys/*0*/)),(((T79*)C))->_has_mem/*24*/))))) {
  342. C->_has_mem=r429item(((T429*)((((T79*)C))->_chain/*12*/)),(((T79*)C))->_has_mem/*24*/);
  343. }
  344. }
  345. /*FI*/R=((((T79*)C))->_has_mem/*24*/)!=(0);
  346. return R;
  347. }
  348. /*No:DICTIONARY[TYPE,INTEGER].Min_size*/
  349. void r79forth(T79* C){
  350. int _i=0;
  351. /*IF*/if ((r429item(((T429*)((((T79*)C))->_chain/*12*/)),(((T79*)C))->_item_mem_j/*32*/))!=(0)) {
  352. C->_item_mem_j=r429item(((T429*)((((T79*)C))->_chain/*12*/)),(((T79*)C))->_item_mem_j/*32*/);
  353. }
  354. else {
  355. _i=((((T79*)C))->_item_mem_i/*36*/)+(1);
  356. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  357. _i=(_i)+(1);
  358. }
  359. C->_item_mem_i=_i;
  360. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  361. }
  362. /*FI*/C->_item_mem=((((T79*)C))->_item_mem/*28*/)+(1);
  363. }
  364. /*No:DICTIONARY[TYPE,INTEGER].store*/
  365. void r79put(T79* C,T0* a1,int a2){
  366. int _hash=0;
  367. _hash=(r2hash_code(a2))%((((T79*)C))->_modulus/*20*/);
  368. /*IF*/if ((((((T79*)C))->_has_mem/*24*/)==(0))||(!((a2)==(r429item(((T429*)((((T79*)C))->_keys/*0*/)),(((T79*)C))->_has_mem/*24*/))))) {
  369. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  370. while (!((((((T79*)C))->_has_mem/*24*/)==(0))||((a2)==(r429item(((T429*)((((T79*)C))->_keys/*0*/)),(((T79*)C))->_has_mem/*24*/))))) {
  371. C->_has_mem=r429item(((T429*)((((T79*)C))->_chain/*12*/)),(((T79*)C))->_has_mem/*24*/);
  372. }
  373. /*IF*/if (((((T79*)C))->_has_mem/*24*/)==(0)) {
  374. /*IF*/if (((((T79*)C))->_count/*40*/)>=(r701count(((T701*)((((T79*)C))->_store/*4*/))))) {
  375. r79expand(C);
  376. }
  377. /*FI*//*[IRF3.6put*/{T429* C1=((T429*)((((T79*)C))->_keys/*0*/));
  378. int b1=a2;
  379. int b2=(((T79*)C))->_free/*16*/;
  380. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  381. }/*]*/
  382. /*[IRF3.6put*/{T701* C1=((T701*)((((T79*)C))->_store/*4*/));
  383. T0* b1=a1;
  384. int b2=(((T79*)C))->_free/*16*/;
  385. ((((T701*)C1))->_storage/*0*/)[(b2)-((((T701*)C1))->_lower/*12*/)]=(b1);
  386. }/*]*/
  387. C->_has_mem=(((T79*)C))->_free/*16*/;
  388. C->_free=r429item(((T429*)((((T79*)C))->_chain/*12*/)),(((T79*)C))->_free/*16*/);
  389. /*[IRF3.6put*/{T429* C1=((T429*)((((T79*)C))->_chain/*12*/));
  390. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  391. int b2=(((T79*)C))->_has_mem/*24*/;
  392. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  393. }/*]*/
  394. /*[IRF3.5put*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T79*)C))->_has_mem/*24*/);
  395. /*]*/
  396. C->_count=((((T79*)C))->_count/*40*/)+(1);
  397. /*IF*/if (((((T79*)C))->_count/*40*/)>(((((T79*)C))->_modulus/*20*/)*(2))) {
  398. r79resize(C,(2)*((((T79*)C))->_modulus/*20*/));
  399. }
  400. /*FI*/}
  401. /*FI*/}
  402. else {
  403. /*[IRF3.6put*/{T701* C1=((T701*)((((T79*)C))->_store/*4*/));
  404. T0* b1=a1;
  405. int b2=(((T79*)C))->_has_mem/*24*/;
  406. ((((T701*)C1))->_storage/*0*/)[(b2)-((((T701*)C1))->_lower/*12*/)]=(b1);
  407. }/*]*/
  408. }
  409. /*FI*/C->_item_mem=0;
  410. }
  411. /*No:DICTIONARY[TYPE,INTEGER].modulus*/
  412. /*No:DICTIONARY[TYPE,INTEGER].count*/
  413. /*No:DICTIONARY[TYPE,INTEGER].has_mem*/
  414. void r79first(T79* C){
  415. int _i=0;
  416. _i=0;
  417. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  418. _i=(_i)+(1);
  419. }
  420. C->_item_mem_i=_i;
  421. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  422. C->_item_mem=1;
  423. }
  424. void r79initialize(T79* C){
  425. int _i=0;
  426. C->_count=0;
  427. C->_free=1;
  428. C->_has_mem=0;
  429. C->_item_mem=0;
  430. _i=1;
  431. while (!((_i)==(r429count(((T429*)((((T79*)C))->_chain/*12*/)))))) {
  432. /*[IRF3.6put*/{T429* C1=((T429*)((((T79*)C))->_chain/*12*/));
  433. int b1=(_i)+(1);
  434. int b2=_i;
  435. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  436. }/*]*/
  437. _i=(_i)+(1);
  438. }
  439. /*[IRF3.6put*/{T429* C1=((T429*)((((T79*)C))->_chain/*12*/));
  440. int b1=0;
  441. int b2=_i;
  442. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  443. }/*]*/
  444. _i=0;
  445. while (!((_i)>=((((T79*)C))->_modulus/*20*/))) {
  446. /*[IRF3.5put*/((((T226*)((T226*)((((T79*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  447. /*]*/
  448. _i=(_i)+(1);
  449. }
  450. }
  451. T0* r199at(T199* C,T0* a1){
  452. T0* R=NULL;
  453. int _foo=0;
  454. _foo=r199has(C,a1);
  455. R=/*X477*/((T0*)r477item(((T477*)((((T199*)C))->_store/*4*/)),(((T199*)C))->_has_mem/*24*/));
  456. return R;
  457. }
  458. void r199expand(T199* C){
  459. int _old_size=0;
  460. int _i=0;
  461. C->_item_mem=0;
  462. _old_size=X477count((((T199*)C))->_store/*4*/);
  463. r429resize(((T429*)((((T199*)C))->_chain/*12*/)),1,(2)*(_old_size));
  464. r52resize(((T52*)((((T199*)C))->_keys/*0*/)),1,(2)*(_old_size));
  465. X477resize((((T199*)C))->_store/*4*/,1,(2)*(_old_size));
  466. _i=(_old_size)+(1);
  467. while (!((_i)==(r429count(((T429*)((((T199*)C))->_chain/*12*/)))))) {
  468. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  469. int b1=(_i)+(1);
  470. int b2=_i;
  471. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  472. }/*]*/
  473. _i=(_i)+(1);
  474. }
  475. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  476. int b1=(((T199*)C))->_free/*16*/;
  477. int b2=_i;
  478. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  479. }/*]*/
  480. C->_free=(_old_size)+(1);
  481. }
  482. /*No:DICTIONARY[RUN_FEATURE,STRING].free*/
  483. void r199make(T199* C){
  484. C->_modulus=(2)*(32);
  485. {T226*n=malloc(sizeof(*n));
  486. *n=M226;
  487. r226make(n,(((T199*)C))->_modulus/*20*/);
  488. C->_buckets=(T0*)n;
  489. }
  490. {T429*n=malloc(sizeof(*n));
  491. *n=M429;
  492. r429make(n,1,32);
  493. C->_chain=(T0*)n;
  494. }
  495. {T477*n=malloc(sizeof(*n));
  496. *n=M477;
  497. r477make(n,1,32);
  498. C->_store=(T0*)n;
  499. }
  500. {T52*n=malloc(sizeof(*n));
  501. *n=M52;
  502. r52make(n,1,32);
  503. C->_keys=(T0*)n;
  504. }
  505. r199initialize(C);
  506. }
  507. void r199remove(T199* C,T0* a1){
  508. int _p=0;
  509. int _n=0;
  510. int _hash=0;
  511. _hash=(r7hash_code(((T7*)a1)))%((((T199*)C))->_modulus/*20*/);
  512. _n=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  513. while (!(((_n)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T199*)C))->_keys/*0*/)),_n))))) {
  514. _p=_n;
  515. _n=r429item(((T429*)((((T199*)C))->_chain/*12*/)),_n);
  516. }
  517. /*IF*/if ((_n)!=(0)) {
  518. /*IF*/if ((_p)!=(0)) {
  519. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  520. int b1=r429item(((T429*)((((T199*)C))->_chain/*12*/)),_n);
  521. int b2=_p;
  522. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  523. }/*]*/
  524. }
  525. else {
  526. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(r429item(((T429*)((((T199*)C))->_chain/*12*/)),_n));
  527. /*]*/
  528. }
  529. /*FI*//*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  530. int b1=(((T199*)C))->_free/*16*/;
  531. int b2=_n;
  532. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  533. }/*]*/
  534. C->_free=_n;
  535. C->_count=((((T199*)C))->_count/*40*/)-(1);
  536. /*IF*/if ((_n)==((((T199*)C))->_has_mem/*24*/)) {
  537. C->_has_mem=0;
  538. }
  539. /*FI*//*IF*/if ((((((T199*)C))->_count/*40*/)<((X477count((((T199*)C))->_store/*4*/))/(4)))&&(((((T199*)C))->_count/*40*/)>(32))) {
  540. r199shrink(C);
  541. }
  542. /*FI*/}
  543. /*FI*/C->_item_mem=0;
  544. }
  545. void r199shrink(T199* C){
  546. int _k=0;
  547. int _j=0;
  548. int _i=0;
  549. T0* _chn=NULL;
  550. T0* _kys=NULL;
  551. T0* _str=NULL;
  552. {T52*n=malloc(sizeof(*n));
  553. *n=M52;
  554. r52make(n,1,(X477count((((T199*)C))->_store/*4*/))/(2));
  555. _kys=(T0*)n;
  556. }
  557. {T477*n=malloc(sizeof(*n));
  558. *n=M477;
  559. r477make(n,1,(X477count((((T199*)C))->_store/*4*/))/(2));
  560. _str=(T0*)n;
  561. }
  562. {T429*n=malloc(sizeof(*n));
  563. *n=M429;
  564. r429make(n,1,(X477count((((T199*)C))->_store/*4*/))/(2));
  565. _chn=(T0*)n;
  566. }
  567. _i=1;
  568. _j=0;
  569. while (!((_j)>=((((T199*)C))->_modulus/*20*/))) {
  570. _k=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_j]/*)*/;
  571. /*IF*/if ((_k)!=(0)) {
  572. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_j]=(_i);
  573. /*]*/
  574. }
  575. /*FI*/while (!((_k)==(0))) {
  576. /*[IRF3.6put*/{T52* C1=((T52*)_kys);
  577. T0* b1=r52item(((T52*)((((T199*)C))->_keys/*0*/)),_k);
  578. int b2=_i;
  579. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  580. }/*]*/
  581. /*X477*//*[IRF3.6put*/{T477* C1=((T477*)_str);
  582. T0* b1=/*X477*/((T0*)r477item(((T477*)((((T199*)C))->_store/*4*/)),_k));
  583. int b2=_i;
  584. ((((T477*)C1))->_storage/*4*/)[(b2)-((((T477*)C1))->_lower/*16*/)]=(b1);
  585. }/*]*/
  586. _k=r429item(((T429*)((((T199*)C))->_chain/*12*/)),_k);
  587. /*IF*/if ((_k)==(0)) {
  588. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  589. int b1=0;
  590. int b2=_i;
  591. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  592. }/*]*/
  593. }
  594. else {
  595. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  596. int b1=(_i)+(1);
  597. int b2=_i;
  598. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  599. }/*]*/
  600. }
  601. /*FI*/_i=(_i)+(1);
  602. }
  603. _j=(_j)+(1);
  604. }
  605. _i=((((T199*)C))->_count/*40*/)+(1);
  606. while (!((_i)>=(r429count(((T429*)_chn))))) {
  607. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  608. int b1=(_i)+(1);
  609. int b2=_i;
  610. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  611. }/*]*/
  612. _i=(_i)+(1);
  613. }
  614. /*[IRF3.6put*/{T429* C1=((T429*)_chn);
  615. int b1=0;
  616. int b2=_i;
  617. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  618. }/*]*/
  619. C->_free=((((T199*)C))->_count/*40*/)+(1);
  620. C->_chain=_chn;
  621. C->_keys=_kys;
  622. C->_store=_str;
  623. C->_item_mem=0;
  624. }
  625. T0* r199item(T199* C,int a1){
  626. T0* R=NULL;
  627. /*IF*/if (((((T199*)C))->_item_mem/*28*/)==(0)) {
  628. r199first(C);
  629. while (!((a1)==((((T199*)C))->_item_mem/*28*/))) {
  630. r199forth(C);
  631. }
  632. R=/*X477*/((T0*)r477item(((T477*)((((T199*)C))->_store/*4*/)),(((T199*)C))->_item_mem_j/*32*/));
  633. }
  634.  else if (((((T199*)C))->_item_mem/*28*/)<=(a1)) {
  635. while (!((a1)==((((T199*)C))->_item_mem/*28*/))) {
  636. r199forth(C);
  637. }
  638. R=/*X477*/((T0*)r477item(((T477*)((((T199*)C))->_store/*4*/)),(((T199*)C))->_item_mem_j/*32*/));
  639. }
  640. else {
  641. C->_item_mem=0;
  642. R=r199item(C,a1);
  643. }
  644. /*FI*/return R;
  645. }
  646. /*No:DICTIONARY[RUN_FEATURE,STRING].item_mem_i*/
  647. void r199resize(T199* C,int a1){
  648. int _p=0;
  649. int _n=0;
  650. int _i=0;
  651. int _hash=0;
  652. r226copy(((T226*)(oBC672tmp_buckets)),(((T199*)C))->_buckets/*8*/);
  653. r226make(((T226*)((((T199*)C))->_buckets/*8*/)),a1);
  654. _i=0;
  655. while (!((_i)>=((((T199*)C))->_modulus/*20*/))) {
  656. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  657. while (!((_n)==(0))) {
  658. _p=r429item(((T429*)((((T199*)C))->_chain/*12*/)),_n);
  659. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T199*)C))->_keys/*0*/)),_n)))))%(a1);
  660. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  661. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  662. int b2=_n;
  663. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  664. }/*]*/
  665. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  666. /*]*/
  667. _n=_p;
  668. }
  669. _i=(_i)+(1);
  670. }
  671. C->_modulus=a1;
  672. C->_item_mem=0;
  673. }
  674. /*No:DICTIONARY[RUN_FEATURE,STRING].item_mem_j*/
  675. /*No:DICTIONARY[RUN_FEATURE,STRING].item_mem*/
  676. /*No:DICTIONARY[RUN_FEATURE,STRING].chain*/
  677. /*No:DICTIONARY[RUN_FEATURE,STRING].buckets*/
  678. /*No:DICTIONARY[RUN_FEATURE,STRING].keys*/
  679. int r199has(T199* C,T0* a1){
  680. int R=0;
  681. /*IF*/if ((((((T199*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  682. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T199*)C))->_modulus/*20*/)]/*)*/;
  683. while (!((((((T199*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  684. C->_has_mem=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_has_mem/*24*/);
  685. }
  686. }
  687. /*FI*/R=((((T199*)C))->_has_mem/*24*/)!=(0);
  688. return R;
  689. }
  690. /*No:DICTIONARY[RUN_FEATURE,STRING].Min_size*/
  691. void r199forth(T199* C){
  692. int _i=0;
  693. /*IF*/if ((r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_item_mem_j/*32*/))!=(0)) {
  694. C->_item_mem_j=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_item_mem_j/*32*/);
  695. }
  696. else {
  697. _i=((((T199*)C))->_item_mem_i/*36*/)+(1);
  698. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  699. _i=(_i)+(1);
  700. }
  701. C->_item_mem_i=_i;
  702. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  703. }
  704. /*FI*/C->_item_mem=((((T199*)C))->_item_mem/*28*/)+(1);
  705. }
  706. /*No:DICTIONARY[RUN_FEATURE,STRING].store*/
  707. void r199with_capacity(T199* C,int a1){
  708. int _i=0;
  709. _i=32;
  710. while (!((_i)>=(a1))) {
  711. _i=(2)*(_i);
  712. }
  713. C->_modulus=(2)*(_i);
  714. {T226*n=malloc(sizeof(*n));
  715. *n=M226;
  716. r226make(n,(((T199*)C))->_modulus/*20*/);
  717. C->_buckets=(T0*)n;
  718. }
  719. {T429*n=malloc(sizeof(*n));
  720. *n=M429;
  721. r429make(n,1,_i);
  722. C->_chain=(T0*)n;
  723. }
  724. {T477*n=malloc(sizeof(*n));
  725. *n=M477;
  726. r477make(n,1,_i);
  727. C->_store=(T0*)n;
  728. }
  729. {T52*n=malloc(sizeof(*n));
  730. *n=M52;
  731. r52make(n,1,_i);
  732. C->_keys=(T0*)n;
  733. }
  734. r199initialize(C);
  735. }
  736. void r199put(T199* C,T0* a1,T0* a2){
  737. int _hash=0;
  738. _hash=(r7hash_code(((T7*)a2)))%((((T199*)C))->_modulus/*20*/);
  739. /*IF*/if ((((((T199*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  740. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  741. while (!((((((T199*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T199*)C))->_keys/*0*/)),(((T199*)C))->_has_mem/*24*/))))) {
  742. C->_has_mem=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_has_mem/*24*/);
  743. }
  744. /*IF*/if (((((T199*)C))->_has_mem/*24*/)==(0)) {
  745. /*IF*/if (((((T199*)C))->_count/*40*/)>=(X477count((((T199*)C))->_store/*4*/))) {
  746. r199expand(C);
  747. }
  748. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T199*)C))->_keys/*0*/));
  749. T0* b1=a2;
  750. int b2=(((T199*)C))->_free/*16*/;
  751. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  752. }/*]*/
  753. /*X477*//*[IRF3.6put*/{T477* C1=((T477*)((((T199*)C))->_store/*4*/));
  754. T0* b1=a1;
  755. int b2=(((T199*)C))->_free/*16*/;
  756. ((((T477*)C1))->_storage/*4*/)[(b2)-((((T477*)C1))->_lower/*16*/)]=(b1);
  757. }/*]*/
  758. C->_has_mem=(((T199*)C))->_free/*16*/;
  759. C->_free=r429item(((T429*)((((T199*)C))->_chain/*12*/)),(((T199*)C))->_free/*16*/);
  760. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  761. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  762. int b2=(((T199*)C))->_has_mem/*24*/;
  763. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  764. }/*]*/
  765. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T199*)C))->_has_mem/*24*/);
  766. /*]*/
  767. C->_count=((((T199*)C))->_count/*40*/)+(1);
  768. /*IF*/if (((((T199*)C))->_count/*40*/)>(((((T199*)C))->_modulus/*20*/)*(2))) {
  769. r199resize(C,(2)*((((T199*)C))->_modulus/*20*/));
  770. }
  771. /*FI*/}
  772. /*FI*/}
  773. else {
  774. /*X477*//*[IRF3.6put*/{T477* C1=((T477*)((((T199*)C))->_store/*4*/));
  775. T0* b1=a1;
  776. int b2=(((T199*)C))->_has_mem/*24*/;
  777. ((((T477*)C1))->_storage/*4*/)[(b2)-((((T477*)C1))->_lower/*16*/)]=(b1);
  778. }/*]*/
  779. }
  780. /*FI*/C->_item_mem=0;
  781. }
  782. /*No:DICTIONARY[RUN_FEATURE,STRING].modulus*/
  783. /*No:DICTIONARY[RUN_FEATURE,STRING].count*/
  784. /*No:DICTIONARY[RUN_FEATURE,STRING].has_mem*/
  785. void r199initialize(T199* C){
  786. int _i=0;
  787. C->_count=0;
  788. C->_free=1;
  789. C->_has_mem=0;
  790. C->_item_mem=0;
  791. _i=1;
  792. while (!((_i)==(r429count(((T429*)((((T199*)C))->_chain/*12*/)))))) {
  793. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  794. int b1=(_i)+(1);
  795. int b2=_i;
  796. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  797. }/*]*/
  798. _i=(_i)+(1);
  799. }
  800. /*[IRF3.6put*/{T429* C1=((T429*)((((T199*)C))->_chain/*12*/));
  801. int b1=0;
  802. int b2=_i;
  803. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  804. }/*]*/
  805. _i=0;
  806. while (!((_i)>=((((T199*)C))->_modulus/*20*/))) {
  807. /*[IRF3.5put*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  808. /*]*/
  809. _i=(_i)+(1);
  810. }
  811. }
  812. void r199first(T199* C){
  813. int _i=0;
  814. _i=0;
  815. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  816. _i=(_i)+(1);
  817. }
  818. C->_item_mem_i=_i;
  819. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T199*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  820. C->_item_mem=1;
  821. }
  822. T0* r718at(T718* C,T0* a1){
  823. T0* R=NULL;
  824. int _foo=0;
  825. _foo=r718has(C,a1);
  826. R=r863item(((T863*)((((T718*)C))->_store/*4*/)),(((T718*)C))->_has_mem/*24*/);
  827. return R;
  828. }
  829. void r718expand(T718* C){
  830. int _old_size=0;
  831. int _i=0;
  832. C->_item_mem=0;
  833. _old_size=r863count(((T863*)((((T718*)C))->_store/*4*/)));
  834. r429resize(((T429*)((((T718*)C))->_chain/*12*/)),1,(2)*(_old_size));
  835. r52resize(((T52*)((((T718*)C))->_keys/*0*/)),1,(2)*(_old_size));
  836. r863resize(((T863*)((((T718*)C))->_store/*4*/)),1,(2)*(_old_size));
  837. _i=(_old_size)+(1);
  838. while (!((_i)==(r429count(((T429*)((((T718*)C))->_chain/*12*/)))))) {
  839. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  840. int b1=(_i)+(1);
  841. int b2=_i;
  842. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  843. }/*]*/
  844. _i=(_i)+(1);
  845. }
  846. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  847. int b1=(((T718*)C))->_free/*16*/;
  848. int b2=_i;
  849. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  850. }/*]*/
  851. C->_free=(_old_size)+(1);
  852. }
  853. /*No:DICTIONARY[BASE_CLASS,STRING].free*/
  854. void r718make(T718* C){
  855. C->_modulus=(2)*(32);
  856. {T226*n=malloc(sizeof(*n));
  857. *n=M226;
  858. r226make(n,(((T718*)C))->_modulus/*20*/);
  859. C->_buckets=(T0*)n;
  860. }
  861. {T429*n=malloc(sizeof(*n));
  862. *n=M429;
  863. r429make(n,1,32);
  864. C->_chain=(T0*)n;
  865. }
  866. {T863*n=malloc(sizeof(*n));
  867. *n=M863;
  868. r863make(n,1,32);
  869. C->_store=(T0*)n;
  870. }
  871. {T52*n=malloc(sizeof(*n));
  872. *n=M52;
  873. r52make(n,1,32);
  874. C->_keys=(T0*)n;
  875. }
  876. r718initialize(C);
  877. }
  878. T0* r718item(T718* C,int a1){
  879. T0* R=NULL;
  880. /*IF*/if (((((T718*)C))->_item_mem/*28*/)==(0)) {
  881. r718first(C);
  882. while (!((a1)==((((T718*)C))->_item_mem/*28*/))) {
  883. r718forth(C);
  884. }
  885. R=r863item(((T863*)((((T718*)C))->_store/*4*/)),(((T718*)C))->_item_mem_j/*32*/);
  886. }
  887.  else if (((((T718*)C))->_item_mem/*28*/)<=(a1)) {
  888. while (!((a1)==((((T718*)C))->_item_mem/*28*/))) {
  889. r718forth(C);
  890. }
  891. R=r863item(((T863*)((((T718*)C))->_store/*4*/)),(((T718*)C))->_item_mem_j/*32*/);
  892. }
  893. else {
  894. C->_item_mem=0;
  895. R=r718item(C,a1);
  896. }
  897. /*FI*/return R;
  898. }
  899. /*No:DICTIONARY[BASE_CLASS,STRING].item_mem_i*/
  900. void r718resize(T718* C,int a1){
  901. int _p=0;
  902. int _n=0;
  903. int _i=0;
  904. int _hash=0;
  905. r226copy(((T226*)(oBC672tmp_buckets)),(((T718*)C))->_buckets/*8*/);
  906. r226make(((T226*)((((T718*)C))->_buckets/*8*/)),a1);
  907. _i=0;
  908. while (!((_i)>=((((T718*)C))->_modulus/*20*/))) {
  909. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  910. while (!((_n)==(0))) {
  911. _p=r429item(((T429*)((((T718*)C))->_chain/*12*/)),_n);
  912. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T718*)C))->_keys/*0*/)),_n)))))%(a1);
  913. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  914. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  915. int b2=_n;
  916. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  917. }/*]*/
  918. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  919. /*]*/
  920. _n=_p;
  921. }
  922. _i=(_i)+(1);
  923. }
  924. C->_modulus=a1;
  925. C->_item_mem=0;
  926. }
  927. /*No:DICTIONARY[BASE_CLASS,STRING].item_mem_j*/
  928. /*No:DICTIONARY[BASE_CLASS,STRING].item_mem*/
  929. /*No:DICTIONARY[BASE_CLASS,STRING].chain*/
  930. /*No:DICTIONARY[BASE_CLASS,STRING].keys*/
  931. /*No:DICTIONARY[BASE_CLASS,STRING].buckets*/
  932. int r718has(T718* C,T0* a1){
  933. int R=0;
  934. /*IF*/if ((((((T718*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  935. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T718*)C))->_modulus/*20*/)]/*)*/;
  936. while (!((((((T718*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  937. C->_has_mem=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_has_mem/*24*/);
  938. }
  939. }
  940. /*FI*/R=((((T718*)C))->_has_mem/*24*/)!=(0);
  941. return R;
  942. }
  943. /*No:DICTIONARY[BASE_CLASS,STRING].Min_size*/
  944. void r718forth(T718* C){
  945. int _i=0;
  946. /*IF*/if ((r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_item_mem_j/*32*/))!=(0)) {
  947. C->_item_mem_j=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_item_mem_j/*32*/);
  948. }
  949. else {
  950. _i=((((T718*)C))->_item_mem_i/*36*/)+(1);
  951. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  952. _i=(_i)+(1);
  953. }
  954. C->_item_mem_i=_i;
  955. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  956. }
  957. /*FI*/C->_item_mem=((((T718*)C))->_item_mem/*28*/)+(1);
  958. }
  959. /*No:DICTIONARY[BASE_CLASS,STRING].store*/
  960. void r718put(T718* C,T0* a1,T0* a2){
  961. int _hash=0;
  962. _hash=(r7hash_code(((T7*)a2)))%((((T718*)C))->_modulus/*20*/);
  963. /*IF*/if ((((((T718*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  964. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  965. while (!((((((T718*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T718*)C))->_keys/*0*/)),(((T718*)C))->_has_mem/*24*/))))) {
  966. C->_has_mem=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_has_mem/*24*/);
  967. }
  968. /*IF*/if (((((T718*)C))->_has_mem/*24*/)==(0)) {
  969. /*IF*/if (((((T718*)C))->_count/*40*/)>=(r863count(((T863*)((((T718*)C))->_store/*4*/))))) {
  970. r718expand(C);
  971. }
  972. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T718*)C))->_keys/*0*/));
  973. T0* b1=a2;
  974. int b2=(((T718*)C))->_free/*16*/;
  975. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  976. }/*]*/
  977. /*[IRF3.6put*/{T863* C1=((T863*)((((T718*)C))->_store/*4*/));
  978. T0* b1=a1;
  979. int b2=(((T718*)C))->_free/*16*/;
  980. ((((T863*)C1))->_storage/*0*/)[(b2)-((((T863*)C1))->_lower/*12*/)]=(b1);
  981. }/*]*/
  982. C->_has_mem=(((T718*)C))->_free/*16*/;
  983. C->_free=r429item(((T429*)((((T718*)C))->_chain/*12*/)),(((T718*)C))->_free/*16*/);
  984. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  985. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  986. int b2=(((T718*)C))->_has_mem/*24*/;
  987. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  988. }/*]*/
  989. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T718*)C))->_has_mem/*24*/);
  990. /*]*/
  991. C->_count=((((T718*)C))->_count/*40*/)+(1);
  992. /*IF*/if (((((T718*)C))->_count/*40*/)>(((((T718*)C))->_modulus/*20*/)*(2))) {
  993. r718resize(C,(2)*((((T718*)C))->_modulus/*20*/));
  994. }
  995. /*FI*/}
  996. /*FI*/}
  997. else {
  998. /*[IRF3.6put*/{T863* C1=((T863*)((((T718*)C))->_store/*4*/));
  999. T0* b1=a1;
  1000. int b2=(((T718*)C))->_has_mem/*24*/;
  1001. ((((T863*)C1))->_storage/*0*/)[(b2)-((((T863*)C1))->_lower/*12*/)]=(b1);
  1002. }/*]*/
  1003. }
  1004. /*FI*/C->_item_mem=0;
  1005. }
  1006. /*No:DICTIONARY[BASE_CLASS,STRING].modulus*/
  1007. /*No:DICTIONARY[BASE_CLASS,STRING].count*/
  1008. /*No:DICTIONARY[BASE_CLASS,STRING].has_mem*/
  1009. void r718first(T718* C){
  1010. int _i=0;
  1011. _i=0;
  1012. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  1013. _i=(_i)+(1);
  1014. }
  1015. C->_item_mem_i=_i;
  1016. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  1017. C->_item_mem=1;
  1018. }
  1019. void r718initialize(T718* C){
  1020. int _i=0;
  1021. C->_count=0;
  1022. C->_free=1;
  1023. C->_has_mem=0;
  1024. C->_item_mem=0;
  1025. _i=1;
  1026. while (!((_i)==(r429count(((T429*)((((T718*)C))->_chain/*12*/)))))) {
  1027. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1028. int b1=(_i)+(1);
  1029. int b2=_i;
  1030. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1031. }/*]*/
  1032. _i=(_i)+(1);
  1033. }
  1034. /*[IRF3.6put*/{T429* C1=((T429*)((((T718*)C))->_chain/*12*/));
  1035. int b1=0;
  1036. int b2=_i;
  1037. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1038. }/*]*/
  1039. _i=0;
  1040. while (!((_i)>=((((T718*)C))->_modulus/*20*/))) {
  1041. /*[IRF3.5put*/((((T226*)((T226*)((((T718*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  1042. /*]*/
  1043. _i=(_i)+(1);
  1044. }
  1045. }
  1046. /*No:MEMO[COMMENT].item*/
  1047. /*No:MEMO[COMMENT].clear*/
  1048. /*No:MEMO[COMMENT].set_item*/
  1049. T0* r237at(T237* C,T0* a1){
  1050. T0* R=NULL;
  1051. int _foo=0;
  1052. _foo=r237has(C,a1);
  1053. R=r495item(((T495*)((((T237*)C))->_store/*4*/)),(((T237*)C))->_has_mem/*24*/);
  1054. return R;
  1055. }
  1056. void r237expand(T237* C){
  1057. int _old_size=0;
  1058. int _i=0;
  1059. C->_item_mem=0;
  1060. _old_size=r495count(((T495*)((((T237*)C))->_store/*4*/)));
  1061. r429resize(((T429*)((((T237*)C))->_chain/*12*/)),1,(2)*(_old_size));
  1062. r52resize(((T52*)((((T237*)C))->_keys/*0*/)),1,(2)*(_old_size));
  1063. r495resize(((T495*)((((T237*)C))->_store/*4*/)),1,(2)*(_old_size));
  1064. _i=(_old_size)+(1);
  1065. while (!((_i)==(r429count(((T429*)((((T237*)C))->_chain/*12*/)))))) {
  1066. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  1067. int b1=(_i)+(1);
  1068. int b2=_i;
  1069. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1070. }/*]*/
  1071. _i=(_i)+(1);
  1072. }
  1073. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  1074. int b1=(((T237*)C))->_free/*16*/;
  1075. int b2=_i;
  1076. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1077. }/*]*/
  1078. C->_free=(_old_size)+(1);
  1079. }
  1080. /*No:DICTIONARY[E_FEATURE,STRING].free*/
  1081. void r237resize(T237* C,int a1){
  1082. int _p=0;
  1083. int _n=0;
  1084. int _i=0;
  1085. int _hash=0;
  1086. r226copy(((T226*)(oBC672tmp_buckets)),(((T237*)C))->_buckets/*8*/);
  1087. r226make(((T226*)((((T237*)C))->_buckets/*8*/)),a1);
  1088. _i=0;
  1089. while (!((_i)>=((((T237*)C))->_modulus/*20*/))) {
  1090. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  1091. while (!((_n)==(0))) {
  1092. _p=r429item(((T429*)((((T237*)C))->_chain/*12*/)),_n);
  1093. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T237*)C))->_keys/*0*/)),_n)))))%(a1);
  1094. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  1095. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1096. int b2=_n;
  1097. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1098. }/*]*/
  1099. /*[IRF3.5put*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  1100. /*]*/
  1101. _n=_p;
  1102. }
  1103. _i=(_i)+(1);
  1104. }
  1105. C->_modulus=a1;
  1106. C->_item_mem=0;
  1107. }
  1108. /*No:DICTIONARY[E_FEATURE,STRING].item_mem*/
  1109. /*No:DICTIONARY[E_FEATURE,STRING].chain*/
  1110. /*No:DICTIONARY[E_FEATURE,STRING].buckets*/
  1111. /*No:DICTIONARY[E_FEATURE,STRING].keys*/
  1112. int r237has(T237* C,T0* a1){
  1113. int R=0;
  1114. /*IF*/if ((((((T237*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  1115. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T237*)C))->_modulus/*20*/)]/*)*/;
  1116. while (!((((((T237*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  1117. C->_has_mem=r429item(((T429*)((((T237*)C))->_chain/*12*/)),(((T237*)C))->_has_mem/*24*/);
  1118. }
  1119. }
  1120. /*FI*/R=((((T237*)C))->_has_mem/*24*/)!=(0);
  1121. return R;
  1122. }
  1123. /*No:DICTIONARY[E_FEATURE,STRING].Min_size*/
  1124. /*No:DICTIONARY[E_FEATURE,STRING].store*/
  1125. void r237with_capacity(T237* C,int a1){
  1126. int _i=0;
  1127. _i=32;
  1128. while (!((_i)>=(a1))) {
  1129. _i=(2)*(_i);
  1130. }
  1131. C->_modulus=(2)*(_i);
  1132. {T226*n=malloc(sizeof(*n));
  1133. *n=M226;
  1134. r226make(n,(((T237*)C))->_modulus/*20*/);
  1135. C->_buckets=(T0*)n;
  1136. }
  1137. {T429*n=malloc(sizeof(*n));
  1138. *n=M429;
  1139. r429make(n,1,_i);
  1140. C->_chain=(T0*)n;
  1141. }
  1142. {T495*n=malloc(sizeof(*n));
  1143. *n=M495;
  1144. r495make(n,1,_i);
  1145. C->_store=(T0*)n;
  1146. }
  1147. {T52*n=malloc(sizeof(*n));
  1148. *n=M52;
  1149. r52make(n,1,_i);
  1150. C->_keys=(T0*)n;
  1151. }
  1152. r237initialize(C);
  1153. }
  1154. void r237put(T237* C,T0* a1,T0* a2){
  1155. int _hash=0;
  1156. _hash=(r7hash_code(((T7*)a2)))%((((T237*)C))->_modulus/*20*/);
  1157. /*IF*/if ((((((T237*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  1158. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1159. while (!((((((T237*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T237*)C))->_keys/*0*/)),(((T237*)C))->_has_mem/*24*/))))) {
  1160. C->_has_mem=r429item(((T429*)((((T237*)C))->_chain/*12*/)),(((T237*)C))->_has_mem/*24*/);
  1161. }
  1162. /*IF*/if (((((T237*)C))->_has_mem/*24*/)==(0)) {
  1163. /*IF*/if (((((T237*)C))->_count/*32*/)>=(r495count(((T495*)((((T237*)C))->_store/*4*/))))) {
  1164. r237expand(C);
  1165. }
  1166. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T237*)C))->_keys/*0*/));
  1167. T0* b1=a2;
  1168. int b2=(((T237*)C))->_free/*16*/;
  1169. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  1170. }/*]*/
  1171. /*[IRF3.6put*/{T495* C1=((T495*)((((T237*)C))->_store/*4*/));
  1172. T0* b1=a1;
  1173. int b2=(((T237*)C))->_free/*16*/;
  1174. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  1175. }/*]*/
  1176. C->_has_mem=(((T237*)C))->_free/*16*/;
  1177. C->_free=r429item(((T429*)((((T237*)C))->_chain/*12*/)),(((T237*)C))->_free/*16*/);
  1178. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  1179. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1180. int b2=(((T237*)C))->_has_mem/*24*/;
  1181. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1182. }/*]*/
  1183. /*[IRF3.5put*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T237*)C))->_has_mem/*24*/);
  1184. /*]*/
  1185. C->_count=((((T237*)C))->_count/*32*/)+(1);
  1186. /*IF*/if (((((T237*)C))->_count/*32*/)>(((((T237*)C))->_modulus/*20*/)*(2))) {
  1187. r237resize(C,(2)*((((T237*)C))->_modulus/*20*/));
  1188. }
  1189. /*FI*/}
  1190. /*FI*/}
  1191. else {
  1192. /*[IRF3.6put*/{T495* C1=((T495*)((((T237*)C))->_store/*4*/));
  1193. T0* b1=a1;
  1194. int b2=(((T237*)C))->_has_mem/*24*/;
  1195. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  1196. }/*]*/
  1197. }
  1198. /*FI*/C->_item_mem=0;
  1199. }
  1200. /*No:DICTIONARY[E_FEATURE,STRING].modulus*/
  1201. /*No:DICTIONARY[E_FEATURE,STRING].count*/
  1202. /*No:DICTIONARY[E_FEATURE,STRING].has_mem*/
  1203. void r237initialize(T237* C){
  1204. int _i=0;
  1205. C->_count=0;
  1206. C->_free=1;
  1207. C->_has_mem=0;
  1208. C->_item_mem=0;
  1209. _i=1;
  1210. while (!((_i)==(r429count(((T429*)((((T237*)C))->_chain/*12*/)))))) {
  1211. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  1212. int b1=(_i)+(1);
  1213. int b2=_i;
  1214. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1215. }/*]*/
  1216. _i=(_i)+(1);
  1217. }
  1218. /*[IRF3.6put*/{T429* C1=((T429*)((((T237*)C))->_chain/*12*/));
  1219. int b1=0;
  1220. int b2=_i;
  1221. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1222. }/*]*/
  1223. _i=0;
  1224. while (!((_i)>=((((T237*)C))->_modulus/*20*/))) {
  1225. /*[IRF3.5put*/((((T226*)((T226*)((((T237*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  1226. /*]*/
  1227. _i=(_i)+(1);
  1228. }
  1229. }
  1230. T0* r250at(T250* C,T0* a1){
  1231. T0* R=NULL;
  1232. int _foo=0;
  1233. _foo=r250has(C,a1);
  1234. R=r396item(((T396*)((((T250*)C))->_store/*4*/)),(((T250*)C))->_has_mem/*24*/);
  1235. return R;
  1236. }
  1237. void r250expand(T250* C){
  1238. int _old_size=0;
  1239. int _i=0;
  1240. C->_item_mem=0;
  1241. _old_size=r396count(((T396*)((((T250*)C))->_store/*4*/)));
  1242. r429resize(((T429*)((((T250*)C))->_chain/*12*/)),1,(2)*(_old_size));
  1243. r52resize(((T52*)((((T250*)C))->_keys/*0*/)),1,(2)*(_old_size));
  1244. r396resize(((T396*)((((T250*)C))->_store/*4*/)),1,(2)*(_old_size));
  1245. _i=(_old_size)+(1);
  1246. while (!((_i)==(r429count(((T429*)((((T250*)C))->_chain/*12*/)))))) {
  1247. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  1248. int b1=(_i)+(1);
  1249. int b2=_i;
  1250. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1251. }/*]*/
  1252. _i=(_i)+(1);
  1253. }
  1254. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  1255. int b1=(((T250*)C))->_free/*16*/;
  1256. int b2=_i;
  1257. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1258. }/*]*/
  1259. C->_free=(_old_size)+(1);
  1260. }
  1261. /*No:DICTIONARY[RUN_CLASS,STRING].free*/
  1262. void r250make(T250* C){
  1263. C->_modulus=(2)*(32);
  1264. {T226*n=malloc(sizeof(*n));
  1265. *n=M226;
  1266. r226make(n,(((T250*)C))->_modulus/*20*/);
  1267. C->_buckets=(T0*)n;
  1268. }
  1269. {T429*n=malloc(sizeof(*n));
  1270. *n=M429;
  1271. r429make(n,1,32);
  1272. C->_chain=(T0*)n;
  1273. }
  1274. {T396*n=malloc(sizeof(*n));
  1275. *n=M396;
  1276. r396make(n,1,32);
  1277. C->_store=(T0*)n;
  1278. }
  1279. {T52*n=malloc(sizeof(*n));
  1280. *n=M52;
  1281. r52make(n,1,32);
  1282. C->_keys=(T0*)n;
  1283. }
  1284. r250initialize(C);
  1285. }
  1286. T0* r250item(T250* C,int a1){
  1287. T0* R=NULL;
  1288. /*IF*/if (((((T250*)C))->_item_mem/*28*/)==(0)) {
  1289. r250first(C);
  1290. while (!((a1)==((((T250*)C))->_item_mem/*28*/))) {
  1291. r250forth(C);
  1292. }
  1293. R=r396item(((T396*)((((T250*)C))->_store/*4*/)),(((T250*)C))->_item_mem_j/*32*/);
  1294. }
  1295.  else if (((((T250*)C))->_item_mem/*28*/)<=(a1)) {
  1296. while (!((a1)==((((T250*)C))->_item_mem/*28*/))) {
  1297. r250forth(C);
  1298. }
  1299. R=r396item(((T396*)((((T250*)C))->_store/*4*/)),(((T250*)C))->_item_mem_j/*32*/);
  1300. }
  1301. else {
  1302. C->_item_mem=0;
  1303. R=r250item(C,a1);
  1304. }
  1305. /*FI*/return R;
  1306. }
  1307. /*No:DICTIONARY[RUN_CLASS,STRING].item_mem_i*/
  1308. void r250resize(T250* C,int a1){
  1309. int _p=0;
  1310. int _n=0;
  1311. int _i=0;
  1312. int _hash=0;
  1313. r226copy(((T226*)(oBC672tmp_buckets)),(((T250*)C))->_buckets/*8*/);
  1314. r226make(((T226*)((((T250*)C))->_buckets/*8*/)),a1);
  1315. _i=0;
  1316. while (!((_i)>=((((T250*)C))->_modulus/*20*/))) {
  1317. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  1318. while (!((_n)==(0))) {
  1319. _p=r429item(((T429*)((((T250*)C))->_chain/*12*/)),_n);
  1320. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T250*)C))->_keys/*0*/)),_n)))))%(a1);
  1321. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  1322. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1323. int b2=_n;
  1324. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1325. }/*]*/
  1326. /*[IRF3.5put*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  1327. /*]*/
  1328. _n=_p;
  1329. }
  1330. _i=(_i)+(1);
  1331. }
  1332. C->_modulus=a1;
  1333. C->_item_mem=0;
  1334. }
  1335. /*No:DICTIONARY[RUN_CLASS,STRING].item_mem_j*/
  1336. /*No:DICTIONARY[RUN_CLASS,STRING].item_mem*/
  1337. /*No:DICTIONARY[RUN_CLASS,STRING].chain*/
  1338. /*No:DICTIONARY[RUN_CLASS,STRING].keys*/
  1339. /*No:DICTIONARY[RUN_CLASS,STRING].buckets*/
  1340. int r250has(T250* C,T0* a1){
  1341. int R=0;
  1342. /*IF*/if ((((((T250*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  1343. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T250*)C))->_modulus/*20*/)]/*)*/;
  1344. while (!((((((T250*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  1345. C->_has_mem=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_has_mem/*24*/);
  1346. }
  1347. }
  1348. /*FI*/R=((((T250*)C))->_has_mem/*24*/)!=(0);
  1349. return R;
  1350. }
  1351. /*No:DICTIONARY[RUN_CLASS,STRING].Min_size*/
  1352. void r250forth(T250* C){
  1353. int _i=0;
  1354. /*IF*/if ((r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_item_mem_j/*32*/))!=(0)) {
  1355. C->_item_mem_j=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_item_mem_j/*32*/);
  1356. }
  1357. else {
  1358. _i=((((T250*)C))->_item_mem_i/*36*/)+(1);
  1359. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  1360. _i=(_i)+(1);
  1361. }
  1362. C->_item_mem_i=_i;
  1363. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  1364. }
  1365. /*FI*/C->_item_mem=((((T250*)C))->_item_mem/*28*/)+(1);
  1366. }
  1367. /*No:DICTIONARY[RUN_CLASS,STRING].store*/
  1368. void r250put(T250* C,T0* a1,T0* a2){
  1369. int _hash=0;
  1370. _hash=(r7hash_code(((T7*)a2)))%((((T250*)C))->_modulus/*20*/);
  1371. /*IF*/if ((((((T250*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  1372. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1373. while (!((((((T250*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T250*)C))->_keys/*0*/)),(((T250*)C))->_has_mem/*24*/))))) {
  1374. C->_has_mem=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_has_mem/*24*/);
  1375. }
  1376. /*IF*/if (((((T250*)C))->_has_mem/*24*/)==(0)) {
  1377. /*IF*/if (((((T250*)C))->_count/*40*/)>=(r396count(((T396*)((((T250*)C))->_store/*4*/))))) {
  1378. r250expand(C);
  1379. }
  1380. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T250*)C))->_keys/*0*/));
  1381. T0* b1=a2;
  1382. int b2=(((T250*)C))->_free/*16*/;
  1383. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  1384. }/*]*/
  1385. /*[IRF3.6put*/{T396* C1=((T396*)((((T250*)C))->_store/*4*/));
  1386. T0* b1=a1;
  1387. int b2=(((T250*)C))->_free/*16*/;
  1388. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  1389. }/*]*/
  1390. C->_has_mem=(((T250*)C))->_free/*16*/;
  1391. C->_free=r429item(((T429*)((((T250*)C))->_chain/*12*/)),(((T250*)C))->_free/*16*/);
  1392. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  1393. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  1394. int b2=(((T250*)C))->_has_mem/*24*/;
  1395. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1396. }/*]*/
  1397. /*[IRF3.5put*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T250*)C))->_has_mem/*24*/);
  1398. /*]*/
  1399. C->_count=((((T250*)C))->_count/*40*/)+(1);
  1400. /*IF*/if (((((T250*)C))->_count/*40*/)>(((((T250*)C))->_modulus/*20*/)*(2))) {
  1401. r250resize(C,(2)*((((T250*)C))->_modulus/*20*/));
  1402. }
  1403. /*FI*/}
  1404. /*FI*/}
  1405. else {
  1406. /*[IRF3.6put*/{T396* C1=((T396*)((((T250*)C))->_store/*4*/));
  1407. T0* b1=a1;
  1408. int b2=(((T250*)C))->_has_mem/*24*/;
  1409. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  1410. }/*]*/
  1411. }
  1412. /*FI*/C->_item_mem=0;
  1413. }
  1414. /*No:DICTIONARY[RUN_CLASS,STRING].modulus*/
  1415. /*No:DICTIONARY[RUN_CLASS,STRING].count*/
  1416. /*No:DICTIONARY[RUN_CLASS,STRING].has_mem*/
  1417. void r250first(T250* C){
  1418. int _i=0;
  1419. _i=0;
  1420. while (!((/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/)!=(0))) {
  1421. _i=(_i)+(1);
  1422. }
  1423. C->_item_mem_i=_i;
  1424. C->_item_mem_j=/*(IRF4.6item*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]/*)*/;
  1425. C->_item_mem=1;
  1426. }
  1427. void r250initialize(T250* C){
  1428. int _i=0;
  1429. C->_count=0;
  1430. C->_free=1;
  1431. C->_has_mem=0;
  1432. C->_item_mem=0;
  1433. _i=1;
  1434. while (!((_i)==(r429count(((T429*)((((T250*)C))->_chain/*12*/)))))) {
  1435. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  1436. int b1=(_i)+(1);
  1437. int b2=_i;
  1438. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1439. }/*]*/
  1440. _i=(_i)+(1);
  1441. }
  1442. /*[IRF3.6put*/{T429* C1=((T429*)((((T250*)C))->_chain/*12*/));
  1443. int b1=0;
  1444. int b2=_i;
  1445. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  1446. }/*]*/
  1447. _i=0;
  1448. while (!((_i)>=((((T250*)C))->_modulus/*20*/))) {
  1449. /*[IRF3.5put*/((((T226*)((T226*)((((T250*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  1450. /*]*/
  1451. _i=(_i)+(1);
  1452. }
  1453. }
  1454. T0*oBC364eh=NULL;
  1455. void r376check_creation_clause(T376* C,T0* a1){
  1456. /*IF*/if (/*(IRF4.7has_creation_clause*/((((T605*)((T605*)(X291base_class(a1)))))->_creation_clause_list/*44*/)!=(NULL)/*)*/) {
  1457. /*[IRF3.6append*/{T0* b1=((T0*)ms1_334);
  1458. r7append(((T7*)(oBC683explanation)),b1);
  1459. }/*]*/
  1460. r683add_type(a1,((T0*)ms2_334));
  1461. r376error((((T376*)C))->_start_position/*8*/,((T0*)ms3_334));
  1462. }
  1463. /*FI*/}
  1464. T0* r376add_comment(T376* C,T0* a1){
  1465. T0* R=NULL;
  1466. /*IF*/if (((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r52count(((T52*)((((T393*)((T393*)a1)))->_list/*4*/)))/*)*/)==(0))) {
  1467. R=(T0*)C;
  1468. }
  1469. /*AF*/else {
  1470. {T46*n=malloc(sizeof(*n));
  1471. *n=M46;
  1472. r46make(n,(T0*)C,a1);
  1473. R=(T0*)n;
  1474. }
  1475. }
  1476. /*FI*/return R;
  1477. }
  1478. void r376check_created_type(T376* C,T0* a1){
  1479. T0* _rt=NULL;
  1480. _rt=X291run_type(a1);
  1481. /*IF*/if ((((T604*)((T604*)(oBC364small_eiffel))))->_short_flag/*4*/) {
  1482. }
  1483.  else if ((((T605*)((T605*)(X291base_class(_rt)))))->_is_deferred/*16*/) {
  1484. r683add_type(_rt,((T0*)ms2_747));
  1485. r683add_position((((T376*)C))->_start_position/*8*/);
  1486. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms3_747);
  1487. r683fatal_error(((T683*)(oBC364eh)),b1);
  1488. }/*]*/
  1489. }
  1490. /*FI*//*IF*/if (X291is_formal_generic(a1)) {
  1491. r683add_position((((T376*)C))->_start_position/*8*/);
  1492. /*[IRF3.6append*/{T0* b1=((T0*)ms4_747);
  1493. r7append(((T7*)(oBC683explanation)),b1);
  1494. }/*]*/
  1495. r683add_type(a1,((T0*)ms5_747));
  1496. r683print_as_fatal_error(((T683*)(oBC364eh)));
  1497. }
  1498. /*FI*/r355set_at_run_time(((T355*)(X291run_class(_rt))));
  1499. }
  1500. T0*oBC364gc_handler=NULL;
  1501. /*No:CREATION_CALL_2.writable*/
  1502. void r376make(T376* C,T0* a1,T0* a2,T0* a3){
  1503. C->_start_position=a1;
  1504. C->_type=a2;
  1505. C->_writable=a3;
  1506. }
  1507. /*No:CREATION_CALL_2.type*/
  1508. void r376c2c_closing(T376* C,T0* a1){
  1509. X662compile_to_c((((T376*)C))->_writable/*12*/);
  1510. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1511. char b1='\75';
  1512. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1513. }/*]*/
  1514. /*]*/
  1515. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms85_470));
  1516. /*]*/
  1517. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1518. char b1='n';
  1519. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1520. }/*]*/
  1521. /*]*/
  1522. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms134_470));
  1523. /*]*/
  1524. /*IF*/if (r324call_invariant_start(a1)) {
  1525. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1526. char b1='n';
  1527. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1528. }/*]*/
  1529. /*]*/
  1530. /*[IRF3.2call_invariant_end*//*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  1531. char b1='\51';
  1532. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1533. }/*]*/
  1534. /*]*/
  1535. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1536. char b1='\73';
  1537. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1538. }/*]*/
  1539. /*]*/
  1540. }
  1541. /*FI*//*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1542. char b1='\175';
  1543. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1544. }/*]*/
  1545. /*]*/
  1546. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1547. char b1='\n';
  1548. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1549. }/*]*/
  1550. /*]*/
  1551. r324rs_pop_position(((T324*)(oBC364cpp)));
  1552. }
  1553. void r376c2c_clear_expanded(T376* C,int a1){
  1554. X662compile_to_c((((T376*)C))->_writable/*12*/);
  1555. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1556. char b1='\75';
  1557. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1558. }/*]*/
  1559. /*]*/
  1560. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1561. char b1='M';
  1562. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1563. }/*]*/
  1564. /*]*/
  1565. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),a1);
  1566. /*]*/
  1567. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms134_470));
  1568. /*]*/
  1569. }
  1570. /*No:CREATION_CALL_2.start_position*/
  1571. void r376compile_to_c(T376* C){
  1572. /*IF*/if (X291is_reference((((T376*)C))->_type/*16*/)) {
  1573. r376c2c_opening(C,(((T376*)C))->_type/*16*/);
  1574. r376c2c_closing(C,(((T376*)C))->_type/*16*/);
  1575. }
  1576. else {
  1577. r376c2c_clear_expanded(C,X291id((((T376*)C))->_type/*16*/));
  1578. }
  1579. /*FI*/}
  1580. /*No:CREATION_CALL_2.fz_00*/
  1581. T0* r376to_runnable(T376* C,T0* a1){
  1582. T0* R=NULL;
  1583. /*IF*/if (((((T376*)C))->_run_compound/*4*/)==((void*)(NULL))) {
  1584. r376check_writable(C,a1);
  1585. r376check_explicit_type(C);
  1586. r376check_created_type(C,(((T376*)C))->_type/*16*/);
  1587. r376check_creation_clause(C,(((T376*)C))->_type/*16*/);
  1588. R=(T0*)C;
  1589. }
  1590. else {
  1591. {T376*n=malloc(sizeof(*n));
  1592. *n=M376;
  1593. r376make(n,(((T376*)C))->_start_position/*8*/,(((T376*)C))->_type/*16*/,(((T376*)C))->_writable/*12*/);
  1594. R=(T0*)n;
  1595. }
  1596. R=r376to_runnable(((T376*)R),a1);
  1597. }
  1598. /*FI*/return R;
  1599. }
  1600. T0*oBC364cpp=NULL;
  1601. T0* r376current_type(T376* C){
  1602. T0* R=NULL;
  1603. /*IF*/if (((((T376*)C))->_run_compound/*4*/)!=((void*)(NULL))) {
  1604. R=(((T592*)((T592*)((((T376*)C))->_run_compound/*4*/))))->_current_type/*4*/;
  1605. }
  1606. /*FI*/return R;
  1607. }
  1608. void r376c2c_opening(T376* C,T0* a1){
  1609. T0* _rc=NULL;
  1610. _rc=X291run_class(a1);
  1611. r324rs_push_position(((T324*)(oBC364cpp)),'5',(((T376*)C))->_start_position/*8*/);
  1612. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  1613. char b1='\173';
  1614. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1615. }/*]*/
  1616. /*]*/
  1617. r548put_new(((T548*)(oBC364gc_handler)),_rc);
  1618. r324expanded_attributes(((T324*)(oBC364cpp)),a1);
  1619. }
  1620. T0*oBC364small_eiffel=NULL;
  1621. /*No:CREATION_CALL_2.run_compound*/
  1622. void r376check_explicit_type(T376* C){
  1623. T0* _t=NULL;
  1624. _t=X291to_runnable((((T376*)C))->_type/*16*/,r376current_type(C));
  1625. /*IF*/if (((_t)==((void*)(NULL)))||(!(X291is_run_type(_t)))) {
  1626. r683add_position(X291start_position((((T376*)C))->_type/*16*/));
  1627. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms1_432);
  1628. r683fatal_error(((T683*)(oBC364eh)),b1);
  1629. }/*]*/
  1630. }
  1631. else {
  1632. C->_type=_t;
  1633. }
  1634. /*FI*//*IF*/if (!(X291is_a((((T376*)C))->_type/*16*/,X662result_type((((T376*)C))->_writable/*12*/)))) {
  1635. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms2_432);
  1636. r683fatal_error(((T683*)(oBC364eh)),b1);
  1637. }/*]*/
  1638. }
  1639. /*FI*/}
  1640. int r376is_pre_computable(T376* C){
  1641. int R=0;
  1642. R=X662is_result((((T376*)C))->_writable/*12*/);
  1643. return R;
  1644. }
  1645. /*No:CREATION_CALL_2.fz_cast_t0_star*/
  1646. int r376use_current(T376* C){
  1647. int R=0;
  1648. R=X662use_current((((T376*)C))->_writable/*12*/);
  1649. return R;
  1650. }
  1651. void r376check_writable(T376* C,T0* a1){
  1652. T0* _w=NULL;
  1653. C->_run_compound=a1;
  1654. _w=X662to_runnable((((T376*)C))->_writable/*12*/,r376current_type(C));
  1655. /*IF*/if ((_w)==((void*)(NULL))) {
  1656. r683add_position(X662start_position((((T376*)C))->_writable/*12*/));
  1657. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms1_747);
  1658. r683fatal_error(((T683*)(oBC364eh)),b1);
  1659. }/*]*/
  1660. }
  1661. else {
  1662. C->_writable=_w;
  1663. }
  1664. /*FI*/}
  1665. void r376error(T0* a1,T0* a2){
  1666. r683add_position(a1);
  1667. r683error(((T683*)(oBC364eh)),a2);
  1668. }
  1669. /*No:CREATION_CALL_2.fatal_error*/
  1670. /*No:CREATION_CALL_2.end_mark_comment*/
  1671. /*No:CREATION_CALL_2.afd_check*/
  1672. /*No:E_REQUIRE.is_require_else*/
  1673. /*No:E_REQUIRE.empty*/
  1674. void r343from_runnable(T343* C,T0* a1){
  1675. C->_list=a1;
  1676. C->_current_type=(((T348*)((T348*)(r608item(((T608*)((((T343*)C))->_list/*8*/)),1)))))->_current_type/*12*/;
  1677. }
  1678. void r343make(T343* C,T0* a1,T0* a2,T0* a3){
  1679. C->_start_position=a1;
  1680. C->_header_comment=a2;
  1681. C->_list=a3;
  1682. }
  1683. T0* r343check_assertion_mode(void){
  1684. T0* R=NULL;
  1685. R=((T0*)ms73_343);
  1686. return R;
  1687. }
  1688. /*No:E_REQUIRE.set_header_comment*/
  1689. /*No:E_REQUIRE.start_position*/
  1690. void r343compile_to_c(T343* C){
  1691. int _i=0;
  1692. /*IF*/if (((((T343*)C))->_list/*8*/)!=((void*)(NULL))) {
  1693. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms1_596));
  1694. /*]*/
  1695. _i=1;
  1696. while (!((_i)>((((T608*)((T608*)((((T343*)C))->_list/*8*/))))->_upper/*8*/))) {
  1697. /*[IRF3.3set_check_assertion_mode*/((((T324*)(((T324*)(oBC364cpp)))))->_check_assertion_mode)=(r343check_assertion_mode());
  1698. /*]*/
  1699. r348compile_to_c(((T348*)(r608item(((T608*)((((T343*)C))->_list/*8*/)),_i))));
  1700. _i=(_i)+(1);
  1701. }
  1702. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms2_596));
  1703. /*]*/
  1704. }
  1705. /*FI*/}
  1706. /*No:E_REQUIRE.list*/
  1707. /*No:E_REQUIRE.current_type*/
  1708. /*No:E_REQUIRE.header_comment*/
  1709. int r343use_current(T343* C){
  1710. int R=0;
  1711. int _i=0;
  1712. /*IF*/if (((((T343*)C))->_list/*8*/)!=((void*)(NULL))) {
  1713. _i=(((T608*)((T608*)((((T343*)C))->_list/*8*/))))->_upper/*8*/;
  1714. while (!((R)||((_i)==(0)))) {
  1715. R=r348use_current(((T348*)(r608item(((T608*)((((T343*)C))->_list/*8*/)),_i))));
  1716. _i=(_i)-(1);
  1717. }
  1718. }
  1719. /*FI*/return R;
  1720. }
  1721. /*No:E_REQUIRE.set_require_else*/
  1722. void r343afd_check(T343* C){
  1723. int _i=0;
  1724. /*IF*/if (((((T343*)C))->_list/*8*/)!=((void*)(NULL))) {
  1725. _i=(((T608*)((T608*)((((T343*)C))->_list/*8*/))))->_upper/*8*/;
  1726. while (!((_i)==(0))) {
  1727. r348afd_check(((T348*)(r608item(((T608*)((((T343*)C))->_list/*8*/)),_i))));
  1728. _i=(_i)-(1);
  1729. }
  1730. }
  1731. /*FI*/}
  1732. /*No:C_PRETTY_PRINTER.msg1*/
  1733. T0*oBC861stack_cpc=NULL;
  1734. /*No:C_PRETTY_PRINTER.generating_type_used*/
  1735. /*No:C_PRETTY_PRINTER.fz_sys*/
  1736. /*No:C_PRETTY_PRINTER.msg2*/
  1737. void r324put_extern3(T324* C,T0* a1,T0* a2){
  1738. r324incr_elt_c_count(C,1);
  1739. r544put_string(((T544*)(oBC324out_c)),((T0*)ms76_324));
  1740. r544put_string(((T544*)(oBC324out_c)),a1);
  1741. r544put_string(((T544*)(oBC324out_c)),((T0*)ms77_324));
  1742. r544put_string(((T544*)(oBC324out_c)),a2);
  1743. r544put_string(((T544*)(oBC324out_c)),((T0*)ms78_324));
  1744. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),((T0*)ms79_324));
  1745. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),a1);
  1746. /*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_out_h/*52*/));
  1747. char b1='\133';
  1748. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1749. }/*]*/
  1750. /*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_out_h/*52*/));
  1751. char b1='\135';
  1752. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1753. }/*]*/
  1754. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),((T0*)ms134_470));
  1755. }
  1756. T0*oBC364unique_string=NULL;
  1757. /*No:C_PRETTY_PRINTER.C_expanded_initialize*/
  1758. T0*oBC364tmp_file_read=NULL;
  1759. /*No:C_PRETTY_PRINTER.us_integer*/
  1760. /*No:C_PRETTY_PRINTER.inspect_level*/
  1761. void r324cdef_id(T324* C,T0* a1,int a2){
  1762. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC324tmp_string)))))->_count)=(0);
  1763. /*]*/
  1764. r7extend(((T7*)(oBC324tmp_string)),'\43');
  1765. r7append(((T7*)(oBC324tmp_string)),((T0*)ms100_470));
  1766. r7extend(((T7*)(oBC324tmp_string)),'\40');
  1767. r7append(((T7*)(oBC324tmp_string)),a1);
  1768. r7append(((T7*)(oBC324tmp_string)),((T0*)ms170_324));
  1769. r2append_in(a2,oBC324tmp_string);
  1770. r7extend(((T7*)(oBC324tmp_string)),'\n');
  1771. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),oBC324tmp_string);
  1772. }
  1773. void r324put_extern4(T324* C,T0* a1,T0* a2,int a3){
  1774. r324incr_elt_c_count(C,1);
  1775. r544put_string(((T544*)(oBC324out_c)),a1);
  1776. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  1777. char b1='\40';
  1778. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1779. }/*]*/
  1780. r544put_string(((T544*)(oBC324out_c)),a2);
  1781. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  1782. char b1='\133';
  1783. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1784. }/*]*/
  1785. r544put_integer(((T544*)(oBC324out_c)),a3);
  1786. r544put_string(((T544*)(oBC324out_c)),((T0*)ms80_324));
  1787. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),((T0*)ms103_470));
  1788. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),a1);
  1789. /*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_out_h/*52*/));
  1790. char b1='\40';
  1791. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1792. }/*]*/
  1793. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),a2);
  1794. /*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_out_h/*52*/));
  1795. char b1='\133';
  1796. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1797. }/*]*/
  1798. /*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_out_h/*52*/));
  1799. char b1='\135';
  1800. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1801. }/*]*/
  1802. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),((T0*)ms134_470));
  1803. }
  1804. void r324use_switch(T324* C,T0* a1,T0* a2,T0* a3,T0* a4){
  1805. int _switch=0;
  1806. T0* _rf=NULL;
  1807. T0* _rc=NULL;
  1808. T0* _rt=NULL;
  1809. /*IF*/if ((r590boost(((T590*)(oBC364run_control))))&&(r324stupid_switch(a1))) {
  1810. C->_direct_call_count=((((T324*)C))->_direct_call_count/*40*/)+(1);
  1811. r576remove(a1);
  1812. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms118_470));
  1813. /*]*/
  1814. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  1815. char b1='X';
  1816. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1817. }/*]*/
  1818. /*]*/
  1819. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)C))->_current_out/*56*/)),X291id(/*X496*/((T0*)(((T832*)((T832*)a1)))->_current_type/*4*/)));
  1820. /*]*/
  1821. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms81_470));
  1822. /*]*/
  1823. _rt=/*X496*/((T0*)(((T832*)((T832*)a1)))->_result_type/*24*/);
  1824. /*IF*/if ((_rt)!=((void*)(NULL))) {
  1825. r7copy(((T7*)(oBC324tmp_string)),((T0*)ms151_470));
  1826. X291c_type_for_result_in(_rt,oBC324tmp_string);
  1827. r7extend(((T7*)(oBC324tmp_string)),'\51');
  1828. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),oBC324tmp_string);
  1829. /*]*/
  1830. }
  1831. /*FI*/_rc=r396item(((T396*)a2),1);
  1832. _rf=r355dynamic(((T355*)_rc),a1);
  1833. r324push_direct(C,_rf,a3,a4);
  1834. X496mapping_c(_rf);
  1835. r324pop(C);
  1836. /*IF*/if ((_rt)!=((void*)(NULL))) {
  1837. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  1838. char b1='\51';
  1839. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1840. }/*]*/
  1841. /*]*/
  1842. }
  1843. /*FI*/}
  1844. else {
  1845. C->_switch_count=((((T324*)C))->_switch_count/*48*/)+(1);
  1846. r544put_string(((T544*)(oBC324out_c)),r798name(a1));
  1847. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  1848. char b1='\50';
  1849. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1850. }/*]*/
  1851. /*IF*/if (r590no_check(((T590*)(oBC364run_control)))) {
  1852. r324put_position(C,X662start_position(a3));
  1853. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  1854. char b1='\54';
  1855. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1856. }/*]*/
  1857. }
  1858. /*FI*/X662compile_to_c(a3);
  1859. /*IF*/if ((a4)!=((void*)(NULL))) {
  1860. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  1861. char b1='\54';
  1862. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1863. }/*]*/
  1864. X431compile_to_c(a4,/*X496*/((T0*)(((T832*)((T832*)a1)))->_arguments/*20*/));
  1865. }
  1866. /*FI*//*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  1867. char b1='\51';
  1868. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1869. }/*]*/
  1870. /*]*/
  1871. /*IF*/if ((/*X496*/((T0*)(((T832*)((T832*)a1)))->_result_type/*24*/))==((void*)(NULL))) {
  1872. r544put_string(((T544*)(oBC324out_c)),((T0*)ms134_470));
  1873. }
  1874. /*FI*/}
  1875. /*FI*/}
  1876. void r324put_inspect(T324* C){
  1877. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  1878. char b1='z';
  1879. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1880. }/*]*/
  1881. /*]*/
  1882. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)C))->_current_out/*56*/)),(((T324*)C))->_inspect_level/*72*/);
  1883. /*]*/
  1884. }
  1885. void r324put_string_c(T0* a1){
  1886. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC324tmp_string)))))->_count)=(0);
  1887. /*]*/
  1888. r340string_to_c_code(a1,oBC324tmp_string);
  1889. r544put_string(((T544*)(oBC324out_c)),oBC324tmp_string);
  1890. }
  1891. /*No:C_PRETTY_PRINTER.set_oflag*/
  1892. /*No:C_PRETTY_PRINTER.call_invariant_end*/
  1893. void r324variant_check(T324* C,T0* a1){
  1894. r324rs_push_position(C,'6',X662start_position(a1));
  1895. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms162_324));
  1896. /*]*/
  1897. X662compile_to_c(a1);
  1898. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms148_470));
  1899. /*]*/
  1900. }
  1901. void r324backup_sfw_connect(T324* C,T0* a1,T0* a2){
  1902. r7copy(((T7*)(oBC324tmp_string3)),a2);
  1903. r7extend(((T7*)(oBC324tmp_string3)),'\176');
  1904. r324echo_rename_file(a2,oBC324tmp_string3);
  1905. r324sfw_connect(C,a1,a2);
  1906. }
  1907. /*No:C_PRETTY_PRINTER.split_c_now*/
  1908. void r324connect_cecil_out_h(T324* C,T0* a1){
  1909. {T544*n=malloc(sizeof(*n));
  1910. *n=M544;
  1911. /*[IRF3.1make*//*]*/
  1912. C->_out_h=(T0*)n;
  1913. }
  1914. r324sfw_connect(C,(((T324*)C))->_out_h/*52*/,a1);
  1915. }
  1916. int fBC364make_suffix=0;
  1917. T0*oBC364make_suffix=NULL;
  1918. T0* r324make_suffix(T324* C){
  1919. if (fBC364make_suffix==0){
  1920. T0* R=NULL;
  1921. fBC364make_suffix=1;
  1922. /*IF*/if ((((T0*)ms14_364))==((void*)(r324system_name(C)))) {
  1923. R=((T0*)ms33_364);
  1924. }
  1925.  else if ((((T0*)ms19_364))==((void*)(r324system_name(C)))) {
  1926. R=((T0*)ms34_364);
  1927. }
  1928.  else if ((((T0*)ms18_364))==((void*)(r324system_name(C)))) {
  1929. R=((T0*)ms35_364);
  1930. }
  1931.  else if ((((T0*)ms16_364))==((void*)(r324system_name(C)))) {
  1932. R=((T0*)ms36_364);
  1933. }
  1934. else {
  1935. R=((T0*)ms37_364);
  1936. }
  1937. /*FI*/oBC364make_suffix=R;}
  1938. return oBC364make_suffix;}
  1939. void r324trace_boolean_expression(T324* C,T0* a1){
  1940. r324rs_push_position(C,'2',X662start_position(a1));
  1941. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms149_324));
  1942. /*]*/
  1943. X662compile_to_c(a1);
  1944. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  1945. char b1='\51';
  1946. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1947. }/*]*/
  1948. /*]*/
  1949. }
  1950. void r324expanded_attributes(T324* C,T0* a1){
  1951. T0* _rf3=NULL;
  1952. int _i=0;
  1953. T0* _at=NULL;
  1954. T0* _a=NULL;
  1955. T0* _wa=NULL;
  1956. _wa=r355writable_attributes(((T355*)(X291run_class(a1))));
  1957. /*IF*/if ((_wa)!=((void*)(NULL))) {
  1958. _i=/*X477*/((int)(((T477*)((T477*)_wa)))->_upper/*12*/);
  1959. while (!((_i)==(0))) {
  1960. _a=/*X477*/((T0*)r477item(((T477*)_wa),_i));
  1961. _at=X291run_type(/*X496*/((T0*)(((T832*)((T832*)_a)))->_result_type/*24*/));
  1962. _rf3=X291expanded_initializer(_at);
  1963. /*IF*/if ((_rf3)!=((void*)(NULL))) {
  1964. r324stack_push(C,1011);
  1965. /*X32*//*[IRF3.6put*/{T32* C1=((T32*)(oBC861stack_target));
  1966. T0* b1=NULL;
  1967. int b2=(((T324*)C))->_top/*32*/;
  1968. ((((T32*)C1))->_storage/*4*/)[b2]=(b1);
  1969. }/*]*/
  1970. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_rf));
  1971. T0* b1=_a;
  1972. int b2=(((T324*)C))->_top/*32*/;
  1973. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  1974. }/*]*/
  1975. C->_direct_call_count=((((T324*)C))->_direct_call_count/*40*/)+(1);
  1976. r832mapping_c(((T832*)_rf3));
  1977. r324pop(C);
  1978. }
  1979. /*FI*/_i=(_i)-(1);
  1980. }
  1981. }
  1982. /*FI*/}
  1983. void r324put_extern5(T324* C,T0* a1,T0* a2){
  1984. r324incr_elt_c_count(C,1);
  1985. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),((T0*)ms103_470));
  1986. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),a1);
  1987. r544put_string(((T544*)((((T324*)C))->_out_h/*52*/)),((T0*)ms134_470));
  1988. r544put_string(((T544*)(oBC324out_c)),a1);
  1989. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  1990. char b1='\75';
  1991. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  1992. }/*]*/
  1993. r544put_string(((T544*)(oBC324out_c)),a2);
  1994. r544put_string(((T544*)(oBC324out_c)),((T0*)ms134_470));
  1995. }
  1996. T0* r324get_inline_ms(T324* C){
  1997. T0* R=NULL;
  1998. T0* _e=NULL;
  1999. _e=X431expression(/*(IRF4.6item*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]/*)*/,1);
  2000. R=_e;
  2001. if(NULL!=(R))switch(((T0*)R)->id) {
  2002. case 805: 
  2003. break;
  2004. default:
  2005. R=NULL;
  2006. };/*IF*/if ((R)==((void*)(NULL))) {
  2007. r683add_position(X662start_position(_e));
  2008. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms182_324);
  2009. r683fatal_error(((T683*)(oBC364eh)),b1);
  2010. }/*]*/
  2011. }
  2012. /*FI*//*[IRF3.6used_for_inline*/{T0* b1=R;
  2013. r256add_last(((T256*)(oBC340dummy_ms_list)),b1);
  2014. }/*]*/
  2015. return R;
  2016. }
  2017. /*No:C_PRETTY_PRINTER.echo_make*/
  2018. void r324write_make_file(T324* C){
  2019. double _score=0;
  2020. /*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_out_h/*52*/));
  2021. char b1='\n';
  2022. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2023. }/*]*/
  2024. r544disconnect(((T544*)((((T324*)C))->_out_h/*52*/)));
  2025. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  2026. char b1='\n';
  2027. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2028. }/*]*/
  2029. r544disconnect(((T544*)(oBC324out_c)));
  2030. r324sfw_connect(C,oBC324out_make,r324path_make(C));
  2031. /*IF*/if ((((T324*)C))->_no_split/*112*/) {
  2032. r324write_make_file_no_split(C);
  2033. }
  2034. else {
  2035. r324write_make_file_split(C);
  2036. }
  2037. /*FI*//*IF*/if (!((((T324*)C))->_no_strip/*108*/)) {
  2038. r324print_strip(C);
  2039. }
  2040. /*FI*/r544disconnect(((T544*)(oBC324out_make)));
  2041. /*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)>(0)) {
  2042. r306file_removing(((T306*)(oBC364echo)),r324path_make(C));
  2043. }
  2044. else {
  2045. r306put_string(((T306*)(oBC364echo)),((T0*)ms177_324));
  2046. _score=((((T324*)C))->_direct_call_count/*40*/)+((((T324*)C))->_check_id_count/*36*/);
  2047. _score=((_score)/((_score)+((((T324*)C))->_switch_count/*48*/)))*(100.0);
  2048. r306put_double_format(((T306*)(oBC364echo)),_score,2);
  2049. r306put_character(((T306*)(oBC364echo)),'\45');
  2050. r306put_character(((T306*)(oBC364echo)),'\n');
  2051. }
  2052. /*FI*//*[IRF3.2show_nb_warnings*/r818show_nb(/*(IRF4.9nb_warnings*/(((T683*)((T683*)(oBC364eh))))->_nb_warnings/*4*//*)*/,((T0*)ms9_818));
  2053. /*]*/
  2054. /*[IRF3.2show_nb_errors*/r818show_nb(/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/,((T0*)ms10_818));
  2055. /*]*/
  2056. r306put_string(((T306*)(oBC364echo)),((T0*)ms136_470));
  2057. }
  2058. /*No:C_PRETTY_PRINTER.rename_file*/
  2059. void r324push_new(T324* C,T0* a1,T0* a2){
  2060. r324stack_push(C,1010);
  2061. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_rf));
  2062. T0* b1=a1;
  2063. int b2=(((T324*)C))->_top/*32*/;
  2064. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  2065. }/*]*/
  2066. /*[IRF3.5put*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(a2);
  2067. /*]*/
  2068. C->_direct_call_count=((((T324*)C))->_direct_call_count/*40*/)+(1);
  2069. }
  2070. /*No:C_PRETTY_PRINTER.nb_errors*/
  2071. void r324inline_level_decr(T324* C){
  2072. C->_inline_level=((((T324*)C))->_inline_level/*76*/)-(1);
  2073. }
  2074. void r324put_target_as_value(T324* C){
  2075. T0* _direct_rf=NULL;
  2076. T0* _c0c=NULL;
  2077. T0* _args=NULL;
  2078. T0* _target=NULL;
  2079. T0* _static_rf=NULL;
  2080. T0* _rf=NULL;
  2081. int _code=0;
  2082. _code=/*(IRF4.6item*/((((T226*)((T226*)(oBC861stack_code))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]/*)*/;
  2083. {int z1=_code;
  2084.  
  2085. if((1007==z1)){
  2086. X662compile_to_c(/*X32*/((T0*)r32item(((T32*)(oBC861stack_target)),(((T324*)C))->_top/*32*/)));
  2087. }
  2088.  else 
  2089. if((1008==z1)){
  2090. X291mapping_cast(/*X496*/((T0*)(((T832*)((T832*)(/*X321*/((T0*)r321item(((T321*)(oBC861stack_rf)),(((T324*)C))->_top/*32*/))))))->_current_type/*4*/));
  2091. X662compile_to_c(/*X32*/((T0*)r32item(((T32*)(oBC861stack_target)),(((T324*)C))->_top/*32*/)));
  2092. }
  2093.  else 
  2094. if((1012==z1)){
  2095. _rf=/*X321*/((T0*)r321item(((T321*)(oBC861stack_rf)),(((T324*)C))->_top/*32*/));
  2096. _target=/*X32*/((T0*)r32item(((T32*)(oBC861stack_target)),(((T324*)C))->_top/*32*/));
  2097. _args=/*(IRF4.6item*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]/*)*/;
  2098. _static_rf=/*X321*/((T0*)r321item(((T321*)(oBC861stack_static_rf)),(((T324*)C))->_top/*32*/));
  2099. C->_top=((((T324*)C))->_top/*32*/)-(1);
  2100. _c0c=_target;
  2101. if(NULL!=(_c0c))switch(((T0*)_c0c)->id) {
  2102. case 487: 
  2103. break;
  2104. default:
  2105. _c0c=NULL;
  2106. };_direct_rf=(((T487*)((T487*)_c0c)))->_run_feature/*20*/;
  2107. X496mapping_c(_direct_rf);
  2108. C->_top=((((T324*)C))->_top/*32*/)+(1);
  2109. /*[IRF3.5put*/((((T226*)((T226*)(oBC861stack_code))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(_code);
  2110. /*]*/
  2111. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_rf));
  2112. T0* b1=_rf;
  2113. int b2=(((T324*)C))->_top/*32*/;
  2114. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  2115. }/*]*/
  2116. /*X32*//*[IRF3.6put*/{T32* C1=((T32*)(oBC861stack_target));
  2117. T0* b1=_target;
  2118. int b2=(((T324*)C))->_top/*32*/;
  2119. ((((T32*)C1))->_storage/*4*/)[b2]=(b1);
  2120. }/*]*/
  2121. /*[IRF3.5put*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(_args);
  2122. /*]*/
  2123. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_static_rf));
  2124. T0* b1=_static_rf;
  2125. int b2=(((T324*)C))->_top/*32*/;
  2126. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  2127. }/*]*/
  2128. }
  2129.  else 
  2130. if((1013==z1)){
  2131. _rf=/*X321*/((T0*)r321item(((T321*)(oBC861stack_rf)),(((T324*)C))->_top/*32*/));
  2132. _args=/*(IRF4.6item*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]/*)*/;
  2133. C->_top=((((T324*)C))->_top/*32*/)-(1);
  2134. r324put_target_as_value(C);
  2135. C->_top=((((T324*)C))->_top/*32*/)+(1);
  2136. /*[IRF3.5put*/((((T226*)((T226*)(oBC861stack_code))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(_code);
  2137. /*]*/
  2138. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_rf));
  2139. T0* b1=_rf;
  2140. int b2=(((T324*)C))->_top/*32*/;
  2141. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  2142. }/*]*/
  2143. /*[IRF3.5put*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(_args);
  2144. /*]*/
  2145. }
  2146.  else{r324common_put_target(C);
  2147. }}
  2148. }
  2149. /*No:C_PRETTY_PRINTER.inlined_procedure_count*/
  2150. /*No:C_PRETTY_PRINTER.fz_open_c_comment*/
  2151. void r324path_c_copy_in(T324* C,T0* a1,int a2){
  2152. /*[IRF3.3clear*/((((T7*)(((T7*)a1))))->_count)=(0);
  2153. /*]*/
  2154. r7append(((T7*)a1),r324path_h(C));
  2155. r7remove_last(((T7*)a1),(((T7*)((T7*)(((T0*)ms27_364)))))->_count/*4*/);
  2156. r2append_in(a2,a1);
  2157. r7append(((T7*)a1),((T0*)ms26_364));
  2158. }
  2159. int fBC324c_compiler=0;
  2160. T0*oBC324c_compiler=NULL;
  2161. T0* r324c_compiler(T324* C){
  2162. if (fBC324c_compiler==0){
  2163. T0* R=NULL;
  2164. fBC324c_compiler=1;
  2165. {T7*n=malloc(sizeof(*n));
  2166. *n=M7;
  2167. r7make(n,12);
  2168. R=(T0*)n;
  2169. }
  2170. r7copy(((T7*)(oBC324tmp_string)),r324small_eiffel_directory(C));
  2171. r324add_directory(C,oBC324tmp_string,((T0*)ms126_470));
  2172. r7append(((T7*)(oBC324tmp_string)),((T0*)ms174_324));
  2173. r7append(((T7*)(oBC324tmp_string)),r324system_name(C));
  2174. r306sfr_connect(((T306*)(oBC364echo)),oBC364tmp_file_read,oBC324tmp_string);
  2175. r675read_line_in(((T675*)(oBC364tmp_file_read)),R);
  2176. r675disconnect(((T675*)(oBC364tmp_file_read)));
  2177. oBC324c_compiler=R;}
  2178. return oBC324c_compiler;}
  2179. int fBC324path_make=0;
  2180. T0*oBC324path_make=NULL;
  2181. T0* r324path_make(T324* C){
  2182. if (fBC324path_make==0){
  2183. T0* R=NULL;
  2184. fBC324path_make=1;
  2185. R=r7twin(((T7*)(r324path_h(C))));
  2186. r7remove_last(((T7*)R),(((T7*)((T7*)(((T0*)ms27_364)))))->_count/*4*/);
  2187. r7append(((T7*)R),r324make_suffix(C));
  2188. oBC324path_make=R;}
  2189. return oBC324path_make;}
  2190. void r324inspect_decr(T324* C){
  2191. C->_inspect_level=((((T324*)C))->_inspect_level/*72*/)-(1);
  2192. }
  2193. void r324define_initialize(T324* C){
  2194. int _no_check=0;
  2195. _no_check=r590no_check(((T590*)(oBC364run_control)));
  2196. r306put_string(((T306*)(oBC364echo)),((T0*)ms168_324));
  2197. /*[IRF3.2define_extern_tables*/{int _size=0;
  2198. _size=(r410max_id(((T410*)(r604id_provider()))))+(1);
  2199. /*IF*/if ((((T324*)((T324*)(oBC364cpp))))->_generator_used/*84*/) {
  2200. r324put_extern4(((T324*)(oBC364cpp)),((T0*)ms129_470),((T0*)ms40_604),_size);
  2201. }
  2202. /*FI*//*IF*/if ((((T324*)((T324*)(oBC364cpp))))->_generating_type_used/*80*/) {
  2203. r324put_extern4(((T324*)(oBC364cpp)),((T0*)ms129_470),((T0*)ms41_604),_size);
  2204. }
  2205. /*FI*//*IF*/if (r590no_check(((T590*)(oBC364run_control)))) {
  2206. r324put_extern4(((T324*)(oBC364cpp)),((T0*)ms42_604),((T0*)ms43_604),_size);
  2207. }
  2208. /*FI*/}/*]*/
  2209. /*IF*/if (_no_check) {
  2210. /*[IRF3.4split_c_now*/r324incr_elt_c_count(C,(1960)+(1));
  2211. /*]*/
  2212. }
  2213. /*FI*/r324put_c_heading(C,((T0*)ms169_324));
  2214. /*[IRF3.3swap_on_c*/((((T324*)(C)))->_current_out)=(oBC324out_c);
  2215. /*]*/
  2216. /*IF*/if (_no_check) {
  2217. /*[IRF3.2initialize_path_table*/{T0* _rc=NULL;
  2218. T0* _bc=NULL;
  2219. int _i=0;
  2220. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms44_604));
  2221. /*]*/
  2222. _i=1;
  2223. while (!((_i)>((((T718*)((T718*)(oBC604base_class_dictionary))))->_count/*40*/))) {
  2224. _bc=r718item(((T718*)(oBC604base_class_dictionary)),_i);
  2225. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms45_604));
  2226. /*]*/
  2227. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T605*)((T605*)_bc)))->_id/*0*/);
  2228. /*]*/
  2229. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms46_604));
  2230. /*]*/
  2231. r324put_string_c((((T605*)((T605*)_bc)))->_path/*4*/);
  2232. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms134_470));
  2233. /*]*/
  2234. _i=(_i)+(1);
  2235. }
  2236. _i=1;
  2237. while (!((_i)>((((T250*)((T250*)(oBC604run_class_dictionary))))->_count/*40*/))) {
  2238. _rc=r250item(((T250*)(oBC604run_class_dictionary)),_i);
  2239. /*IF*/if (((((T355*)((T355*)_rc)))->_at_run_time/*8*/)&&(X291is_generic((((T355*)((T355*)_rc)))->_current_type/*0*/))) {
  2240. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms47_604));
  2241. /*]*/
  2242. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T355*)((T355*)_rc)))->_id/*4*/);
  2243. /*]*/
  2244. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms48_604));
  2245. /*]*/
  2246. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T605*)((T605*)(r355base_class(((T355*)_rc))))))->_id/*0*/);
  2247. /*]*/
  2248. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms49_604));
  2249. /*]*/
  2250. }
  2251. /*FI*/_i=(_i)+(1);
  2252. }
  2253. }/*]*/
  2254. }
  2255. /*FI*//*IF*/if ((((T324*)C))->_generator_used/*84*/) {
  2256. /*[IRF3.2initialize_generator*/{T0* _rc=NULL;
  2257. T0* _bc=NULL;
  2258. int _i=0;
  2259. _i=1;
  2260. while (!((_i)>((((T718*)((T718*)(oBC604base_class_dictionary))))->_count/*40*/))) {
  2261. _bc=r718item(((T718*)(oBC604base_class_dictionary)),_i);
  2262. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms50_604));
  2263. /*]*/
  2264. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T605*)((T605*)_bc)))->_id/*0*/);
  2265. /*]*/
  2266. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms51_604));
  2267. /*]*/
  2268. r324put_string_c((((T451*)((T451*)((((T605*)((T605*)_bc)))->_base_class_name/*24*/))))->_to_string/*0*/);
  2269. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms148_470));
  2270. /*]*/
  2271. _i=(_i)+(1);
  2272. }
  2273. _i=1;
  2274. while (!((_i)>((((T250*)((T250*)(oBC604run_class_dictionary))))->_count/*40*/))) {
  2275. _rc=r250item(((T250*)(oBC604run_class_dictionary)),_i);
  2276. /*IF*/if (((((T355*)((T355*)_rc)))->_at_run_time/*8*/)&&(X291is_generic((((T355*)((T355*)_rc)))->_current_type/*0*/))) {
  2277. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms52_604));
  2278. /*]*/
  2279. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T355*)((T355*)_rc)))->_id/*4*/);
  2280. /*]*/
  2281. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms53_604));
  2282. /*]*/
  2283. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T605*)((T605*)(r355base_class(((T355*)_rc))))))->_id/*0*/);
  2284. /*]*/
  2285. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms54_604));
  2286. /*]*/
  2287. }
  2288. /*FI*/_i=(_i)+(1);
  2289. }
  2290. }/*]*/
  2291. }
  2292. /*FI*//*IF*/if ((((T324*)C))->_generating_type_used/*80*/) {
  2293. /*[IRF3.2initialize_generating_type*/{T0* _rc=NULL;
  2294. int _i=0;
  2295. _i=1;
  2296. while (!((_i)>((((T250*)((T250*)(oBC604run_class_dictionary))))->_count/*40*/))) {
  2297. _rc=r250item(((T250*)(oBC604run_class_dictionary)),_i);
  2298. /*IF*/if ((((T355*)((T355*)_rc)))->_at_run_time/*8*/) {
  2299. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms55_604));
  2300. /*]*/
  2301. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T355*)((T355*)_rc)))->_id/*4*/);
  2302. /*]*/
  2303. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms56_604));
  2304. /*]*/
  2305. /*IF*/if (X291is_generic((((T355*)((T355*)_rc)))->_current_type/*0*/)) {
  2306. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms57_604));
  2307. /*]*/
  2308. r324put_string_c(X291run_time_mark((((T355*)((T355*)_rc)))->_current_type/*0*/));
  2309. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  2310. char b1='\51';
  2311. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2312. }/*]*/
  2313. /*]*/
  2314. }
  2315. else {
  2316. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms58_604));
  2317. /*]*/
  2318. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),(((T355*)((T355*)_rc)))->_id/*4*/);
  2319. /*]*/
  2320. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/));
  2321. char b1='\135';
  2322. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2323. }/*]*/
  2324. /*]*/
  2325. }
  2326. /*FI*//*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms134_470));
  2327. /*]*/
  2328. }
  2329. /*FI*/_i=(_i)+(1);
  2330. }
  2331. }/*]*/
  2332. }
  2333. /*FI*//*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms146_470));
  2334. /*]*/
  2335. /*IF*/if (_no_check) {
  2336. /*[IRF3.4split_c_now*/r324incr_elt_c_count(C,(1960)+(1));
  2337. /*]*/
  2338. }
  2339. /*FI*/}
  2340. void r324push_same_target(T324* C,T0* a1,T0* a2){
  2341. r324stack_push(C,1013);
  2342. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_rf));
  2343. T0* b1=a1;
  2344. int b2=(((T324*)C))->_top/*32*/;
  2345. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  2346. }/*]*/
  2347. /*[IRF3.5put*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(a2);
  2348. /*]*/
  2349. }
  2350. /*No:C_PRETTY_PRINTER.swap_on_c*/
  2351. void r324add_directory(T324* C,T0* a1,T0* a2){
  2352. /*IF*/if ((((T0*)ms17_364))==((void*)(r324system_name(C)))) {
  2353. r7set_last(((T7*)a1),'\57');
  2354. r7append(((T7*)a1),a2);
  2355. r7set_last(((T7*)a1),'\57');
  2356. }
  2357.  else if ((((T0*)ms19_364))==((void*)(r324system_name(C)))) {
  2358. r7set_last(((T7*)a1),'\134');
  2359. r7append(((T7*)a1),a2);
  2360. r7set_last(((T7*)a1),'\134');
  2361. }
  2362.  else if ((((T0*)ms15_364))==((void*)(r324system_name(C)))) {
  2363. r7set_last(((T7*)a1),'\72');
  2364. r7append(((T7*)a1),a2);
  2365. r7set_last(((T7*)a1),'\72');
  2366. }
  2367.  else if ((((T0*)ms14_364))==((void*)(r324system_name(C)))) {
  2368. r7set_last(((T7*)a1),'\134');
  2369. r7append(((T7*)a1),a2);
  2370. r7set_last(((T7*)a1),'\134');
  2371. }
  2372.  else if ((((T0*)ms16_364))==((void*)(r324system_name(C)))) {
  2373. r7set_last(((T7*)a1),'\134');
  2374. r7append(((T7*)a1),a2);
  2375. r7set_last(((T7*)a1),'\134');
  2376. }
  2377.  else if ((((T0*)ms13_364))==((void*)(r324system_name(C)))) {
  2378. r7set_last(((T7*)a1),'\57');
  2379. r7append(((T7*)a1),a2);
  2380. r7set_last(((T7*)a1),'\57');
  2381. }
  2382.  else if ((((T0*)ms18_364))==((void*)(r324system_name(C)))) {
  2383. r7set_last(((T7*)a1),'\135');
  2384. r7remove_last(((T7*)a1),1);
  2385. r7set_last(((T7*)a1),'\56');
  2386. r7append(((T7*)a1),a2);
  2387. r7set_last(((T7*)a1),'\135');
  2388. }
  2389. /*FI*/}
  2390. /*No:C_PRETTY_PRINTER.static_expression_count*/
  2391. /*No:C_PRETTY_PRINTER.C_inline_dca*/
  2392. void r324write_make_file_split(T324* C){
  2393. int _i=0;
  2394. _i=(((T324*)C))->_split_count/*88*/;
  2395. while (!((_i)==(0))) {
  2396. r324path_c_copy_in(C,oBC324tmp_string,_i);
  2397. r7copy(((T7*)(oBC324tmp_string2)),oBC324tmp_string);
  2398. r7extend(((T7*)(oBC324tmp_string2)),'\176');
  2399. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC324tmp_string3)))))->_count)=(0);
  2400. /*]*/
  2401. r324path_o_in(C,oBC324tmp_string3,_i);
  2402. /*IF*/if ((r324file_exists(oBC324tmp_string3))&&(r670same_files(oBC324tmp_string,oBC324tmp_string2))) {
  2403. r306put_string(((T306*)(oBC364echo)),((T0*)ms135_470));
  2404. r306put_string(((T306*)(oBC364echo)),oBC324tmp_string3);
  2405. r306put_string(((T306*)(oBC364echo)),((T0*)ms183_324));
  2406. }
  2407. else {
  2408. r306file_removing(((T306*)(oBC364echo)),oBC324tmp_string3);
  2409. r324call_c_compiler(C);
  2410. r7append(((T7*)(oBC324tmp_string)),((T0*)ms184_324));
  2411. r7append(((T7*)(oBC324tmp_string)),oBC324tmp_string2);
  2412. r7remove_last(((T7*)(oBC324tmp_string)),1);
  2413. /*[IRF3.2echo_make*/r544put_string(((T544*)(oBC324out_make)),oBC324tmp_string);
  2414. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_make));
  2415. char b1='\n';
  2416. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2417. }/*]*/
  2418. /*]*/
  2419. }
  2420. /*FI*/_i=(_i)-(1);
  2421. r306file_removing(((T306*)(oBC364echo)),oBC324tmp_string2);
  2422. }
  2423. r324call_c_linker(C);
  2424. r324add_oflag(C);
  2425. _i=1;
  2426. while (!((_i)>((((T324*)C))->_split_count/*88*/))) {
  2427. r324path_o_in(C,oBC324tmp_string,_i);
  2428. r7extend(((T7*)(oBC324tmp_string)),'\40');
  2429. _i=(_i)+(1);
  2430. }
  2431. r324tmp_string_object_library(C);
  2432. /*[IRF3.2echo_make*/r544put_string(((T544*)(oBC324out_make)),oBC324tmp_string);
  2433. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_make));
  2434. char b1='\n';
  2435. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2436. }/*]*/
  2437. /*]*/
  2438. }
  2439. /*No:C_PRETTY_PRINTER.windows_system*/
  2440. /*No:C_PRETTY_PRINTER.fz_00*/
  2441. void r324incr_real_procedure_count(T324* C){
  2442. C->_real_procedure_count=((((T324*)C))->_real_procedure_count/*16*/)+(1);
  2443. }
  2444. void r324inside_twin(T324* C,T0* a1){
  2445. r324stack_push(C,1015);
  2446. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_rf));
  2447. T0* b1=a1;
  2448. int b2=(((T324*)C))->_top/*32*/;
  2449. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  2450. }/*]*/
  2451. X496mapping_c(a1);
  2452. r324pop(C);
  2453. }
  2454. /*No:C_PRETTY_PRINTER.rs_push_result*/
  2455. void r324put_comment(T324* C,T0* a1){
  2456. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms118_470));
  2457. /*]*/
  2458. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),a1);
  2459. /*]*/
  2460. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms81_470));
  2461. /*]*/
  2462. }
  2463. /*No:C_PRETTY_PRINTER.fz_01*/
  2464. void r324define_used_basics(T324* C){
  2465. int _no_check=0;
  2466. _no_check=r590no_check(((T590*)(oBC364run_control)));
  2467. r306put_string(((T306*)(oBC364echo)),((T0*)ms113_324));
  2468. /*IF*/if ((((T324*)C))->_sprintf_double_flag/*128*/) {
  2469. r324put_extern1(C,((T0*)ms114_324));
  2470. }
  2471. /*FI*//*IF*/if (r604string_at_run_time()) {
  2472. /*[IRF3.2define_se_ms*/r7copy(((T7*)(oBC340header)),((T0*)ms1_340));
  2473. r7copy(((T7*)(oBC340body)),((T0*)ms129_470));
  2474. r7extend(((T7*)(oBC340body)),'s');
  2475. r7extend(((T7*)(oBC340body)),'\75');
  2476. /*IF*/if ((((T548*)((T548*)(oBC364gc_handler))))->_is_on/*0*/) {
  2477. ((/*UT*/(void)(((T491*)(r340type_string())))));
  2478. r491gc_call_new_in(oBC340body);
  2479. r7append(((T7*)(oBC340body)),((T0*)ms134_470));
  2480. }
  2481. else {
  2482. r7append(((T7*)(oBC340body)),((T0*)ms2_340));
  2483. /*IF*/if (r355is_tagged(((T355*)(r491run_class(((T491*)(r340type_string()))))))) {
  2484. r7append(((T7*)(oBC340body)),((T0*)ms3_340));
  2485. }
  2486. /*FI*/}
  2487. /*FI*/r7append(((T7*)(oBC340body)),((T0*)ms4_340));
  2488. /*IF*/if ((((T548*)((T548*)(oBC364gc_handler))))->_is_on/*0*/) {
  2489. r7append(((T7*)(oBC340body)),((T0*)ms115_470));
  2490. r7extend(((T7*)(oBC340body)),'9');
  2491. }
  2492. else {
  2493. r7append(((T7*)(oBC340body)),((T0*)ms88_473));
  2494. }
  2495. /*FI*/r7append(((T7*)(oBC340body)),((T0*)ms5_340));
  2496. r324put_c_function(((T324*)(oBC364cpp)),oBC340header,oBC340body);
  2497. r324put_c_function(((T324*)(oBC364cpp)),((T0*)ms6_340),((T0*)ms7_340));
  2498. r324put_c_function(((T324*)(oBC364cpp)),((T0*)ms8_340),((T0*)ms9_340));
  2499. /*]*/
  2500. }
  2501. /*FI*//*[IRF3.2c_define*/{int _i=0;
  2502. _i=1;
  2503. while (!((_i)>((((T79*)((T79*)(oBC94manifest_array_types))))->_count/*40*/))) {
  2504. r94c_define_for(r79item(((T79*)(oBC94manifest_array_types)),_i));
  2505. _i=(_i)+(1);
  2506. }
  2507. }/*]*/
  2508. /*IF*/if (_no_check) {
  2509. r324put_c_function(C,((T0*)ms115_324),((T0*)ms116_324));
  2510. }
  2511. else {
  2512. r324put_c_function(C,((T0*)ms117_324),((T0*)ms118_324));
  2513. }
  2514. /*FI*//*IF*/if (_no_check) {
  2515. r324put_c_function(C,((T0*)ms119_324),((T0*)ms120_324));
  2516. r324put_c_function(C,((T0*)ms121_324),((T0*)ms122_324));
  2517. r324put_c_function(C,((T0*)ms123_324),((T0*)ms124_324));
  2518. r324put_c_function(C,((T0*)ms125_324),((T0*)ms126_324));
  2519. r324put_c_function(C,((T0*)ms127_324),((T0*)ms128_324));
  2520. r324put_c_function(C,((T0*)ms129_324),((T0*)ms130_324));
  2521. }
  2522. /*FI*/r324put_c_function(C,((T0*)ms131_324),((T0*)ms132_324));
  2523. /*[IRF3.2c_define*/{int _switch=0;
  2524. int _total=0;
  2525. int _count2=0;
  2526. int _count1=0;
  2527. T0* _dictionary2=NULL;
  2528. /*IF*/if (!(/*(IRF4.7empty*/((((T338*)((T338*)(oBC576dictionary))))->_count/*40*/)==(0)/*)*/)) {
  2529. /*[IRF3.3swap_on_c*/((((T324*)(((T324*)(oBC364cpp)))))->_current_out)=(oBC324out_c);
  2530. /*]*/
  2531. /*[IRF3.4split_c_now*/r324incr_elt_c_count(((T324*)(oBC364cpp)),(1960)+(1));
  2532. /*]*/
  2533. _count1=1;
  2534. while (!((_count1)>((((T338*)((T338*)(oBC576dictionary))))->_count/*40*/))) {
  2535. _dictionary2=r338item(((T338*)(oBC576dictionary)),_count1);
  2536. _count2=1;
  2537. while (!((_count2)>((((T199*)((T199*)_dictionary2)))->_count/*40*/))) {
  2538. r798c_define(_switch,r199item(((T199*)_dictionary2),_count2));
  2539. _total=(_total)+(1);
  2540. r324incr_elt_c_count(((T324*)(oBC364cpp)),20);
  2541. _count2=(_count2)+(1);
  2542. }
  2543. _count1=(_count1)+(1);
  2544. }
  2545. /*[IRF3.4split_c_now*/r324incr_elt_c_count(((T324*)(oBC364cpp)),(1960)+(1));
  2546. /*]*/
  2547. }
  2548. /*FI*/r306print_count(((T306*)(oBC364echo)),((T0*)ms1_576),_total);
  2549. }/*]*/
  2550. /*IF*/if (((((T324*)C))->_to_expanded_mem/*64*/)!=((void*)(NULL))) {
  2551. r324define_to_expanded(C);
  2552. }
  2553. /*FI*//*IF*/if (((((T324*)C))->_to_reference_mem/*60*/)!=((void*)(NULL))) {
  2554. r324define_to_reference(C);
  2555. }
  2556. /*FI*//*IF*/if (((((T324*)C))->_sure_void_count/*44*/)>(0)) {
  2557. r306put_string(((T306*)(oBC364echo)),((T0*)ms133_324));
  2558. r306put_integer(((T306*)(oBC364echo)),(((T324*)C))->_sure_void_count/*44*/);
  2559. r306put_string(((T306*)(oBC364echo)),((T0*)ms134_324));
  2560. }
  2561. /*FI*/r306print_count(((T306*)(oBC364echo)),((T0*)ms135_324),(((T324*)C))->_direct_call_count/*40*/);
  2562. r306print_count(((T306*)(oBC364echo)),((T0*)ms136_324),(((T324*)C))->_check_id_count/*36*/);
  2563. r306print_count(((T306*)(oBC364echo)),((T0*)ms137_324),(((T324*)C))->_switch_count/*48*/);
  2564. r306print_count(((T306*)(oBC364echo)),((T0*)ms138_324),(((T324*)C))->_inlined_procedure_count/*0*/);
  2565. r306print_count(((T306*)(oBC364echo)),((T0*)ms139_324),(((T324*)C))->_inlined_function_count/*4*/);
  2566. r306print_count(((T306*)(oBC364echo)),((T0*)ms140_324),(((T324*)C))->_static_expression_count/*24*/);
  2567. r306print_count(((T306*)(oBC364echo)),((T0*)ms141_324),(((T324*)C))->_real_procedure_count/*16*/);
  2568. r306print_count(((T306*)(oBC364echo)),((T0*)ms142_324),(((T324*)C))->_real_function_count/*20*/);
  2569. r306print_count(((T306*)(oBC364echo)),((T0*)ms143_324),(((T324*)C))->_procedure_count/*8*/);
  2570. r306print_count(((T306*)(oBC364echo)),((T0*)ms144_324),(((T324*)C))->_function_count/*12*/);
  2571. /*IF*/if (((((T324*)C))->_pre_computed_once/*28*/)!=((void*)(NULL))) {
  2572. r306print_count(((T306*)(oBC364echo)),((T0*)ms145_324),r365count(((T365*)((((T324*)C))->_pre_computed_once/*28*/))));
  2573. }
  2574. /*FI*/r306put_string(((T306*)(oBC364echo)),((T0*)ms146_324));
  2575. r306put_integer(((T306*)(oBC364echo)),/*(IRF4.6count*/((((T226*)((T226*)(oBC861stack_code))))->_upper/*8*/)+(1)/*)*/);
  2576. r306put_character(((T306*)(oBC364echo)),'\n');
  2577. r324define_initialize(C);
  2578. }
  2579. /*No:C_PRETTY_PRINTER.fz_gc_info*/
  2580. /*No:C_PRETTY_PRINTER.fz_11*/
  2581. /*No:C_PRETTY_PRINTER.fz_02*/
  2582. void r324incr_inlined_function_count(T324* C){
  2583. C->_inlined_function_count=((((T324*)C))->_inlined_function_count/*4*/)+(1);
  2584. }
  2585. /*No:C_PRETTY_PRINTER.check_id_count*/
  2586. T0* r324get_environment_variable(T324* C,T0* a1){
  2587. T0* R=NULL;
  2588. void* _p=0;
  2589. _p=r7to_external(((T7*)a1));
  2590. R=(NULL==(_p=getenv((char*)_p)))?NULL:((T0*)e2s((char*)_p));
  2591. return R;
  2592. }
  2593. void r324put_c_function(T324* C,T0* a1,T0* a2){
  2594. r324incr_elt_c_count(C,15);
  2595. r324put_c_heading(C,a1);
  2596. r544put_string(((T544*)(oBC324out_c)),a2);
  2597. r544put_string(((T544*)(oBC324out_c)),((T0*)ms146_470));
  2598. }
  2599. /*No:C_PRETTY_PRINTER.fz_12*/
  2600. int fBC324path_c=0;
  2601. T0*oBC324path_c=NULL;
  2602. T0* r324path_c(T324* C){
  2603. if (fBC324path_c==0){
  2604. T0* R=NULL;
  2605. fBC324path_c=1;
  2606. /*IF*/if ((((T324*)C))->_no_split/*112*/) {
  2607. R=r7twin(((T7*)(r324path_h(C))));
  2608. /*[IRF3.6remove_suffix*/{T7* C1=((T7*)R);
  2609. T0* b1=((T0*)ms27_364);
  2610. r7remove_last(C1,(((T7*)((T7*)b1)))->_count/*4*/);
  2611. }/*]*/
  2612. r7append(((T7*)R),((T0*)ms26_364));
  2613. }
  2614. else {
  2615. C->_split_count=1;
  2616. {T7*n=malloc(sizeof(*n));
  2617. *n=M7;
  2618. r7make(n,((((T7*)((T7*)(r324path_h(C)))))->_count/*4*/)+(2));
  2619. R=(T0*)n;
  2620. }
  2621. r324path_c_copy_in(C,R,(((T324*)C))->_split_count/*88*/);
  2622. }
  2623. /*FI*/oBC324path_c=R;}
  2624. return oBC324path_c;}
  2625. /*No:C_PRETTY_PRINTER.fz_c_no_args_procedure*/
  2626. void r324check_id(T324* C,T0* a1,int a2){
  2627. /*IF*/if (r590no_check(((T590*)(oBC364run_control)))) {
  2628. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2629. char b1='\50';
  2630. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2631. }/*]*/
  2632. /*]*/
  2633. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2634. char b1='\50';
  2635. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2636. }/*]*/
  2637. /*]*/
  2638. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2639. char b1='T';
  2640. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2641. }/*]*/
  2642. /*]*/
  2643. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)C))->_current_out/*56*/)),a2);
  2644. /*]*/
  2645. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms161_324));
  2646. /*]*/
  2647. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)C))->_current_out/*56*/)),a2);
  2648. /*]*/
  2649. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2650. char b1='\54';
  2651. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2652. }/*]*/
  2653. /*]*/
  2654. X662compile_to_c(a1);
  2655. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2656. char b1='\54';
  2657. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2658. }/*]*/
  2659. /*]*/
  2660. r324put_position(C,X662start_position(a1));
  2661. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms147_470));
  2662. /*]*/
  2663. C->_check_id_count=((((T324*)C))->_check_id_count/*36*/)+(1);
  2664. }
  2665. else {
  2666. X662compile_to_c(a1);
  2667. C->_direct_call_count=((((T324*)C))->_direct_call_count/*40*/)+(1);
  2668. }
  2669. /*FI*/}
  2670. T0*oBC364manifest_array_pool=NULL;
  2671. /*No:C_PRETTY_PRINTER.fz_13*/
  2672. void r324define_to_reference(T324* C){
  2673. T0* _dest_type=NULL;
  2674. T0* _src_type=NULL;
  2675. T0* _dest_rc=NULL;
  2676. T0* _src_rc=NULL;
  2677. int _i=0;
  2678. _i=1;
  2679. while (!((_i)>((((T396*)((T396*)((((T324*)C))->_to_reference_mem/*60*/))))->_upper/*8*/))) {
  2680. _src_rc=r396item(((T396*)((((T324*)C))->_to_reference_mem/*60*/)),_i);
  2681. _i=(_i)+(1);
  2682. _dest_rc=r396item(((T396*)((((T324*)C))->_to_reference_mem/*60*/)),_i);
  2683. _i=(_i)+(1);
  2684. _src_type=(((T355*)((T355*)_src_rc)))->_current_type/*0*/;
  2685. _dest_type=(((T355*)((T355*)_dest_rc)))->_current_type/*0*/;
  2686. r306put_string(((T306*)(oBC364echo)),((T0*)ms187_324));
  2687. r306put_string(((T306*)(oBC364echo)),X291run_time_mark(_src_type));
  2688. r306put_string(((T306*)(oBC364echo)),((T0*)ms89_324));
  2689. r306put_string(((T306*)(oBC364echo)),X291run_time_mark(_dest_type));
  2690. r306put_string(((T306*)(oBC364echo)),((T0*)ms186_324));
  2691. r7copy(((T7*)(oBC324tmp_string)),((T0*)ms128_470));
  2692. r324conversion_name((((T355*)((T355*)_dest_rc)))->_id/*4*/);
  2693. r7extend(((T7*)(oBC324tmp_string)),'\50');
  2694. X291c_type_for_target_in(_src_type,oBC324tmp_string);
  2695. r7append(((T7*)(oBC324tmp_string)),((T0*)ms90_324));
  2696. r324put_c_heading(C,oBC324tmp_string);
  2697. /*[IRF3.3swap_on_c*/((((T324*)(C)))->_current_out)=(oBC324out_c);
  2698. /*]*/
  2699. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC324tmp_string)))))->_count)=(0);
  2700. /*]*/
  2701. X291c_type_for_target_in(_dest_type,oBC324tmp_string);
  2702. r7append(((T7*)(oBC324tmp_string)),((T0*)ms91_324));
  2703. /*IF*/if (r355is_tagged(((T355*)_dest_rc))) {
  2704. r7extend(((T7*)(oBC324tmp_string)),'d');
  2705. r7append(((T7*)(oBC324tmp_string)),((T0*)ms53_470));
  2706. r7extend(((T7*)(oBC324tmp_string)),'\75');
  2707. r2append_in((((T355*)((T355*)_dest_rc)))->_id/*4*/,oBC324tmp_string);
  2708. r7extend(((T7*)(oBC324tmp_string)),'\73');
  2709. }
  2710. /*FI*/r7append(((T7*)(oBC324tmp_string)),((T0*)ms92_324));
  2711. r544put_string(((T544*)(oBC324out_c)),oBC324tmp_string);
  2712. }
  2713. }
  2714. void r324define_main(T324* C,T0* a1){
  2715. T0* _ct=NULL;
  2716. T0* _rc=NULL;
  2717. int _id=0;
  2718. r306put_string(((T306*)(oBC364echo)),((T0*)ms97_324));
  2719. _ct=(((T832*)((T832*)a1)))->_current_type/*4*/;
  2720. _id=X291id(_ct);
  2721. _rc=r832run_class(((T832*)a1));
  2722. /*[IRF3.3swap_on_c*/((((T324*)(C)))->_current_out)=(oBC324out_c);
  2723. /*]*/
  2724. /*[IRF3.4split_c_now*/r324incr_elt_c_count(C,(1960)+(1));
  2725. /*]*/
  2726. r324put_extern1(C,((T0*)ms98_324));
  2727. r324put_extern1(C,((T0*)ms99_324));
  2728. /*IF*/if ((((T590*)((T590*)(oBC364run_control))))->_trace/*4*/) {
  2729. r324put_extern1(C,((T0*)ms100_324));
  2730. r324put_extern2(C,((T0*)ms101_324),'0');
  2731. }
  2732. /*FI*//*IF*/if ((((T0*)ms18_364))==((void*)(r324system_name(C)))) {
  2733. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms133_470));
  2734. /*]*/
  2735. }
  2736. else {
  2737. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms111_470));
  2738. /*]*/
  2739. }
  2740. /*FI*//*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms102_324));
  2741. /*]*/
  2742. /*IF*/if ((((T548*)((T548*)(oBC364gc_handler))))->_is_on/*0*/) {
  2743. /*[IRF3.2initialize*/{T0* _rcd=NULL;
  2744. T0* _rc=NULL;
  2745. int _i=0;
  2746. r7copy(((T7*)(oBC548body)),((T0*)ms28_548));
  2747. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),oBC548body);
  2748. /*]*/
  2749. _rcd=oBC604run_class_dictionary;
  2750. _i=1;
  2751. while (!((_i)>((((T250*)((T250*)_rcd)))->_count/*40*/))) {
  2752. _rc=r250item(((T250*)_rcd),_i);
  2753. r355gc_initialize(((T355*)_rc));
  2754. _i=(_i)+(1);
  2755. }
  2756. }/*]*/
  2757. }
  2758. /*FI*//*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms103_324));
  2759. /*]*/
  2760. /*IF*/if ((((T548*)((T548*)(oBC364gc_handler))))->_is_on/*0*/) {
  2761. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms104_324));
  2762. /*]*/
  2763. }
  2764. /*FI*/r548put_new(((T548*)(oBC364gc_handler)),_rc);
  2765. /*IF*/if ((((T548*)((T548*)(oBC364gc_handler))))->_is_on/*0*/) {
  2766. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms105_324));
  2767. /*]*/
  2768. }
  2769. /*FI*//*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms106_324));
  2770. /*]*/
  2771. /*[IRF3.2c_call_initialize*/{int _nb=0;
  2772. int _i=0;
  2773. _i=(((T256*)((T256*)(oBC340ms_list))))->_upper/*12*/;
  2774. _nb=1;
  2775. while (!((_i)<(0))) {
  2776. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms12_340));
  2777. /*]*/
  2778. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),_nb);
  2779. /*]*/
  2780. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)((T324*)(oBC364cpp))))->_current_out/*56*/)),((T0*)ms93_470));
  2781. /*]*/
  2782. _i=(_i)-(20);
  2783. _nb=(_nb)+(1);
  2784. }
  2785. }/*]*/
  2786. /*IF*/if (r590no_check(((T590*)(oBC364run_control)))) {
  2787. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms107_324));
  2788. /*]*/
  2789. }
  2790. /*FI*/r324expanded_attributes(C,_ct);
  2791. /*IF*/if ((((T324*)C))->_sprintf_double_flag/*128*/) {
  2792. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms108_324));
  2793. /*]*/
  2794. }
  2795. /*FI*/r324once_pre_computing(C);
  2796. /*IF*/if ((((T590*)((T590*)(oBC364run_control))))->_trace/*4*/) {
  2797. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms109_324));
  2798. /*]*/
  2799. }
  2800. /*FI*/r324push_new(C,a1,NULL);
  2801. r832mapping_c(((T832*)a1));
  2802. r324pop(C);
  2803. /*IF*/if (r590invariant_check(((T590*)(oBC364run_control)))) {
  2804. /*IF*/if (((((T355*)((T355*)_rc)))->_invariant_assertion/*16*/)!=((void*)(NULL))) {
  2805. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2806. char b1='i';
  2807. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2808. }/*]*/
  2809. /*]*/
  2810. /*[IRF3.5put_integer*/r544put_integer(((T544*)((((T324*)C))->_current_out/*56*/)),_id);
  2811. /*]*/
  2812. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2813. char b1='\50';
  2814. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2815. }/*]*/
  2816. /*]*/
  2817. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2818. char b1='n';
  2819. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2820. }/*]*/
  2821. /*]*/
  2822. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2823. char b1='\51';
  2824. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2825. }/*]*/
  2826. /*]*/
  2827. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms134_470));
  2828. /*]*/
  2829. }
  2830. /*FI*/}
  2831. /*FI*//*IF*/if (r590no_check(((T590*)(oBC364run_control)))) {
  2832. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms110_324));
  2833. /*]*/
  2834. }
  2835. /*FI*//*IF*/if ((((T548*)((T548*)(oBC364gc_handler))))->_info_flag/*4*/) {
  2836. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms106_470));
  2837. /*]*/
  2838. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms93_470));
  2839. /*]*/
  2840. }
  2841. /*FI*//*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms111_324));
  2842. /*]*/
  2843. r324incr_elt_c_count(C,10);
  2844. r306put_string(((T306*)(oBC364echo)),((T0*)ms112_324));
  2845. r306put_integer(((T306*)(oBC364echo)),/*(IRF4.9count*/(((T794*)((T794*)(oBC902memory))))->_count/*32*//*)*/);
  2846. r306put_string(((T306*)(oBC364echo)),((T0*)ms241_470));
  2847. /*[IRF3.2c_define*/{T0* _ms=NULL;
  2848. int _nb=0;
  2849. int _j=0;
  2850. int _i=0;
  2851. r306print_count(((T306*)(oBC364echo)),((T0*)ms10_340),/*(IRF4.6count*/((((T256*)((T256*)(oBC340ms_list))))->_upper/*12*/)+(1)/*)*/);
  2852. _i=(((T256*)((T256*)(oBC340ms_list))))->_upper/*12*/;
  2853. while (!((_i)<(0))) {
  2854. _ms=/*(IRF4.6item*/((((T256*)((T256*)(oBC340ms_list))))->_storage/*4*/)[_i]/*)*/;
  2855. /*IF*/if (r340not_dummy(_ms)) {
  2856. r7copy(((T7*)(oBC340header)),((T0*)ms129_470));
  2857. r7append(((T7*)(oBC340header)),(((T805*)((T805*)_ms)))->_mapping_c/*32*/);
  2858. r324put_extern1(((T324*)(oBC364cpp)),oBC340header);
  2859. }
  2860. /*FI*/_i=(_i)-(1);
  2861. }
  2862. _i=(((T256*)((T256*)(oBC340ms_list))))->_upper/*12*/;
  2863. _nb=1;
  2864. while (!((_i)<(0))) {
  2865. r7copy(((T7*)(oBC340header)),((T0*)ms133_470));
  2866. r7extend(((T7*)(oBC340header)),'\40');
  2867. r7append(((T7*)(oBC340header)),((T0*)ms12_340));
  2868. r2append_in(_nb,oBC340header);
  2869. r7append(((T7*)(oBC340header)),((T0*)ms97_470));
  2870. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC340body)))))->_count)=(0);
  2871. /*]*/
  2872. _j=20;
  2873. while (!(((_j)==(0))||((_i)<(0)))) {
  2874. _ms=/*(IRF4.6item*/((((T256*)((T256*)(oBC340ms_list))))->_storage/*4*/)[_i]/*)*/;
  2875. /*IF*/if (r340not_dummy(_ms)) {
  2876. r7append(((T7*)(oBC340body)),(((T805*)((T805*)_ms)))->_mapping_c/*32*/);
  2877. r7append(((T7*)(oBC340body)),((T0*)ms11_340));
  2878. r2append_in(/*(IRF4.6count*/(((T7*)((T7*)((((T805*)((T805*)_ms)))->_to_string/*16*/))))->_count/*4*//*)*/,oBC340body);
  2879. r7extend(((T7*)(oBC340body)),'\54');
  2880. r340string_to_c_code((((T805*)((T805*)_ms)))->_to_string/*16*/,oBC340body);
  2881. r7append(((T7*)(oBC340body)),((T0*)ms148_470));
  2882. }
  2883. /*FI*/_j=(_j)-(1);
  2884. _i=(_i)-(1);
  2885. }
  2886. r324put_c_function(((T324*)(oBC364cpp)),oBC340header,oBC340body);
  2887. _nb=(_nb)+(1);
  2888. }
  2889. }/*]*/
  2890. }
  2891. /*No:C_PRETTY_PRINTER.fz_04*/
  2892. T0*oBC364system_list=NULL;
  2893. void r324put_target_as_target(T324* C){
  2894. int _ivt_flag=0;
  2895. T0* _tt=NULL;
  2896. T0* _args=NULL;
  2897. T0* _target=NULL;
  2898. T0* _rf=NULL;
  2899. int _code=0;
  2900. _code=/*(IRF4.6item*/((((T226*)((T226*)(oBC861stack_code))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]/*)*/;
  2901. {int z1=_code;
  2902.  
  2903. if((1007==z1)){
  2904. _target=/*X32*/((T0*)r32item(((T32*)(oBC861stack_target)),(((T324*)C))->_top/*32*/));
  2905. _tt=/*X496*/((T0*)(((T832*)((T832*)(/*X321*/((T0*)r321item(((T321*)(oBC861stack_rf)),(((T324*)C))->_top/*32*/))))))->_current_type/*4*/);
  2906. X662mapping_c_target(_target,_tt);
  2907. }
  2908.  else 
  2909. if((1008==z1)){
  2910. _target=/*X32*/((T0*)r32item(((T32*)(oBC861stack_target)),(((T324*)C))->_top/*32*/));
  2911. _rf=/*X321*/((T0*)r321item(((T321*)(oBC861stack_rf)),(((T324*)C))->_top/*32*/));
  2912. _tt=/*X496*/((T0*)(((T832*)((T832*)_rf)))->_current_type/*4*/);
  2913. /*IF*/if (r590boost(((T590*)(oBC364run_control)))) {
  2914. X662mapping_c_target(_target,_tt);
  2915. }
  2916. else {
  2917. _ivt_flag=r324call_invariant_start(_tt);
  2918. r324check_id(C,_target,X496id(_rf));
  2919. /*IF*/if (_ivt_flag) {
  2920. /*[IRF3.2call_invariant_end*//*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  2921. char b1='\51';
  2922. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2923. }/*]*/
  2924. /*]*/
  2925. }
  2926. /*FI*/}
  2927. /*FI*/}
  2928.  else 
  2929. if((1012==z1)){
  2930. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2931. char b1='\50';
  2932. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2933. }/*]*/
  2934. /*]*/
  2935. X291mapping_cast(/*X496*/((T0*)(((T832*)((T832*)(/*X321*/((T0*)r321item(((T321*)(oBC861stack_rf)),(((T324*)C))->_top/*32*/))))))->_current_type/*4*/));
  2936. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  2937. char b1='\50';
  2938. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  2939. }/*]*/
  2940. /*]*/
  2941. r324put_target_as_value(C);
  2942. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms147_470));
  2943. /*]*/
  2944. }
  2945.  else 
  2946. if((1013==z1)){
  2947. _rf=/*X321*/((T0*)r321item(((T321*)(oBC861stack_rf)),(((T324*)C))->_top/*32*/));
  2948. _args=/*(IRF4.6item*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]/*)*/;
  2949. C->_top=((((T324*)C))->_top/*32*/)-(1);
  2950. r324put_target_as_target(C);
  2951. C->_top=((((T324*)C))->_top/*32*/)+(1);
  2952. /*[IRF3.5put*/((((T226*)((T226*)(oBC861stack_code))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(_code);
  2953. /*]*/
  2954. /*X321*//*[IRF3.6put*/{T321* C1=((T321*)(oBC861stack_rf));
  2955. T0* b1=_rf;
  2956. int b2=(((T324*)C))->_top/*32*/;
  2957. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  2958. }/*]*/
  2959. /*[IRF3.5put*/((((T374*)((T374*)(oBC861stack_args))))->_storage/*0*/)[(((T324*)C))->_top/*32*/]=(_args);
  2960. /*]*/
  2961. }
  2962.  else{r324common_put_target(C);
  2963. }}
  2964. }
  2965. /*No:C_PRETTY_PRINTER.fz_define*/
  2966. int fBC364system_name=0;
  2967. T0*oBC364system_name=NULL;
  2968. T0* r324system_name(T324* C){
  2969. if (fBC364system_name==0){
  2970. T0* R=NULL;
  2971. int _i=0;
  2972. fBC364system_name=1;
  2973. r7copy(((T7*)(oBC364tmp_path)),r324small_eiffel_directory(C));
  2974. /*IF*/if (r7has(((T7*)(oBC364tmp_path)),'\57')) {
  2975. r7set_last(((T7*)(oBC364tmp_path)),'\57');
  2976. r7append(((T7*)(oBC364tmp_path)),((T0*)ms126_470));
  2977. r7extend(((T7*)(oBC364tmp_path)),'\57');
  2978. r7append(((T7*)(oBC364tmp_path)),((T0*)ms127_470));
  2979. r306sfr_connect(((T306*)(oBC364echo)),oBC364tmp_file_read,oBC364tmp_path);
  2980. }
  2981. /*FI*//*IF*/if (!(/*(IRF4.7is_connected*/((((T675*)((T675*)(oBC364tmp_file_read))))->_path/*4*/)!=(NULL)/*)*/)) {
  2982. r7copy(((T7*)(oBC364tmp_path)),r324small_eiffel_directory(C));
  2983. /*IF*/if (r7has(((T7*)(oBC364tmp_path)),'\134')) {
  2984. r7set_last(((T7*)(oBC364tmp_path)),'\134');
  2985. r7append(((T7*)(oBC364tmp_path)),((T0*)ms126_470));
  2986. r7extend(((T7*)(oBC364tmp_path)),'\134');
  2987. r7append(((T7*)(oBC364tmp_path)),((T0*)ms127_470));
  2988. r306sfr_connect(((T306*)(oBC364echo)),oBC364tmp_file_read,oBC364tmp_path);
  2989. }
  2990. /*FI*/}
  2991. /*FI*//*IF*/if (!(/*(IRF4.7is_connected*/((((T675*)((T675*)(oBC364tmp_file_read))))->_path/*4*/)!=(NULL)/*)*/)) {
  2992. r7copy(((T7*)(oBC364tmp_path)),r324small_eiffel_directory(C));
  2993. /*IF*/if (r7has(((T7*)(oBC364tmp_path)),'\72')) {
  2994. r7set_last(((T7*)(oBC364tmp_path)),'\72');
  2995. r7append(((T7*)(oBC364tmp_path)),((T0*)ms126_470));
  2996. r7extend(((T7*)(oBC364tmp_path)),'\72');
  2997. r7append(((T7*)(oBC364tmp_path)),((T0*)ms127_470));
  2998. r306sfr_connect(((T306*)(oBC364echo)),oBC364tmp_file_read,oBC364tmp_path);
  2999. }
  3000. /*FI*/}
  3001. /*FI*//*IF*/if (!(/*(IRF4.7is_connected*/((((T675*)((T675*)(oBC364tmp_file_read))))->_path/*4*/)!=(NULL)/*)*/)) {
  3002. r7copy(((T7*)(oBC364tmp_path)),r324small_eiffel_directory(C));
  3003. /*IF*/if (r7has(((T7*)(oBC364tmp_path)),'\135')) {
  3004. r7set_last(((T7*)(oBC364tmp_path)),'\135');
  3005. r7remove_last(((T7*)(oBC364tmp_path)),1);
  3006. r7extend(((T7*)(oBC364tmp_path)),'\56');
  3007. r7append(((T7*)(oBC364tmp_path)),((T0*)ms126_470));
  3008. r7extend(((T7*)(oBC364tmp_path)),'\135');
  3009. r7append(((T7*)(oBC364tmp_path)),((T0*)ms127_470));
  3010. r306sfr_connect(((T306*)(oBC364echo)),oBC364tmp_file_read,oBC364tmp_path);
  3011. }
  3012. /*FI*/}
  3013. /*FI*//*IF*/if (!(/*(IRF4.7is_connected*/((((T675*)((T675*)(oBC364tmp_file_read))))->_path/*4*/)!=(NULL)/*)*/)) {
  3014. r7copy(((T7*)(oBC364tmp_path)),r324small_eiffel_directory(C));
  3015. r7append(((T7*)(oBC364tmp_path)),((T0*)ms127_470));
  3016. r306sfr_connect(((T306*)(oBC364echo)),oBC364tmp_file_read,oBC364tmp_path);
  3017. }
  3018. /*FI*//*IF*/if (!(/*(IRF4.7is_connected*/((((T675*)((T675*)(oBC364tmp_file_read))))->_path/*4*/)!=(NULL)/*)*/)) {
  3019. r306w_put_string(((T0*)ms20_364));
  3020. r306w_put_string(((T0*)ms127_470));
  3021. r306w_put_string(((T0*)ms21_364));
  3022. r306w_put_string(r324small_eiffel_directory(C));
  3023. r306w_put_string(((T0*)ms242_470));
  3024. exit(1);
  3025. }
  3026. /*FI*/r675read_line(((T675*)(oBC364tmp_file_read)));
  3027. R=oBC762last_string;
  3028. _i=r52index_of(((T52*)(oBC364system_list)),R);
  3029. r675disconnect(((T675*)(oBC364tmp_file_read)));
  3030. /*IF*/if ((_i)>((((T52*)((T52*)(oBC364system_list))))->_upper/*8*/)) {
  3031. r306w_put_string(((T0*)ms22_364));
  3032. r306w_put_string(oBC364tmp_path);
  3033. r306w_put_string(((T0*)ms23_364));
  3034. _i=1;
  3035. while (!((_i)>((((T52*)((T52*)(oBC364system_list))))->_upper/*8*/))) {
  3036. r306w_put_string(r52item(((T52*)(oBC364system_list)),_i));
  3037. r306w_put_character('\n');
  3038. _i=(_i)+(1);
  3039. }
  3040. }
  3041. else {
  3042. R=r52item(((T52*)(oBC364system_list)),_i);
  3043. r306put_string(((T306*)(oBC364echo)),((T0*)ms24_364));
  3044. r306put_string(((T306*)(oBC364echo)),R);
  3045. r306put_string(((T306*)(oBC364echo)),((T0*)ms242_470));
  3046. }
  3047. /*FI*/oBC364system_name=R;}
  3048. return oBC364system_name;}
  3049. /*No:C_PRETTY_PRINTER.fz_14*/
  3050. /*No:C_PRETTY_PRINTER.fz_05*/
  3051. void r324error_void_or_bad_type(T324* C,T0* a1){
  3052. r683add_position(X662start_position(a1));
  3053. /*[IRF3.6append*/{T0* b1=((T0*)ms151_324);
  3054. r7append(((T7*)(oBC683explanation)),b1);
  3055. }/*]*/
  3056. r683add_type(X291run_type(X662result_type(a1)),((T0*)ms152_324));
  3057. r683print_as_warning(((T683*)(oBC364eh)));
  3058. /*IF*/if (r590boost(((T590*)(oBC364run_control)))) {
  3059. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms153_324));
  3060. /*]*/
  3061. }
  3062. else {
  3063. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms154_324));
  3064. /*]*/
  3065. X662compile_to_c(a1);
  3066. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  3067. char b1='\54';
  3068. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  3069. }/*]*/
  3070. /*]*/
  3071. r324put_position(C,X662start_position(a1));
  3072. /*[IRF3.5put_character*//*[IRF3.6put_character*/{T544* C1=((T544*)((((T324*)C))->_current_out/*56*/));
  3073. char b1='\51';
  3074. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  3075. }/*]*/
  3076. /*]*/
  3077. }
  3078. /*FI*/}
  3079. void r324cecil_define(T324* C){
  3080. T0* _save_out_h=NULL;
  3081. r625c_define_internals(((T625*)(oBC364cecil_pool)));
  3082. _save_out_h=(((T324*)C))->_out_h/*52*/;
  3083. r625c_define_users(((T625*)(oBC364cecil_pool)));
  3084. C->_out_h=_save_out_h;
  3085. }
  3086. void r324rs_pop_position(T324* C){
  3087. /*IF*/if (r590no_check(((T590*)(oBC364run_control)))) {
  3088. /*[IRF3.5put_string*/r544put_string(((T544*)((((T324*)C))->_current_out/*56*/)),((T0*)ms160_324));
  3089. /*]*/
  3090. }
  3091. /*FI*/}
  3092. /*No:C_PRETTY_PRINTER.output_name*/
  3093. /*No:C_PRETTY_PRINTER.us_real*/
  3094. T0*oBC324tmp_string=NULL;
  3095. /*No:C_PRETTY_PRINTER.us_result*/
  3096. /*No:C_PRETTY_PRINTER.C_same_target*/
  3097. /*No:C_PRETTY_PRINTER.to_expanded_mem*/
  3098. /*No:C_PRETTY_PRINTER.os2_system*/
  3099. /*No:C_PRETTY_PRINTER.fz_17*/
  3100. void r324tmp_string_object_library(T324* C){
  3101. int _i=0;
  3102. /*IF*/if (((((T324*)C))->_c_object_list/*120*/)!=((void*)(NULL))) {
  3103. _i=(((T52*)((T52*)((((T324*)C))->_c_object_list/*120*/))))->_lower/*12*/;
  3104. while (!((_i)>((((T52*)((T52*)((((T324*)C))->_c_object_list/*120*/))))->_upper/*8*/))) {
  3105. r7extend(((T7*)(oBC324tmp_string)),'\40');
  3106. r7append(((T7*)(oBC324tmp_string)),r52item(((T52*)((((T324*)C))->_c_object_list/*120*/)),_i));
  3107. _i=(_i)+(1);
  3108. }
  3109. }
  3110. /*FI*//*IF*/if (((((T324*)C))->_c_library_list/*124*/)!=((void*)(NULL))) {
  3111. _i=(((T52*)((T52*)((((T324*)C))->_c_library_list/*124*/))))->_lower/*12*/;
  3112. while (!((_i)>((((T52*)((T52*)((((T324*)C))->_c_library_list/*124*/))))->_upper/*8*/))) {
  3113. r7extend(((T7*)(oBC324tmp_string)),'\40');
  3114. r7append(((T7*)(oBC324tmp_string)),r52item(((T52*)((((T324*)C))->_c_library_list/*124*/)),_i));
  3115. _i=(_i)+(1);
  3116. }
  3117. }
  3118. /*FI*/}
  3119. void r324pop(T324* C){
  3120. C->_top=((((T324*)C))->_top/*32*/)-(1);
  3121. }
  3122. void r324add_c_object(T324* C,T0* a1){
  3123. /*IF*/if (((((T324*)C))->_c_object_list/*120*/)==((void*)(NULL))) {
  3124. C->_c_object_list=se_ma52(1,a1);
  3125. }
  3126.  else if (r52has(((T52*)((((T324*)C))->_c_object_list/*120*/)),a1)) {
  3127. }
  3128. else {
  3129. r52add_last(((T52*)((((T324*)C))->_c_object_list/*120*/)),a1);
  3130. }
  3131. /*FI*/}
  3132. /*No:C_PRETTY_PRINTER.put_string*/
  3133. T0*oBC861stack_args=NULL;
  3134. /*No:C_PRETTY_PRINTER.fz_18*/
  3135. void r324swap_on_h(T324* C){
  3136. C->_current_out=(((T324*)C))->_out_h/*52*/;
  3137. }
  3138. /*No:C_PRETTY_PRINTER.top*/
  3139. /*No:C_PRETTY_PRINTER.C_check_id*/
  3140. int fBC324path_h=0;
  3141. T0*oBC324path_h=NULL;
  3142. T0* r324path_h(T324* C){
  3143. if (fBC324path_h==0){
  3144. T0* R=NULL;
  3145. fBC324path_h=1;
  3146. R=(((T590*)((T590*)(oBC364run_control))))->_root_class/*8*/;
  3147. /*IF*/if ((R)==((void*)(NULL))) {
  3148. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms171_324);
  3149. r683fatal_error(((T683*)(oBC364eh)),b1);
  3150. }/*]*/
  3151. }
  3152. else {
  3153. R=r324to_bcn(R);
  3154. r7to_lower(((T7*)R));
  3155. /*IF*/if ((((T0*)ms14_364))==((void*)(r324system_name(C)))) {
  3156. while (!(((((T7*)((T7*)R)))->_count/*4*/)<=(4))) {
  3157. r7remove_last(((T7*)R),1);
  3158. }
  3159. }
  3160. /*FI*/r7append(((T7*)R),((T0*)ms27_364));
  3161. }
  3162. /*FI*/oBC324path_h=R;}
  3163. return oBC324path_h;}
  3164. void r324call_c_linker(T324* C){
  3165. r7copy(((T7*)(oBC324tmp_string)),r324c_linker(C));
  3166. r7extend(((T7*)(oBC324tmp_string)),'\40');
  3167. /*IF*/if (((((T324*)C))->_c_compiler_options/*116*/)!=((void*)(NULL))) {
  3168. r7append(((T7*)(oBC324tmp_string)),(((T324*)C))->_c_compiler_options/*116*/);
  3169. }
  3170. /*FI*/}
  3171. /*No:C_PRETTY_PRINTER.c_compiler_options*/
  3172. /*No:C_PRETTY_PRINTER.put_character*/
  3173. void r324incr_elt_c_count(T324* C,int a1){
  3174. /*IF*/if ((((T324*)C))->_no_split/*112*/) {
  3175. }
  3176. else {
  3177. C->_elt_c_count=((((T324*)C))->_elt_c_count/*92*/)+(a1);
  3178. /*IF*/if (((((T324*)C))->_elt_c_count/*92*/)>(1960)) {
  3179. C->_elt_c_count=0;
  3180. /*[IRF3.6put_character*/{T544* C1=((T544*)(oBC324out_c));
  3181. char b1='\n';
  3182. putc(b1,((FILE*)((((T544*)C1))->_output_stream/*4*/)));
  3183. }/*]*/
  3184. r544disconnect(((T544*)(oBC324out_c)));
  3185. C->_split_count=((((T324*)C))->_split_count/*88*/)+(1);
  3186. r324path_c_copy_in(C,r324path_c(C),(((T324*)C))->_split_count/*88*/);
  3187. r324backup_sfw_connect(C,oBC324out_c,r324path_c(C));
  3188. r324add_first_include(C);
  3189. /*IF*/if (((((T324*)C))->_current_out/*56*/)!=((void*)((((T324*)C))->_out_h/*52*/))) {
  3190. C->_current_out=oBC324out_c;
  3191. }
  3192. /*FI*/}
  3193. /*FI*/}
  3194. /*FI*/}
  3195. /*No:C_PRETTY_PRINTER.sprintf_double_flag*/
  3196. /*No:C_PRETTY_PRINTER.us_double*/
  3197. /*No:C_PRETTY_PRINTER.macintosh_system*/
  3198.  
  3199.