home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ppcsmalleiffel / source.lha / bin_c / short6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  19.3 KB  |  702 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. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].clear_all*/
  10. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].set_all_with*/
  11. void r943make(T943* C,int a1,int a2){
  12. int _needed=0;
  13. C->_lower=a1;
  14. C->_upper=a2;
  15. _needed=((a2)-(a1))+(1);
  16. /*IF*/if ((_needed)>(0)) {
  17. /*IF*/if (((((T943*)C))->_capacity/*4*/)<(_needed)) {
  18. /*IF*/if (((((T943*)C))->_capacity/*4*/)==(0)) {
  19. C->_storage=calloc(_needed,sizeof(T0*));
  20. }
  21. else {
  22. C->_storage=calloc(_needed,sizeof(T0*));
  23. }
  24. /*FI*/C->_capacity=_needed;
  25. }
  26. else {
  27. /*[IRF3.6clear_all*/{T943* C1=C;
  28. T0* __value=NULL;
  29. /*[IRF3.6set_all_with*/{T943* C2=C1;
  30. T0* c1=__value;
  31. r354set_all_with((((T943*)C2))->_storage/*0*/,c1,((((T943*)C2))->_upper/*8*/)-((((T943*)C2))->_lower/*12*/));
  32. }/*]*/
  33. }/*]*/
  34. }
  35. /*FI*/}
  36. /*FI*/}
  37. T0* r943item(T943* C,int a1){
  38. T0* R=NULL;
  39. R=((((T943*)C))->_storage/*0*/)[(a1)-((((T943*)C))->_lower/*12*/)];
  40. return R;
  41. }
  42. void r943resize(T943* C,int a1,int a2){
  43. int _mem=0;
  44. int _up=0;
  45. int _i=0;
  46. T0* _other=NULL;
  47. {T943*n=malloc(sizeof(*n));
  48. *n=M943;
  49. r943make(n,a1,a2);
  50. _other=(T0*)n;
  51. }
  52. _i=r2max((((T943*)C))->_lower/*12*/,(((T943*)((T943*)_other)))->_lower/*12*/);
  53. _up=r2min((((T943*)C))->_upper/*8*/,(((T943*)((T943*)_other)))->_upper/*8*/);
  54. while (!((_i)>(_up))) {
  55. /*[IRF3.6put*/{T943* C1=((T943*)_other);
  56. T0* b1=r943item(C,_i);
  57. int b2=_i;
  58. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  59. }/*]*/
  60. _i=(_i)+(1);
  61. }
  62. *((T943*)(C))=*((T943*)(_other));
  63. }
  64. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].storage*/
  65. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].capacity*/
  66. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].lower*/
  67. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].put*/
  68. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].upper*/
  69. int r943count(T943* C){
  70. int R=0;
  71. R=(((((T943*)C))->_upper/*8*/)-((((T943*)C))->_lower/*12*/))+(1);
  72. return R;
  73. }
  74. /*No:ARRAY[INTEGER].clear_all*/
  75. /*No:ARRAY[INTEGER].set_all_with*/
  76. void r429make(T429* C,int a1,int a2){
  77. int _needed=0;
  78. C->_lower=a1;
  79. C->_upper=a2;
  80. _needed=((a2)-(a1))+(1);
  81. /*IF*/if ((_needed)>(0)) {
  82. /*IF*/if (((((T429*)C))->_capacity/*4*/)<(_needed)) {
  83. /*IF*/if (((((T429*)C))->_capacity/*4*/)==(0)) {
  84. C->_storage=calloc(_needed,sizeof(int));
  85. }
  86. else {
  87. C->_storage=calloc(_needed,sizeof(int));
  88. }
  89. /*FI*/C->_capacity=_needed;
  90. }
  91. else {
  92. /*[IRF3.6clear_all*/{T429* C1=C;
  93. int __value=0;
  94. /*[IRF3.6set_all_with*/{T429* C2=C1;
  95. int c1=__value;
  96. r699set_all_with((((T429*)C2))->_storage/*0*/,c1,((((T429*)C2))->_upper/*8*/)-((((T429*)C2))->_lower/*12*/));
  97. }/*]*/
  98. }/*]*/
  99. }
  100. /*FI*/}
  101. /*FI*/}
  102. int r429fast_has(T429* C,int a1){
  103. int R=0;
  104. /*IF*/if ((r429count(C))>(0)) {
  105. R=(r429fast_index_of(C,a1))<=((((T429*)C))->_upper/*8*/);
  106. }
  107. /*FI*/return R;
  108. }
  109. int r429item(T429* C,int a1){
  110. int R=0;
  111. R=((((T429*)C))->_storage/*0*/)[(a1)-((((T429*)C))->_lower/*12*/)];
  112. return R;
  113. }
  114. void r429resize(T429* C,int a1,int a2){
  115. int _mem=0;
  116. int _up=0;
  117. int _i=0;
  118. T0* _other=NULL;
  119. {T429*n=malloc(sizeof(*n));
  120. *n=M429;
  121. r429make(n,a1,a2);
  122. _other=(T0*)n;
  123. }
  124. _i=r2max((((T429*)C))->_lower/*12*/,(((T429*)((T429*)_other)))->_lower/*12*/);
  125. _up=r2min((((T429*)C))->_upper/*8*/,(((T429*)((T429*)_other)))->_upper/*8*/);
  126. while (!((_i)>(_up))) {
  127. /*[IRF3.6put*/{T429* C1=((T429*)_other);
  128. int b1=r429item(C,_i);
  129. int b2=_i;
  130. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  131. }/*]*/
  132. _i=(_i)+(1);
  133. }
  134. *((T429*)(C))=*((T429*)(_other));
  135. }
  136. /*No:ARRAY[INTEGER].storage*/
  137. /*No:ARRAY[INTEGER].capacity*/
  138. /*No:ARRAY[INTEGER].lower*/
  139. int r429fast_index_of(T429* C,int a1){
  140. int R=0;
  141. R=((((T429*)C))->_lower/*12*/)+(r699fast_index_of((((T429*)C))->_storage/*0*/,a1,((((T429*)C))->_upper/*8*/)-((((T429*)C))->_lower/*12*/)));
  142. return R;
  143. }
  144. /*No:ARRAY[INTEGER].put*/
  145. /*No:ARRAY[INTEGER].upper*/
  146. void r429add_last(T429* C,int a1){
  147. int _new_capacity=0;
  148. /*IF*/if (((((T429*)C))->_capacity/*4*/)<((r429count(C))+(1))) {
  149. /*IF*/if (((((T429*)C))->_capacity/*4*/)==(0)) {
  150. C->_capacity=16;
  151. C->_storage=calloc((((T429*)C))->_capacity/*4*/,sizeof(int));
  152. }
  153. else {
  154. _new_capacity=(2)*((((T429*)C))->_capacity/*4*/);
  155. C->_storage=r699realloc((((T429*)C))->_storage/*0*/,(((T429*)C))->_capacity/*4*/,_new_capacity);
  156. C->_capacity=_new_capacity;
  157. }
  158. /*FI*/}
  159. /*FI*/C->_upper=((((T429*)C))->_upper/*8*/)+(1);
  160. /*[IRF3.6put*/{T429* C1=C;
  161. int b1=a1;
  162. int b2=(((T429*)C))->_upper/*8*/;
  163. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  164. }/*]*/
  165. }
  166. int r429count(T429* C){
  167. int R=0;
  168. R=(((((T429*)C))->_upper/*8*/)-((((T429*)C))->_lower/*12*/))+(1);
  169. return R;
  170. }
  171. T0* r764item(T764* C,int a1){
  172. T0* R=NULL;
  173. R=((((T764*)C))->_storage/*0*/)[(a1)-((((T764*)C))->_lower/*12*/)];
  174. return R;
  175. }
  176. /*No:ARRAY[FEATURE_CLAUSE].storage*/
  177. /*No:ARRAY[FEATURE_CLAUSE].capacity*/
  178. /*No:ARRAY[FEATURE_CLAUSE].lower*/
  179. /*No:ARRAY[FEATURE_CLAUSE].put*/
  180. /*No:ARRAY[FEATURE_CLAUSE].upper*/
  181. int r764count(T764* C){
  182. int R=0;
  183. R=(((((T764*)C))->_upper/*8*/)-((((T764*)C))->_lower/*12*/))+(1);
  184. return R;
  185. }
  186. void r764add_last(T764* C,T0* a1){
  187. int _new_capacity=0;
  188. /*IF*/if (((((T764*)C))->_capacity/*4*/)<((r764count(C))+(1))) {
  189. /*IF*/if (((((T764*)C))->_capacity/*4*/)==(0)) {
  190. C->_capacity=16;
  191. C->_storage=calloc((((T764*)C))->_capacity/*4*/,sizeof(T0*));
  192. }
  193. else {
  194. _new_capacity=(2)*((((T764*)C))->_capacity/*4*/);
  195. C->_storage=r42realloc((((T764*)C))->_storage/*0*/,(((T764*)C))->_capacity/*4*/,_new_capacity);
  196. C->_capacity=_new_capacity;
  197. }
  198. /*FI*/}
  199. /*FI*/C->_upper=((((T764*)C))->_upper/*8*/)+(1);
  200. /*[IRF3.6put*/{T764* C1=C;
  201. T0* b1=a1;
  202. int b2=(((T764*)C))->_upper/*8*/;
  203. ((((T764*)C1))->_storage/*0*/)[(b2)-((((T764*)C1))->_lower/*12*/)]=(b1);
  204. }/*]*/
  205. }
  206. int r321fast_has(T321* C,T0* a1){
  207. int R=0;
  208. /*IF*/if ((r321count(C))>(0)) {
  209. R=(r321fast_index_of(C,a1))<=((((T321*)C))->_upper/*12*/);
  210. }
  211. /*FI*/return R;
  212. }
  213. T0* r321item(T321* C,int a1){
  214. T0* R=NULL;
  215. R=((((T321*)C))->_storage/*4*/)[a1];
  216. return R;
  217. }
  218. /*No:FIXED_ARRAY[RUN_FEATURE].storage*/
  219. void r321swap(T321* C,int a1,int a2){
  220. T0* _tmp=NULL;
  221. _tmp=r321item(C,a1);
  222. /*[IRF3.6put*/{T321* C1=C;
  223. T0* b1=r321item(C,a2);
  224. int b2=a1;
  225. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  226. }/*]*/
  227. /*[IRF3.6put*/{T321* C1=C;
  228. T0* b1=_tmp;
  229. int b2=a2;
  230. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  231. }/*]*/
  232. }
  233. /*No:FIXED_ARRAY[RUN_FEATURE].capacity*/
  234. void r321with_capacity(T321* C,int a1){
  235. /*IF*/if (((((T321*)C))->_capacity/*8*/)<(a1)) {
  236. C->_storage=calloc(a1,sizeof(T0*));
  237. C->_capacity=a1;
  238. }
  239. /*FI*/C->_upper=-(1);
  240. }
  241. int r321fast_index_of(T321* C,T0* a1){
  242. int R=0;
  243. R=r778fast_index_of((((T321*)C))->_storage/*4*/,a1,(((T321*)C))->_upper/*12*/);
  244. return R;
  245. }
  246. /*No:FIXED_ARRAY[RUN_FEATURE].put*/
  247. /*No:FIXED_ARRAY[RUN_FEATURE].upper*/
  248. void r321add_last(T321* C,T0* a1){
  249. int _new_capacity=0;
  250. /*IF*/if ((((((T321*)C))->_upper/*12*/)+(1))<=(((((T321*)C))->_capacity/*8*/)-(1))) {
  251. C->_upper=((((T321*)C))->_upper/*12*/)+(1);
  252. }
  253.  else if (((((T321*)C))->_capacity/*8*/)==(0)) {
  254. C->_storage=calloc(2,sizeof(T0*));
  255. C->_capacity=2;
  256. C->_upper=0;
  257. }
  258. else {
  259. _new_capacity=(2)*((((T321*)C))->_capacity/*8*/);
  260. C->_storage=r778realloc((((T321*)C))->_storage/*4*/,(((T321*)C))->_capacity/*8*/,_new_capacity);
  261. C->_capacity=_new_capacity;
  262. C->_upper=((((T321*)C))->_upper/*12*/)+(1);
  263. }
  264. /*FI*//*[IRF3.6put*/{T321* C1=C;
  265. T0* b1=a1;
  266. int b2=(((T321*)C))->_upper/*12*/;
  267. ((((T321*)C1))->_storage/*4*/)[b2]=(b1);
  268. }/*]*/
  269. }
  270. int r321count(T321* C){
  271. int R=0;
  272. R=((((T321*)C))->_upper/*12*/)+(1);
  273. return R;
  274. }
  275. /*No:ARRAY[LOCAL_NAME1].clear_all*/
  276. /*No:ARRAY[LOCAL_NAME1].set_all_with*/
  277. void r733make(T733* C,int a1,int a2){
  278. int _needed=0;
  279. C->_lower=a1;
  280. C->_upper=a2;
  281. _needed=((a2)-(a1))+(1);
  282. /*IF*/if ((_needed)>(0)) {
  283. /*IF*/if (((((T733*)C))->_capacity/*8*/)<(_needed)) {
  284. /*IF*/if (((((T733*)C))->_capacity/*8*/)==(0)) {
  285. C->_storage=calloc(_needed,sizeof(T0*));
  286. }
  287. else {
  288. C->_storage=calloc(_needed,sizeof(T0*));
  289. }
  290. /*FI*/C->_capacity=_needed;
  291. }
  292. else {
  293. /*[IRF3.6clear_all*/{T733* C1=C;
  294. T0* __value=NULL;
  295. /*[IRF3.6set_all_with*/{T733* C2=C1;
  296. T0* c1=__value;
  297. r731set_all_with((((T733*)C2))->_storage/*4*/,c1,((((T733*)C2))->_upper/*12*/)-((((T733*)C2))->_lower/*16*/));
  298. }/*]*/
  299. }/*]*/
  300. }
  301. /*FI*/}
  302. /*FI*/}
  303. T0* r733item(T733* C,int a1){
  304. T0* R=NULL;
  305. R=((((T733*)C))->_storage/*4*/)[(a1)-((((T733*)C))->_lower/*16*/)];
  306. return R;
  307. }
  308. /*No:ARRAY[LOCAL_NAME1].storage*/
  309. T0* r733twin(T733* C){
  310. T0* R=NULL;
  311. R=malloc(sizeof(*C));
  312. *((T733*)R)=M733;
  313. r733copy(((T733*)R),((T0*)C));
  314. return R;
  315. }
  316. /*No:ARRAY[LOCAL_NAME1].capacity*/
  317. void r733copy(T733* C,T0* a1){
  318. int _needed_capacity=0;
  319. C->_lower=(((T733*)((T733*)a1)))->_lower/*16*/;
  320. C->_upper=(((T733*)((T733*)a1)))->_upper/*12*/;
  321. _needed_capacity=(((((T733*)C))->_upper/*12*/)-((((T733*)C))->_lower/*16*/))+(1);
  322. /*IF*/if (((((T733*)C))->_capacity/*8*/)<(_needed_capacity)) {
  323. C->_capacity=_needed_capacity;
  324. C->_storage=calloc((((T733*)C))->_capacity/*8*/,sizeof(T0*));
  325. }
  326. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  327. r731copy_from((((T733*)C))->_storage/*4*/,(((T733*)((T733*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  328. }
  329. /*FI*/}
  330. /*No:ARRAY[LOCAL_NAME1].lower*/
  331. /*No:ARRAY[LOCAL_NAME1].put*/
  332. /*No:ARRAY[LOCAL_NAME1].upper*/
  333. int r733count(T733* C){
  334. int R=0;
  335. R=(((((T733*)C))->_upper/*12*/)-((((T733*)C))->_lower/*16*/))+(1);
  336. return R;
  337. }
  338. void r733add_last(T733* C,T0* a1){
  339. int _new_capacity=0;
  340. /*IF*/if (((((T733*)C))->_capacity/*8*/)<((r733count(C))+(1))) {
  341. /*IF*/if (((((T733*)C))->_capacity/*8*/)==(0)) {
  342. C->_capacity=16;
  343. C->_storage=calloc((((T733*)C))->_capacity/*8*/,sizeof(T0*));
  344. }
  345. else {
  346. _new_capacity=(2)*((((T733*)C))->_capacity/*8*/);
  347. C->_storage=r731realloc((((T733*)C))->_storage/*4*/,(((T733*)C))->_capacity/*8*/,_new_capacity);
  348. C->_capacity=_new_capacity;
  349. }
  350. /*FI*/}
  351. /*FI*/C->_upper=((((T733*)C))->_upper/*12*/)+(1);
  352. /*[IRF3.6put*/{T733* C1=C;
  353. T0* b1=a1;
  354. int b2=(((T733*)C))->_upper/*12*/;
  355. ((((T733*)C1))->_storage/*4*/)[(b2)-((((T733*)C1))->_lower/*16*/)]=(b1);
  356. }/*]*/
  357. }
  358. T0* r733first(T733* C){
  359. T0* R=NULL;
  360. R=r733item(C,(((T733*)C))->_lower/*16*/);
  361. return R;
  362. }
  363. T0* r247item(T247* C,int a1){
  364. T0* R=NULL;
  365. R=((((T247*)C))->_storage/*4*/)[(a1)-((((T247*)C))->_lower/*16*/)];
  366. return R;
  367. }
  368. /*No:ARRAY[WHEN_ITEM_1].storage*/
  369. T0* r247twin(T247* C){
  370. T0* R=NULL;
  371. R=malloc(sizeof(*C));
  372. *((T247*)R)=M247;
  373. r247copy(((T247*)R),((T0*)C));
  374. return R;
  375. }
  376. /*No:ARRAY[WHEN_ITEM_1].capacity*/
  377. void r247copy(T247* C,T0* a1){
  378. int _needed_capacity=0;
  379. C->_lower=(((T247*)((T247*)a1)))->_lower/*16*/;
  380. C->_upper=(((T247*)((T247*)a1)))->_upper/*12*/;
  381. _needed_capacity=(((((T247*)C))->_upper/*12*/)-((((T247*)C))->_lower/*16*/))+(1);
  382. /*IF*/if (((((T247*)C))->_capacity/*8*/)<(_needed_capacity)) {
  383. C->_capacity=_needed_capacity;
  384. C->_storage=calloc((((T247*)C))->_capacity/*8*/,sizeof(T0*));
  385. }
  386. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  387. r497copy_from((((T247*)C))->_storage/*4*/,(((T247*)((T247*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  388. }
  389. /*FI*/}
  390. /*No:ARRAY[WHEN_ITEM_1].lower*/
  391. /*No:ARRAY[WHEN_ITEM_1].put*/
  392. /*No:ARRAY[WHEN_ITEM_1].upper*/
  393. int r247count(T247* C){
  394. int R=0;
  395. R=(((((T247*)C))->_upper/*12*/)-((((T247*)C))->_lower/*16*/))+(1);
  396. return R;
  397. }
  398. void r247add_last(T247* C,T0* a1){
  399. int _new_capacity=0;
  400. /*IF*/if (((((T247*)C))->_capacity/*8*/)<((r247count(C))+(1))) {
  401. /*IF*/if (((((T247*)C))->_capacity/*8*/)==(0)) {
  402. C->_capacity=16;
  403. C->_storage=calloc((((T247*)C))->_capacity/*8*/,sizeof(T0*));
  404. }
  405. else {
  406. _new_capacity=(2)*((((T247*)C))->_capacity/*8*/);
  407. C->_storage=r497realloc((((T247*)C))->_storage/*4*/,(((T247*)C))->_capacity/*8*/,_new_capacity);
  408. C->_capacity=_new_capacity;
  409. }
  410. /*FI*/}
  411. /*FI*/C->_upper=((((T247*)C))->_upper/*12*/)+(1);
  412. /*[IRF3.6put*/{T247* C1=C;
  413. T0* b1=a1;
  414. int b2=(((T247*)C))->_upper/*12*/;
  415. ((((T247*)C1))->_storage/*4*/)[(b2)-((((T247*)C1))->_lower/*16*/)]=(b1);
  416. }/*]*/
  417. }
  418. T0* r948item(T948* C,int a1){
  419. T0* R=NULL;
  420. R=((((T948*)C))->_storage/*0*/)[(a1)-((((T948*)C))->_lower/*12*/)];
  421. return R;
  422. }
  423. /*No:ARRAY[IFTHEN].storage*/
  424. T0* r948twin(T948* C){
  425. T0* R=NULL;
  426. R=malloc(sizeof(*C));
  427. *((T948*)R)=M948;
  428. r948copy(((T948*)R),((T0*)C));
  429. return R;
  430. }
  431. /*No:ARRAY[IFTHEN].capacity*/
  432. void r948copy(T948* C,T0* a1){
  433. int _needed_capacity=0;
  434. C->_lower=(((T948*)((T948*)a1)))->_lower/*12*/;
  435. C->_upper=(((T948*)((T948*)a1)))->_upper/*8*/;
  436. _needed_capacity=(((((T948*)C))->_upper/*8*/)-((((T948*)C))->_lower/*12*/))+(1);
  437. /*IF*/if (((((T948*)C))->_capacity/*4*/)<(_needed_capacity)) {
  438. C->_capacity=_needed_capacity;
  439. C->_storage=calloc((((T948*)C))->_capacity/*4*/,sizeof(T0*));
  440. }
  441. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  442. r191copy_from((((T948*)C))->_storage/*0*/,(((T948*)((T948*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  443. }
  444. /*FI*/}
  445. /*No:ARRAY[IFTHEN].lower*/
  446. /*No:ARRAY[IFTHEN].put*/
  447. /*No:ARRAY[IFTHEN].upper*/
  448. int r948count(T948* C){
  449. int R=0;
  450. R=(((((T948*)C))->_upper/*8*/)-((((T948*)C))->_lower/*12*/))+(1);
  451. return R;
  452. }
  453. void r948add_last(T948* C,T0* a1){
  454. int _new_capacity=0;
  455. /*IF*/if (((((T948*)C))->_capacity/*4*/)<((r948count(C))+(1))) {
  456. /*IF*/if (((((T948*)C))->_capacity/*4*/)==(0)) {
  457. C->_capacity=16;
  458. C->_storage=calloc((((T948*)C))->_capacity/*4*/,sizeof(T0*));
  459. }
  460. else {
  461. _new_capacity=(2)*((((T948*)C))->_capacity/*4*/);
  462. C->_storage=r191realloc((((T948*)C))->_storage/*0*/,(((T948*)C))->_capacity/*4*/,_new_capacity);
  463. C->_capacity=_new_capacity;
  464. }
  465. /*FI*/}
  466. /*FI*/C->_upper=((((T948*)C))->_upper/*8*/)+(1);
  467. /*[IRF3.6put*/{T948* C1=C;
  468. T0* b1=a1;
  469. int b2=(((T948*)C))->_upper/*8*/;
  470. ((((T948*)C1))->_storage/*0*/)[(b2)-((((T948*)C1))->_lower/*12*/)]=(b1);
  471. }/*]*/
  472. }
  473. /*No:ARRAY[ARGUMENT_NAME1].clear_all*/
  474. /*No:ARRAY[ARGUMENT_NAME1].set_all_with*/
  475. void r65make(T65* C,int a1,int a2){
  476. int _needed=0;
  477. C->_lower=a1;
  478. C->_upper=a2;
  479. _needed=((a2)-(a1))+(1);
  480. /*IF*/if ((_needed)>(0)) {
  481. /*IF*/if (((((T65*)C))->_capacity/*8*/)<(_needed)) {
  482. /*IF*/if (((((T65*)C))->_capacity/*8*/)==(0)) {
  483. C->_storage=calloc(_needed,sizeof(T0*));
  484. }
  485. else {
  486. C->_storage=calloc(_needed,sizeof(T0*));
  487. }
  488. /*FI*/C->_capacity=_needed;
  489. }
  490. else {
  491. /*[IRF3.6clear_all*/{T65* C1=C;
  492. T0* __value=NULL;
  493. /*[IRF3.6set_all_with*/{T65* C2=C1;
  494. T0* c1=__value;
  495. r24set_all_with((((T65*)C2))->_storage/*4*/,c1,((((T65*)C2))->_upper/*12*/)-((((T65*)C2))->_lower/*16*/));
  496. }/*]*/
  497. }/*]*/
  498. }
  499. /*FI*/}
  500. /*FI*/}
  501. T0* r65item(T65* C,int a1){
  502. T0* R=NULL;
  503. R=((((T65*)C))->_storage/*4*/)[(a1)-((((T65*)C))->_lower/*16*/)];
  504. return R;
  505. }
  506. /*No:ARRAY[ARGUMENT_NAME1].storage*/
  507. T0* r65twin(T65* C){
  508. T0* R=NULL;
  509. R=malloc(sizeof(*C));
  510. *((T65*)R)=M65;
  511. r65copy(((T65*)R),((T0*)C));
  512. return R;
  513. }
  514. /*No:ARRAY[ARGUMENT_NAME1].capacity*/
  515. void r65copy(T65* C,T0* a1){
  516. int _needed_capacity=0;
  517. C->_lower=(((T65*)((T65*)a1)))->_lower/*16*/;
  518. C->_upper=(((T65*)((T65*)a1)))->_upper/*12*/;
  519. _needed_capacity=(((((T65*)C))->_upper/*12*/)-((((T65*)C))->_lower/*16*/))+(1);
  520. /*IF*/if (((((T65*)C))->_capacity/*8*/)<(_needed_capacity)) {
  521. C->_capacity=_needed_capacity;
  522. C->_storage=calloc((((T65*)C))->_capacity/*8*/,sizeof(T0*));
  523. }
  524. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  525. r24copy_from((((T65*)C))->_storage/*4*/,(((T65*)((T65*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  526. }
  527. /*FI*/}
  528. /*No:ARRAY[ARGUMENT_NAME1].lower*/
  529. /*No:ARRAY[ARGUMENT_NAME1].put*/
  530. /*No:ARRAY[ARGUMENT_NAME1].upper*/
  531. int r65count(T65* C){
  532. int R=0;
  533. R=(((((T65*)C))->_upper/*12*/)-((((T65*)C))->_lower/*16*/))+(1);
  534. return R;
  535. }
  536. void r65add_last(T65* C,T0* a1){
  537. int _new_capacity=0;
  538. /*IF*/if (((((T65*)C))->_capacity/*8*/)<((r65count(C))+(1))) {
  539. /*IF*/if (((((T65*)C))->_capacity/*8*/)==(0)) {
  540. C->_capacity=16;
  541. C->_storage=calloc((((T65*)C))->_capacity/*8*/,sizeof(T0*));
  542. }
  543. else {
  544. _new_capacity=(2)*((((T65*)C))->_capacity/*8*/);
  545. C->_storage=r24realloc((((T65*)C))->_storage/*4*/,(((T65*)C))->_capacity/*8*/,_new_capacity);
  546. C->_capacity=_new_capacity;
  547. }
  548. /*FI*/}
  549. /*FI*/C->_upper=((((T65*)C))->_upper/*12*/)+(1);
  550. /*[IRF3.6put*/{T65* C1=C;
  551. T0* b1=a1;
  552. int b2=(((T65*)C))->_upper/*12*/;
  553. ((((T65*)C1))->_storage/*4*/)[(b2)-((((T65*)C1))->_lower/*16*/)]=(b1);
  554. }/*]*/
  555. }
  556. T0* r65first(T65* C){
  557. T0* R=NULL;
  558. R=r65item(C,(((T65*)C))->_lower/*16*/);
  559. return R;
  560. }
  561. /*No:ARRAY[E_FEATURE].clear_all*/
  562. /*No:ARRAY[E_FEATURE].set_all_with*/
  563. void r495make(T495* C,int a1,int a2){
  564. int _needed=0;
  565. C->_lower=a1;
  566. C->_upper=a2;
  567. _needed=((a2)-(a1))+(1);
  568. /*IF*/if ((_needed)>(0)) {
  569. /*IF*/if (((((T495*)C))->_capacity/*4*/)<(_needed)) {
  570. /*IF*/if (((((T495*)C))->_capacity/*4*/)==(0)) {
  571. C->_storage=calloc(_needed,sizeof(T0*));
  572. }
  573. else {
  574. C->_storage=calloc(_needed,sizeof(T0*));
  575. }
  576. /*FI*/C->_capacity=_needed;
  577. }
  578. else {
  579. /*[IRF3.6clear_all*/{T495* C1=C;
  580. T0* __value=NULL;
  581. /*[IRF3.6set_all_with*/{T495* C2=C1;
  582. T0* c1=__value;
  583. r822set_all_with((((T495*)C2))->_storage/*0*/,c1,((((T495*)C2))->_upper/*8*/)-((((T495*)C2))->_lower/*12*/));
  584. }/*]*/
  585. }/*]*/
  586. }
  587. /*FI*/}
  588. /*FI*/}
  589. T0* r495item(T495* C,int a1){
  590. T0* R=NULL;
  591. R=((((T495*)C))->_storage/*0*/)[(a1)-((((T495*)C))->_lower/*12*/)];
  592. return R;
  593. }
  594. void r495resize(T495* C,int a1,int a2){
  595. int _mem=0;
  596. int _up=0;
  597. int _i=0;
  598. T0* _other=NULL;
  599. {T495*n=malloc(sizeof(*n));
  600. *n=M495;
  601. r495make(n,a1,a2);
  602. _other=(T0*)n;
  603. }
  604. _i=r2max((((T495*)C))->_lower/*12*/,(((T495*)((T495*)_other)))->_lower/*12*/);
  605. _up=r2min((((T495*)C))->_upper/*8*/,(((T495*)((T495*)_other)))->_upper/*8*/);
  606. while (!((_i)>(_up))) {
  607. /*[IRF3.6put*/{T495* C1=((T495*)_other);
  608. T0* b1=r495item(C,_i);
  609. int b2=_i;
  610. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  611. }/*]*/
  612. _i=(_i)+(1);
  613. }
  614. *((T495*)(C))=*((T495*)(_other));
  615. }
  616. /*No:ARRAY[E_FEATURE].storage*/
  617. /*No:ARRAY[E_FEATURE].capacity*/
  618. /*No:ARRAY[E_FEATURE].lower*/
  619. /*No:ARRAY[E_FEATURE].put*/
  620. /*No:ARRAY[E_FEATURE].upper*/
  621. void r495add_last(T495* C,T0* a1){
  622. int _new_capacity=0;
  623. /*IF*/if (((((T495*)C))->_capacity/*4*/)<((r495count(C))+(1))) {
  624. /*IF*/if (((((T495*)C))->_capacity/*4*/)==(0)) {
  625. C->_capacity=16;
  626. C->_storage=calloc((((T495*)C))->_capacity/*4*/,sizeof(T0*));
  627. }
  628. else {
  629. _new_capacity=(2)*((((T495*)C))->_capacity/*4*/);
  630. C->_storage=r822realloc((((T495*)C))->_storage/*0*/,(((T495*)C))->_capacity/*4*/,_new_capacity);
  631. C->_capacity=_new_capacity;
  632. }
  633. /*FI*/}
  634. /*FI*/C->_upper=((((T495*)C))->_upper/*8*/)+(1);
  635. /*[IRF3.6put*/{T495* C1=C;
  636. T0* b1=a1;
  637. int b2=(((T495*)C))->_upper/*8*/;
  638. ((((T495*)C1))->_storage/*0*/)[(b2)-((((T495*)C1))->_lower/*12*/)]=(b1);
  639. }/*]*/
  640. }
  641. int r495count(T495* C){
  642. int R=0;
  643. R=(((((T495*)C))->_upper/*8*/)-((((T495*)C))->_lower/*12*/))+(1);
  644. return R;
  645. }
  646. T0* r263item(T263* C,int a1){
  647. T0* R=NULL;
  648. R=((((T263*)C))->_storage/*4*/)[(a1)-((((T263*)C))->_lower/*16*/)];
  649. return R;
  650. }
  651. /*No:ARRAY[WHEN_ITEM_2].storage*/
  652. T0* r263twin(T263* C){
  653. T0* R=NULL;
  654. R=malloc(sizeof(*C));
  655. *((T263*)R)=M263;
  656. r263copy(((T263*)R),((T0*)C));
  657. return R;
  658. }
  659. /*No:ARRAY[WHEN_ITEM_2].capacity*/
  660. void r263copy(T263* C,T0* a1){
  661. int _needed_capacity=0;
  662. C->_lower=(((T263*)((T263*)a1)))->_lower/*16*/;
  663. C->_upper=(((T263*)((T263*)a1)))->_upper/*12*/;
  664. _needed_capacity=(((((T263*)C))->_upper/*12*/)-((((T263*)C))->_lower/*16*/))+(1);
  665. /*IF*/if (((((T263*)C))->_capacity/*8*/)<(_needed_capacity)) {
  666. C->_capacity=_needed_capacity;
  667. C->_storage=calloc((((T263*)C))->_capacity/*8*/,sizeof(T0*));
  668. }
  669. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  670. r533copy_from((((T263*)C))->_storage/*4*/,(((T263*)((T263*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  671. }
  672. /*FI*/}
  673. /*No:ARRAY[WHEN_ITEM_2].lower*/
  674. /*No:ARRAY[WHEN_ITEM_2].put*/
  675. /*No:ARRAY[WHEN_ITEM_2].upper*/
  676. int r263count(T263* C){
  677. int R=0;
  678. R=(((((T263*)C))->_upper/*12*/)-((((T263*)C))->_lower/*16*/))+(1);
  679. return R;
  680. }
  681. void r263add_last(T263* C,T0* a1){
  682. int _new_capacity=0;
  683. /*IF*/if (((((T263*)C))->_capacity/*8*/)<((r263count(C))+(1))) {
  684. /*IF*/if (((((T263*)C))->_capacity/*8*/)==(0)) {
  685. C->_capacity=16;
  686. C->_storage=calloc((((T263*)C))->_capacity/*8*/,sizeof(T0*));
  687. }
  688. else {
  689. _new_capacity=(2)*((((T263*)C))->_capacity/*8*/);
  690. C->_storage=r533realloc((((T263*)C))->_storage/*4*/,(((T263*)C))->_capacity/*8*/,_new_capacity);
  691. C->_capacity=_new_capacity;
  692. }
  693. /*FI*/}
  694. /*FI*/C->_upper=((((T263*)C))->_upper/*12*/)+(1);
  695. /*[IRF3.6put*/{T263* C1=C;
  696. T0* b1=a1;
  697. int b2=(((T263*)C))->_upper/*12*/;
  698. ((((T263*)C1))->_storage/*4*/)[(b2)-((((T263*)C1))->_lower/*16*/)]=(b1);
  699. }/*]*/
  700. }
  701.  
  702.