home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ppcsmalleiffel / source.lha / bin_c / short9.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  25.7 KB  |  852 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 "short.h"
  9. T0* r382item(T382* C,int a1){
  10. T0* R=NULL;
  11. R=((((T382*)C))->_storage/*0*/)[(a1)-((((T382*)C))->_lower/*12*/)];
  12. return R;
  13. }
  14. /*No:ARRAY[DECLARATION].storage*/
  15. /*No:ARRAY[DECLARATION].capacity*/
  16. /*No:ARRAY[DECLARATION].lower*/
  17. /*No:ARRAY[DECLARATION].put*/
  18. /*No:ARRAY[DECLARATION].upper*/
  19. int r382count(T382* C){
  20. int R=0;
  21. R=(((((T382*)C))->_upper/*8*/)-((((T382*)C))->_lower/*12*/))+(1);
  22. return R;
  23. }
  24. void r382add_last(T382* C,T0* a1){
  25. int _new_capacity=0;
  26. /*IF*/if (((((T382*)C))->_capacity/*4*/)<((r382count(C))+(1))) {
  27. /*IF*/if (((((T382*)C))->_capacity/*4*/)==(0)) {
  28. C->_capacity=16;
  29. C->_storage=calloc((((T382*)C))->_capacity/*4*/,sizeof(T0*));
  30. }
  31. else {
  32. _new_capacity=(2)*((((T382*)C))->_capacity/*4*/);
  33. C->_storage=r667realloc((((T382*)C))->_storage/*0*/,(((T382*)C))->_capacity/*4*/,_new_capacity);
  34. C->_capacity=_new_capacity;
  35. }
  36. /*FI*/}
  37. /*FI*/C->_upper=((((T382*)C))->_upper/*8*/)+(1);
  38. /*[IRF3.6put*/{T382* C1=C;
  39. T0* b1=a1;
  40. int b2=(((T382*)C))->_upper/*8*/;
  41. ((((T382*)C1))->_storage/*0*/)[(b2)-((((T382*)C1))->_lower/*12*/)]=(b1);
  42. }/*]*/
  43. }
  44. /*No:ARRAY[BOOLEAN].clear_all*/
  45. /*No:ARRAY[BOOLEAN].set_all_with*/
  46. void r353force(T353* C,int a1,int a2){
  47. /*IF*/if (((((T353*)C))->_upper/*8*/)<(a2)) {
  48. r353resize(C,(((T353*)C))->_lower/*12*/,a2);
  49. }
  50.  else if ((a2)<((((T353*)C))->_lower/*12*/)) {
  51. r353resize(C,a2,(((T353*)C))->_upper/*8*/);
  52. }
  53. /*FI*//*[IRF3.6put*/{T353* C1=C;
  54. int b1=a1;
  55. int b2=a2;
  56. ((((T353*)C1))->_storage/*0*/)[(b2)-((((T353*)C1))->_lower/*12*/)]=(b1);
  57. }/*]*/
  58. }
  59. void r353make(T353* C,int a1,int a2){
  60. int _needed=0;
  61. C->_lower=a1;
  62. C->_upper=a2;
  63. _needed=((a2)-(a1))+(1);
  64. /*IF*/if ((_needed)>(0)) {
  65. /*IF*/if (((((T353*)C))->_capacity/*4*/)<(_needed)) {
  66. /*IF*/if (((((T353*)C))->_capacity/*4*/)==(0)) {
  67. C->_storage=calloc(_needed,sizeof(int));
  68. }
  69. else {
  70. C->_storage=calloc(_needed,sizeof(int));
  71. }
  72. /*FI*/C->_capacity=_needed;
  73. }
  74. else {
  75. /*[IRF3.6clear_all*/{T353* C1=C;
  76. int __value=0;
  77. /*[IRF3.6set_all_with*/{T353* C2=C1;
  78. int c1=__value;
  79. r567set_all_with((((T353*)C2))->_storage/*0*/,c1,((((T353*)C2))->_upper/*8*/)-((((T353*)C2))->_lower/*12*/));
  80. }/*]*/
  81. }/*]*/
  82. }
  83. /*FI*/}
  84. /*FI*/}
  85. int r353item(T353* C,int a1){
  86. int R=0;
  87. R=((((T353*)C))->_storage/*0*/)[(a1)-((((T353*)C))->_lower/*12*/)];
  88. return R;
  89. }
  90. void r353resize(T353* C,int a1,int a2){
  91. int _mem=0;
  92. int _up=0;
  93. int _i=0;
  94. T0* _other=NULL;
  95. {T353*n=malloc(sizeof(*n));
  96. *n=M353;
  97. r353make(n,a1,a2);
  98. _other=(T0*)n;
  99. }
  100. _i=r2max((((T353*)C))->_lower/*12*/,(((T353*)((T353*)_other)))->_lower/*12*/);
  101. _up=r2min((((T353*)C))->_upper/*8*/,(((T353*)((T353*)_other)))->_upper/*8*/);
  102. while (!((_i)>(_up))) {
  103. /*[IRF3.6put*/{T353* C1=((T353*)_other);
  104. int b1=r353item(C,_i);
  105. int b2=_i;
  106. ((((T353*)C1))->_storage/*0*/)[(b2)-((((T353*)C1))->_lower/*12*/)]=(b1);
  107. }/*]*/
  108. _i=(_i)+(1);
  109. }
  110. *((T353*)(C))=*((T353*)(_other));
  111. }
  112. /*No:ARRAY[BOOLEAN].storage*/
  113. /*No:ARRAY[BOOLEAN].capacity*/
  114. /*No:ARRAY[BOOLEAN].lower*/
  115. /*No:ARRAY[BOOLEAN].put*/
  116. /*No:ARRAY[BOOLEAN].upper*/
  117. int r353valid_index(T353* C,int a1){
  118. int R=0;
  119. R=(((((T353*)C))->_lower/*12*/)<=(a1))&&((a1)<=((((T353*)C))->_upper/*8*/));
  120. return R;
  121. }
  122. void r353set_slice_with(T353* C,int a1,int a2,int a3){
  123. int _i=0;
  124. _i=a2;
  125. while (!((_i)>(a3))) {
  126. /*[IRF3.6put*/{T353* C1=C;
  127. int b1=a1;
  128. int b2=_i;
  129. ((((T353*)C1))->_storage/*0*/)[(b2)-((((T353*)C1))->_lower/*12*/)]=(b1);
  130. }/*]*/
  131. _i=(_i)+(1);
  132. }
  133. }
  134. /*No:FIXED_ARRAY[MANIFEST_STRING].storage*/
  135. /*No:FIXED_ARRAY[MANIFEST_STRING].capacity*/
  136. void r256with_capacity(T256* C,int a1){
  137. /*IF*/if (((((T256*)C))->_capacity/*4*/)<(a1)) {
  138. C->_storage=calloc(a1,sizeof(T0*));
  139. C->_capacity=a1;
  140. }
  141. /*FI*/C->_upper=-(1);
  142. }
  143. /*No:FIXED_ARRAY[MANIFEST_STRING].put*/
  144. /*No:FIXED_ARRAY[MANIFEST_STRING].upper*/
  145. void r256add_last(T256* C,T0* a1){
  146. int _new_capacity=0;
  147. /*IF*/if ((((((T256*)C))->_upper/*8*/)+(1))<=(((((T256*)C))->_capacity/*4*/)-(1))) {
  148. C->_upper=((((T256*)C))->_upper/*8*/)+(1);
  149. }
  150.  else if (((((T256*)C))->_capacity/*4*/)==(0)) {
  151. C->_storage=calloc(2,sizeof(T0*));
  152. C->_capacity=2;
  153. C->_upper=0;
  154. }
  155. else {
  156. _new_capacity=(2)*((((T256*)C))->_capacity/*4*/);
  157. C->_storage=r729realloc((((T256*)C))->_storage/*0*/,(((T256*)C))->_capacity/*4*/,_new_capacity);
  158. C->_capacity=_new_capacity;
  159. C->_upper=((((T256*)C))->_upper/*8*/)+(1);
  160. }
  161. /*FI*//*[IRF3.5put*/((((T256*)C))->_storage/*0*/)[(((T256*)C))->_upper/*8*/]=(a1);
  162. /*]*/
  163. }
  164. /*No:FIXED_ARRAY[RUN_CLASS].storage*/
  165. /*No:FIXED_ARRAY[RUN_CLASS].capacity*/
  166. void r187with_capacity(T187* C,int a1){
  167. /*IF*/if (((((T187*)C))->_capacity/*4*/)<(a1)) {
  168. C->_storage=calloc(a1,sizeof(T0*));
  169. C->_capacity=a1;
  170. }
  171. /*FI*/C->_upper=-(1);
  172. }
  173. int r187fast_index_of(T187* C,T0* a1){
  174. int R=0;
  175. R=r659fast_index_of((((T187*)C))->_storage/*0*/,a1,(((T187*)C))->_upper/*8*/);
  176. return R;
  177. }
  178. /*No:FIXED_ARRAY[RUN_CLASS].put*/
  179. /*No:FIXED_ARRAY[RUN_CLASS].upper*/
  180. void r187add_last(T187* C,T0* a1){
  181. int _new_capacity=0;
  182. /*IF*/if ((((((T187*)C))->_upper/*8*/)+(1))<=(((((T187*)C))->_capacity/*4*/)-(1))) {
  183. C->_upper=((((T187*)C))->_upper/*8*/)+(1);
  184. }
  185.  else if (((((T187*)C))->_capacity/*4*/)==(0)) {
  186. C->_storage=calloc(2,sizeof(T0*));
  187. C->_capacity=2;
  188. C->_upper=0;
  189. }
  190. else {
  191. _new_capacity=(2)*((((T187*)C))->_capacity/*4*/);
  192. C->_storage=r659realloc((((T187*)C))->_storage/*0*/,(((T187*)C))->_capacity/*4*/,_new_capacity);
  193. C->_capacity=_new_capacity;
  194. C->_upper=((((T187*)C))->_upper/*8*/)+(1);
  195. }
  196. /*FI*//*[IRF3.5put*/((((T187*)C))->_storage/*0*/)[(((T187*)C))->_upper/*8*/]=(a1);
  197. /*]*/
  198. }
  199. T0* r419item(T419* C,int a1){
  200. T0* R=NULL;
  201. R=((((T419*)C))->_storage/*0*/)[(a1)-((((T419*)C))->_lower/*12*/)];
  202. return R;
  203. }
  204. /*No:ARRAY[INSTRUCTION].storage*/
  205. T0* r419twin(T419* C){
  206. T0* R=NULL;
  207. R=malloc(sizeof(*C));
  208. *((T419*)R)=M419;
  209. r419copy(((T419*)R),((T0*)C));
  210. return R;
  211. }
  212. /*No:ARRAY[INSTRUCTION].capacity*/
  213. void r419copy(T419* C,T0* a1){
  214. int _needed_capacity=0;
  215. C->_lower=(((T419*)((T419*)a1)))->_lower/*12*/;
  216. C->_upper=(((T419*)((T419*)a1)))->_upper/*8*/;
  217. _needed_capacity=(((((T419*)C))->_upper/*8*/)-((((T419*)C))->_lower/*12*/))+(1);
  218. /*IF*/if (((((T419*)C))->_capacity/*4*/)<(_needed_capacity)) {
  219. C->_capacity=_needed_capacity;
  220. C->_storage=calloc((((T419*)C))->_capacity/*4*/,sizeof(T0*));
  221. }
  222. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  223. r705copy_from((((T419*)C))->_storage/*0*/,(((T419*)((T419*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  224. }
  225. /*FI*/}
  226. /*No:ARRAY[INSTRUCTION].lower*/
  227. /*No:ARRAY[INSTRUCTION].put*/
  228. /*No:ARRAY[INSTRUCTION].upper*/
  229. int r419count(T419* C){
  230. int R=0;
  231. R=(((((T419*)C))->_upper/*8*/)-((((T419*)C))->_lower/*12*/))+(1);
  232. return R;
  233. }
  234. void r419add_last(T419* C,T0* a1){
  235. int _new_capacity=0;
  236. /*IF*/if (((((T419*)C))->_capacity/*4*/)<((r419count(C))+(1))) {
  237. /*IF*/if (((((T419*)C))->_capacity/*4*/)==(0)) {
  238. C->_capacity=16;
  239. C->_storage=calloc((((T419*)C))->_capacity/*4*/,sizeof(T0*));
  240. }
  241. else {
  242. _new_capacity=(2)*((((T419*)C))->_capacity/*4*/);
  243. C->_storage=r705realloc((((T419*)C))->_storage/*0*/,(((T419*)C))->_capacity/*4*/,_new_capacity);
  244. C->_capacity=_new_capacity;
  245. }
  246. /*FI*/}
  247. /*FI*/C->_upper=((((T419*)C))->_upper/*8*/)+(1);
  248. /*[IRF3.6put*/{T419* C1=C;
  249. T0* b1=a1;
  250. int b2=(((T419*)C))->_upper/*8*/;
  251. ((((T419*)C1))->_storage/*0*/)[(b2)-((((T419*)C1))->_lower/*12*/)]=(b1);
  252. }/*]*/
  253. }
  254. T0* r901item(T901* C,int a1){
  255. T0* R=NULL;
  256. R=((((T901*)C))->_storage/*0*/)[(a1)-((((T901*)C))->_lower/*12*/)];
  257. return R;
  258. }
  259. /*No:ARRAY[CLASS_NAME].storage*/
  260. T0* r901twin(T901* C){
  261. T0* R=NULL;
  262. R=malloc(sizeof(*C));
  263. *((T901*)R)=M901;
  264. r901copy(((T901*)R),((T0*)C));
  265. return R;
  266. }
  267. /*No:ARRAY[CLASS_NAME].capacity*/
  268. void r901copy(T901* C,T0* a1){
  269. int _needed_capacity=0;
  270. C->_lower=(((T901*)((T901*)a1)))->_lower/*12*/;
  271. C->_upper=(((T901*)((T901*)a1)))->_upper/*8*/;
  272. _needed_capacity=(((((T901*)C))->_upper/*8*/)-((((T901*)C))->_lower/*12*/))+(1);
  273. /*IF*/if (((((T901*)C))->_capacity/*4*/)<(_needed_capacity)) {
  274. C->_capacity=_needed_capacity;
  275. C->_storage=calloc((((T901*)C))->_capacity/*4*/,sizeof(T0*));
  276. }
  277. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  278. r221copy_from((((T901*)C))->_storage/*0*/,(((T901*)((T901*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  279. }
  280. /*FI*/}
  281. /*No:ARRAY[CLASS_NAME].lower*/
  282. /*No:ARRAY[CLASS_NAME].put*/
  283. /*No:ARRAY[CLASS_NAME].upper*/
  284. int r901count(T901* C){
  285. int R=0;
  286. R=(((((T901*)C))->_upper/*8*/)-((((T901*)C))->_lower/*12*/))+(1);
  287. return R;
  288. }
  289. void r901add_last(T901* C,T0* a1){
  290. int _new_capacity=0;
  291. /*IF*/if (((((T901*)C))->_capacity/*4*/)<((r901count(C))+(1))) {
  292. /*IF*/if (((((T901*)C))->_capacity/*4*/)==(0)) {
  293. C->_capacity=16;
  294. C->_storage=calloc((((T901*)C))->_capacity/*4*/,sizeof(T0*));
  295. }
  296. else {
  297. _new_capacity=(2)*((((T901*)C))->_capacity/*4*/);
  298. C->_storage=r221realloc((((T901*)C))->_storage/*0*/,(((T901*)C))->_capacity/*4*/,_new_capacity);
  299. C->_capacity=_new_capacity;
  300. }
  301. /*FI*/}
  302. /*FI*/C->_upper=((((T901*)C))->_upper/*8*/)+(1);
  303. /*[IRF3.6put*/{T901* C1=C;
  304. T0* b1=a1;
  305. int b2=(((T901*)C))->_upper/*8*/;
  306. ((((T901*)C1))->_storage/*0*/)[(b2)-((((T901*)C1))->_lower/*12*/)]=(b1);
  307. }/*]*/
  308. }
  309. /*No:FIXED_ARRAY[STRING].clear_all*/
  310. /*No:FIXED_ARRAY[STRING].set_all_with*/
  311. void r927make(T927* C,int a1){
  312. /*IF*/if ((a1)==(0)) {
  313. C->_upper=-(1);
  314. }
  315.  else if (((((T927*)C))->_capacity/*4*/)==(0)) {
  316. C->_storage=calloc(a1,sizeof(T0*));
  317. C->_capacity=a1;
  318. C->_upper=(a1)-(1);
  319. }
  320.  else if (((((T927*)C))->_capacity/*4*/)<(a1)) {
  321. C->_storage=calloc(a1,sizeof(T0*));
  322. C->_capacity=a1;
  323. C->_upper=(a1)-(1);
  324. }
  325. else {
  326. C->_upper=(a1)-(1);
  327. /*[IRF3.6clear_all*/{T927* C1=C;
  328. T0* __value=NULL;
  329. /*[IRF3.6set_all_with*/{T927* C2=C1;
  330. T0* c1=__value;
  331. r400set_all_with((((T927*)C2))->_storage/*0*/,c1,(((T927*)C2))->_upper/*8*/);
  332. }/*]*/
  333. }/*]*/
  334. }
  335. /*FI*/}
  336. /*No:FIXED_ARRAY[STRING].item*/
  337. /*No:FIXED_ARRAY[STRING].storage*/
  338. /*No:FIXED_ARRAY[STRING].capacity*/
  339. void r927with_capacity(T927* C,int a1){
  340. /*IF*/if (((((T927*)C))->_capacity/*4*/)<(a1)) {
  341. C->_storage=calloc(a1,sizeof(T0*));
  342. C->_capacity=a1;
  343. }
  344. /*FI*/C->_upper=-(1);
  345. }
  346. int r927fast_index_of(T927* C,T0* a1){
  347. int R=0;
  348. R=r400fast_index_of((((T927*)C))->_storage/*0*/,a1,(((T927*)C))->_upper/*8*/);
  349. return R;
  350. }
  351. /*No:FIXED_ARRAY[STRING].put*/
  352. /*No:FIXED_ARRAY[STRING].upper*/
  353. void r927add_last(T927* C,T0* a1){
  354. int _new_capacity=0;
  355. /*IF*/if ((((((T927*)C))->_upper/*8*/)+(1))<=(((((T927*)C))->_capacity/*4*/)-(1))) {
  356. C->_upper=((((T927*)C))->_upper/*8*/)+(1);
  357. }
  358.  else if (((((T927*)C))->_capacity/*4*/)==(0)) {
  359. C->_storage=calloc(2,sizeof(T0*));
  360. C->_capacity=2;
  361. C->_upper=0;
  362. }
  363. else {
  364. _new_capacity=(2)*((((T927*)C))->_capacity/*4*/);
  365. C->_storage=r400realloc((((T927*)C))->_storage/*0*/,(((T927*)C))->_capacity/*4*/,_new_capacity);
  366. C->_capacity=_new_capacity;
  367. C->_upper=((((T927*)C))->_upper/*8*/)+(1);
  368. }
  369. /*FI*//*[IRF3.5put*/((((T927*)C))->_storage/*0*/)[(((T927*)C))->_upper/*8*/]=(a1);
  370. /*]*/
  371. }
  372. /*No:ARRAY[RUN_CLASS].clear_all*/
  373. /*No:ARRAY[RUN_CLASS].set_all_with*/
  374. void r396make(T396* C,int a1,int a2){
  375. int _needed=0;
  376. C->_lower=a1;
  377. C->_upper=a2;
  378. _needed=((a2)-(a1))+(1);
  379. /*IF*/if ((_needed)>(0)) {
  380. /*IF*/if (((((T396*)C))->_capacity/*4*/)<(_needed)) {
  381. /*IF*/if (((((T396*)C))->_capacity/*4*/)==(0)) {
  382. C->_storage=calloc(_needed,sizeof(T0*));
  383. }
  384. else {
  385. C->_storage=calloc(_needed,sizeof(T0*));
  386. }
  387. /*FI*/C->_capacity=_needed;
  388. }
  389. else {
  390. /*[IRF3.6clear_all*/{T396* C1=C;
  391. T0* __value=NULL;
  392. /*[IRF3.6set_all_with*/{T396* C2=C1;
  393. T0* c1=__value;
  394. r659set_all_with((((T396*)C2))->_storage/*0*/,c1,((((T396*)C2))->_upper/*8*/)-((((T396*)C2))->_lower/*12*/));
  395. }/*]*/
  396. }/*]*/
  397. }
  398. /*FI*/}
  399. /*FI*/}
  400. int r396fast_has(T396* C,T0* a1){
  401. int R=0;
  402. /*IF*/if ((r396count(C))>(0)) {
  403. R=(r396fast_index_of(C,a1))<=((((T396*)C))->_upper/*8*/);
  404. }
  405. /*FI*/return R;
  406. }
  407. T0* r396item(T396* C,int a1){
  408. T0* R=NULL;
  409. R=((((T396*)C))->_storage/*0*/)[(a1)-((((T396*)C))->_lower/*12*/)];
  410. return R;
  411. }
  412. void r396resize(T396* C,int a1,int a2){
  413. int _mem=0;
  414. int _up=0;
  415. int _i=0;
  416. T0* _other=NULL;
  417. {T396*n=malloc(sizeof(*n));
  418. *n=M396;
  419. r396make(n,a1,a2);
  420. _other=(T0*)n;
  421. }
  422. _i=r2max((((T396*)C))->_lower/*12*/,(((T396*)((T396*)_other)))->_lower/*12*/);
  423. _up=r2min((((T396*)C))->_upper/*8*/,(((T396*)((T396*)_other)))->_upper/*8*/);
  424. while (!((_i)>(_up))) {
  425. /*[IRF3.6put*/{T396* C1=((T396*)_other);
  426. T0* b1=r396item(C,_i);
  427. int b2=_i;
  428. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  429. }/*]*/
  430. _i=(_i)+(1);
  431. }
  432. *((T396*)(C))=*((T396*)(_other));
  433. }
  434. /*No:ARRAY[RUN_CLASS].storage*/
  435. /*No:ARRAY[RUN_CLASS].capacity*/
  436. /*No:ARRAY[RUN_CLASS].lower*/
  437. int r396fast_index_of(T396* C,T0* a1){
  438. int R=0;
  439. R=((((T396*)C))->_lower/*12*/)+(r659fast_index_of((((T396*)C))->_storage/*0*/,a1,((((T396*)C))->_upper/*8*/)-((((T396*)C))->_lower/*12*/)));
  440. return R;
  441. }
  442. /*No:ARRAY[RUN_CLASS].put*/
  443. /*No:ARRAY[RUN_CLASS].upper*/
  444. void r396add_last(T396* C,T0* a1){
  445. int _new_capacity=0;
  446. /*IF*/if (((((T396*)C))->_capacity/*4*/)<((r396count(C))+(1))) {
  447. /*IF*/if (((((T396*)C))->_capacity/*4*/)==(0)) {
  448. C->_capacity=16;
  449. C->_storage=calloc((((T396*)C))->_capacity/*4*/,sizeof(T0*));
  450. }
  451. else {
  452. _new_capacity=(2)*((((T396*)C))->_capacity/*4*/);
  453. C->_storage=r659realloc((((T396*)C))->_storage/*0*/,(((T396*)C))->_capacity/*4*/,_new_capacity);
  454. C->_capacity=_new_capacity;
  455. }
  456. /*FI*/}
  457. /*FI*/C->_upper=((((T396*)C))->_upper/*8*/)+(1);
  458. /*[IRF3.6put*/{T396* C1=C;
  459. T0* b1=a1;
  460. int b2=(((T396*)C))->_upper/*8*/;
  461. ((((T396*)C1))->_storage/*0*/)[(b2)-((((T396*)C1))->_lower/*12*/)]=(b1);
  462. }/*]*/
  463. }
  464. int r396count(T396* C){
  465. int R=0;
  466. R=(((((T396*)C))->_upper/*8*/)-((((T396*)C))->_lower/*12*/))+(1);
  467. return R;
  468. }
  469. T0* r794at(T794* C,T0* a1){
  470. T0* R=NULL;
  471. int _foo=0;
  472. _foo=r794has(C,a1);
  473. R=r52item(((T52*)((((T794*)C))->_store/*4*/)),(((T794*)C))->_has_mem/*24*/);
  474. return R;
  475. }
  476. void r794expand(T794* C){
  477. int _old_size=0;
  478. int _i=0;
  479. C->_item_mem=0;
  480. _old_size=r52count(((T52*)((((T794*)C))->_store/*4*/)));
  481. r429resize(((T429*)((((T794*)C))->_chain/*12*/)),1,(2)*(_old_size));
  482. r52resize(((T52*)((((T794*)C))->_keys/*0*/)),1,(2)*(_old_size));
  483. r52resize(((T52*)((((T794*)C))->_store/*4*/)),1,(2)*(_old_size));
  484. _i=(_old_size)+(1);
  485. while (!((_i)==(r429count(((T429*)((((T794*)C))->_chain/*12*/)))))) {
  486. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  487. int b1=(_i)+(1);
  488. int b2=_i;
  489. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  490. }/*]*/
  491. _i=(_i)+(1);
  492. }
  493. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  494. int b1=(((T794*)C))->_free/*16*/;
  495. int b2=_i;
  496. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  497. }/*]*/
  498. C->_free=(_old_size)+(1);
  499. }
  500. T0*oBC672tmp_buckets=NULL;
  501. /*No:DICTIONARY[STRING,STRING].free*/
  502. void r794make(T794* C){
  503. C->_modulus=(2)*(32);
  504. {T226*n=malloc(sizeof(*n));
  505. *n=M226;
  506. r226make(n,(((T794*)C))->_modulus/*20*/);
  507. C->_buckets=(T0*)n;
  508. }
  509. {T429*n=malloc(sizeof(*n));
  510. *n=M429;
  511. r429make(n,1,32);
  512. C->_chain=(T0*)n;
  513. }
  514. {T52*n=malloc(sizeof(*n));
  515. *n=M52;
  516. r52make(n,1,32);
  517. C->_store=(T0*)n;
  518. }
  519. {T52*n=malloc(sizeof(*n));
  520. *n=M52;
  521. r52make(n,1,32);
  522. C->_keys=(T0*)n;
  523. }
  524. r794initialize(C);
  525. }
  526. void r794resize(T794* C,int a1){
  527. int _p=0;
  528. int _n=0;
  529. int _i=0;
  530. int _hash=0;
  531. r226copy(((T226*)(oBC672tmp_buckets)),(((T794*)C))->_buckets/*8*/);
  532. r226make(((T226*)((((T794*)C))->_buckets/*8*/)),a1);
  533. _i=0;
  534. while (!((_i)>=((((T794*)C))->_modulus/*20*/))) {
  535. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  536. while (!((_n)==(0))) {
  537. _p=r429item(((T429*)((((T794*)C))->_chain/*12*/)),_n);
  538. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T794*)C))->_keys/*0*/)),_n)))))%(a1);
  539. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  540. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  541. int b2=_n;
  542. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  543. }/*]*/
  544. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  545. /*]*/
  546. _n=_p;
  547. }
  548. _i=(_i)+(1);
  549. }
  550. C->_modulus=a1;
  551. C->_item_mem=0;
  552. }
  553. /*No:DICTIONARY[STRING,STRING].item_mem*/
  554. /*No:DICTIONARY[STRING,STRING].chain*/
  555. /*No:DICTIONARY[STRING,STRING].keys*/
  556. /*No:DICTIONARY[STRING,STRING].buckets*/
  557. int r794has(T794* C,T0* a1){
  558. int R=0;
  559. /*IF*/if ((((((T794*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  560. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T794*)C))->_modulus/*20*/)]/*)*/;
  561. while (!((((((T794*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  562. C->_has_mem=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_has_mem/*24*/);
  563. }
  564. }
  565. /*FI*/R=((((T794*)C))->_has_mem/*24*/)!=(0);
  566. return R;
  567. }
  568. /*No:DICTIONARY[STRING,STRING].Min_size*/
  569. /*No:DICTIONARY[STRING,STRING].store*/
  570. void r794with_capacity(T794* C,int a1){
  571. int _i=0;
  572. _i=32;
  573. while (!((_i)>=(a1))) {
  574. _i=(2)*(_i);
  575. }
  576. C->_modulus=(2)*(_i);
  577. {T226*n=malloc(sizeof(*n));
  578. *n=M226;
  579. r226make(n,(((T794*)C))->_modulus/*20*/);
  580. C->_buckets=(T0*)n;
  581. }
  582. {T429*n=malloc(sizeof(*n));
  583. *n=M429;
  584. r429make(n,1,_i);
  585. C->_chain=(T0*)n;
  586. }
  587. {T52*n=malloc(sizeof(*n));
  588. *n=M52;
  589. r52make(n,1,_i);
  590. C->_store=(T0*)n;
  591. }
  592. {T52*n=malloc(sizeof(*n));
  593. *n=M52;
  594. r52make(n,1,_i);
  595. C->_keys=(T0*)n;
  596. }
  597. r794initialize(C);
  598. }
  599. void r794put(T794* C,T0* a1,T0* a2){
  600. int _hash=0;
  601. _hash=(r7hash_code(((T7*)a2)))%((((T794*)C))->_modulus/*20*/);
  602. /*IF*/if ((((((T794*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  603. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  604. while (!((((((T794*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T794*)C))->_keys/*0*/)),(((T794*)C))->_has_mem/*24*/))))) {
  605. C->_has_mem=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_has_mem/*24*/);
  606. }
  607. /*IF*/if (((((T794*)C))->_has_mem/*24*/)==(0)) {
  608. /*IF*/if (((((T794*)C))->_count/*32*/)>=(r52count(((T52*)((((T794*)C))->_store/*4*/))))) {
  609. r794expand(C);
  610. }
  611. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_keys/*0*/));
  612. T0* b1=a2;
  613. int b2=(((T794*)C))->_free/*16*/;
  614. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  615. }/*]*/
  616. /*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_store/*4*/));
  617. T0* b1=a1;
  618. int b2=(((T794*)C))->_free/*16*/;
  619. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  620. }/*]*/
  621. C->_has_mem=(((T794*)C))->_free/*16*/;
  622. C->_free=r429item(((T429*)((((T794*)C))->_chain/*12*/)),(((T794*)C))->_free/*16*/);
  623. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  624. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  625. int b2=(((T794*)C))->_has_mem/*24*/;
  626. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  627. }/*]*/
  628. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T794*)C))->_has_mem/*24*/);
  629. /*]*/
  630. C->_count=((((T794*)C))->_count/*32*/)+(1);
  631. /*IF*/if (((((T794*)C))->_count/*32*/)>(((((T794*)C))->_modulus/*20*/)*(2))) {
  632. r794resize(C,(2)*((((T794*)C))->_modulus/*20*/));
  633. }
  634. /*FI*/}
  635. /*FI*/}
  636. else {
  637. /*[IRF3.6put*/{T52* C1=((T52*)((((T794*)C))->_store/*4*/));
  638. T0* b1=a1;
  639. int b2=(((T794*)C))->_has_mem/*24*/;
  640. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  641. }/*]*/
  642. }
  643. /*FI*/C->_item_mem=0;
  644. }
  645. /*No:DICTIONARY[STRING,STRING].modulus*/
  646. /*No:DICTIONARY[STRING,STRING].count*/
  647. /*No:DICTIONARY[STRING,STRING].has_mem*/
  648. void r794initialize(T794* C){
  649. int _i=0;
  650. C->_count=0;
  651. C->_free=1;
  652. C->_has_mem=0;
  653. C->_item_mem=0;
  654. _i=1;
  655. while (!((_i)==(r429count(((T429*)((((T794*)C))->_chain/*12*/)))))) {
  656. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  657. int b1=(_i)+(1);
  658. int b2=_i;
  659. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  660. }/*]*/
  661. _i=(_i)+(1);
  662. }
  663. /*[IRF3.6put*/{T429* C1=((T429*)((((T794*)C))->_chain/*12*/));
  664. int b1=0;
  665. int b2=_i;
  666. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  667. }/*]*/
  668. _i=0;
  669. while (!((_i)>=((((T794*)C))->_modulus/*20*/))) {
  670. /*[IRF3.5put*/((((T226*)((T226*)((((T794*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  671. /*]*/
  672. _i=(_i)+(1);
  673. }
  674. }
  675. T0* r338at(T338* C,T0* a1){
  676. T0* R=NULL;
  677. int _foo=0;
  678. _foo=r338has(C,a1);
  679. R=r943item(((T943*)((((T338*)C))->_store/*4*/)),(((T338*)C))->_has_mem/*24*/);
  680. return R;
  681. }
  682. void r338expand(T338* C){
  683. int _old_size=0;
  684. int _i=0;
  685. C->_item_mem=0;
  686. _old_size=r943count(((T943*)((((T338*)C))->_store/*4*/)));
  687. r429resize(((T429*)((((T338*)C))->_chain/*12*/)),1,(2)*(_old_size));
  688. r52resize(((T52*)((((T338*)C))->_keys/*0*/)),1,(2)*(_old_size));
  689. r943resize(((T943*)((((T338*)C))->_store/*4*/)),1,(2)*(_old_size));
  690. _i=(_old_size)+(1);
  691. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  692. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  693. int b1=(_i)+(1);
  694. int b2=_i;
  695. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  696. }/*]*/
  697. _i=(_i)+(1);
  698. }
  699. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  700. int b1=(((T338*)C))->_free/*16*/;
  701. int b2=_i;
  702. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  703. }/*]*/
  704. C->_free=(_old_size)+(1);
  705. }
  706. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].free*/
  707. void r338make(T338* C){
  708. C->_modulus=(2)*(32);
  709. {T226*n=malloc(sizeof(*n));
  710. *n=M226;
  711. r226make(n,(((T338*)C))->_modulus/*20*/);
  712. C->_buckets=(T0*)n;
  713. }
  714. {T429*n=malloc(sizeof(*n));
  715. *n=M429;
  716. r429make(n,1,32);
  717. C->_chain=(T0*)n;
  718. }
  719. {T943*n=malloc(sizeof(*n));
  720. *n=M943;
  721. r943make(n,1,32);
  722. C->_store=(T0*)n;
  723. }
  724. {T52*n=malloc(sizeof(*n));
  725. *n=M52;
  726. r52make(n,1,32);
  727. C->_keys=(T0*)n;
  728. }
  729. r338initialize(C);
  730. }
  731. void r338resize(T338* C,int a1){
  732. int _p=0;
  733. int _n=0;
  734. int _i=0;
  735. int _hash=0;
  736. r226copy(((T226*)(oBC672tmp_buckets)),(((T338*)C))->_buckets/*8*/);
  737. r226make(((T226*)((((T338*)C))->_buckets/*8*/)),a1);
  738. _i=0;
  739. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  740. _n=/*(IRF4.6item*/((((T226*)((T226*)(oBC672tmp_buckets))))->_storage/*0*/)[_i]/*)*/;
  741. while (!((_n)==(0))) {
  742. _p=r429item(((T429*)((((T338*)C))->_chain/*12*/)),_n);
  743. _hash=(r7hash_code(((T7*)(r52item(((T52*)((((T338*)C))->_keys/*0*/)),_n)))))%(a1);
  744. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  745. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  746. int b2=_n;
  747. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  748. }/*]*/
  749. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=(_n);
  750. /*]*/
  751. _n=_p;
  752. }
  753. _i=(_i)+(1);
  754. }
  755. C->_modulus=a1;
  756. C->_item_mem=0;
  757. }
  758. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].item_mem*/
  759. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].chain*/
  760. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].keys*/
  761. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].buckets*/
  762. int r338has(T338* C,T0* a1){
  763. int R=0;
  764. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  765. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[(r7hash_code(((T7*)a1)))%((((T338*)C))->_modulus/*20*/)]/*)*/;
  766. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a1),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  767. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  768. }
  769. }
  770. /*FI*/R=((((T338*)C))->_has_mem/*24*/)!=(0);
  771. return R;
  772. }
  773. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].Min_size*/
  774. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].store*/
  775. void r338put(T338* C,T0* a1,T0* a2){
  776. int _hash=0;
  777. _hash=(r7hash_code(((T7*)a2)))%((((T338*)C))->_modulus/*20*/);
  778. /*IF*/if ((((((T338*)C))->_has_mem/*24*/)==(0))||(!(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  779. C->_has_mem=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  780. while (!((((((T338*)C))->_has_mem/*24*/)==(0))||(r7is_equal(((T7*)a2),r52item(((T52*)((((T338*)C))->_keys/*0*/)),(((T338*)C))->_has_mem/*24*/))))) {
  781. C->_has_mem=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_has_mem/*24*/);
  782. }
  783. /*IF*/if (((((T338*)C))->_has_mem/*24*/)==(0)) {
  784. /*IF*/if (((((T338*)C))->_count/*32*/)>=(r943count(((T943*)((((T338*)C))->_store/*4*/))))) {
  785. r338expand(C);
  786. }
  787. /*FI*//*[IRF3.6put*/{T52* C1=((T52*)((((T338*)C))->_keys/*0*/));
  788. T0* b1=a2;
  789. int b2=(((T338*)C))->_free/*16*/;
  790. ((((T52*)C1))->_storage/*0*/)[(b2)-((((T52*)C1))->_lower/*12*/)]=(b1);
  791. }/*]*/
  792. /*[IRF3.6put*/{T943* C1=((T943*)((((T338*)C))->_store/*4*/));
  793. T0* b1=a1;
  794. int b2=(((T338*)C))->_free/*16*/;
  795. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  796. }/*]*/
  797. C->_has_mem=(((T338*)C))->_free/*16*/;
  798. C->_free=r429item(((T429*)((((T338*)C))->_chain/*12*/)),(((T338*)C))->_free/*16*/);
  799. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  800. int b1=/*(IRF4.6item*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]/*)*/;
  801. int b2=(((T338*)C))->_has_mem/*24*/;
  802. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  803. }/*]*/
  804. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_hash]=((((T338*)C))->_has_mem/*24*/);
  805. /*]*/
  806. C->_count=((((T338*)C))->_count/*32*/)+(1);
  807. /*IF*/if (((((T338*)C))->_count/*32*/)>(((((T338*)C))->_modulus/*20*/)*(2))) {
  808. r338resize(C,(2)*((((T338*)C))->_modulus/*20*/));
  809. }
  810. /*FI*/}
  811. /*FI*/}
  812. else {
  813. /*[IRF3.6put*/{T943* C1=((T943*)((((T338*)C))->_store/*4*/));
  814. T0* b1=a1;
  815. int b2=(((T338*)C))->_has_mem/*24*/;
  816. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  817. }/*]*/
  818. }
  819. /*FI*/C->_item_mem=0;
  820. }
  821. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].modulus*/
  822. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].count*/
  823. /*No:DICTIONARY[DICTIONARY[RUN_FEATURE,STRING],STRING].has_mem*/
  824. void r338initialize(T338* C){
  825. int _i=0;
  826. C->_count=0;
  827. C->_free=1;
  828. C->_has_mem=0;
  829. C->_item_mem=0;
  830. _i=1;
  831. while (!((_i)==(r429count(((T429*)((((T338*)C))->_chain/*12*/)))))) {
  832. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  833. int b1=(_i)+(1);
  834. int b2=_i;
  835. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  836. }/*]*/
  837. _i=(_i)+(1);
  838. }
  839. /*[IRF3.6put*/{T429* C1=((T429*)((((T338*)C))->_chain/*12*/));
  840. int b1=0;
  841. int b2=_i;
  842. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  843. }/*]*/
  844. _i=0;
  845. while (!((_i)>=((((T338*)C))->_modulus/*20*/))) {
  846. /*[IRF3.5put*/((((T226*)((T226*)((((T338*)C))->_buckets/*8*/))))->_storage/*0*/)[_i]=(0);
  847. /*]*/
  848. _i=(_i)+(1);
  849. }
  850. }
  851.  
  852.