home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ppcsmalleiffel / source.lha / bin_c / compile_to_jvm8.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  16.2 KB  |  585 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_jvm.h"
  9. /*No:ARRAY[E_REQUIRE].clear_all*/
  10. /*No:ARRAY[E_REQUIRE].set_all_with*/
  11. int r522empty(T522* C){
  12. int R=0;
  13. R=(r522count(C))==(0);
  14. return R;
  15. }
  16. void r522make(T522* C,int a1,int a2){
  17. int _needed=0;
  18. C->_lower=a1;
  19. C->_upper=a2;
  20. _needed=((a2)-(a1))+(1);
  21. /*IF*/if ((_needed)>(0)) {
  22. /*IF*/if (((((T522*)C))->_capacity/*4*/)<(_needed)) {
  23. /*IF*/if (((((T522*)C))->_capacity/*4*/)==(0)) {
  24. C->_storage=calloc(_needed,sizeof(T0*));
  25. }
  26. else {
  27. C->_storage=calloc(_needed,sizeof(T0*));
  28. }
  29. /*FI*/C->_capacity=_needed;
  30. }
  31. else {
  32. /*[IRF3.6clear_all*/{T522* C1=C;
  33. T0* __value=NULL;
  34. /*[IRF3.6set_all_with*/{T522* C2=C1;
  35. T0* c1=__value;
  36. r884set_all_with((((T522*)C2))->_storage/*0*/,c1,((((T522*)C2))->_upper/*8*/)-((((T522*)C2))->_lower/*12*/));
  37. }/*]*/
  38. }/*]*/
  39. }
  40. /*FI*/}
  41. /*FI*/}
  42. int r522fast_has(T522* C,T0* a1){
  43. int R=0;
  44. /*IF*/if ((r522count(C))>(0)) {
  45. R=(r522fast_index_of(C,a1))<=((((T522*)C))->_upper/*8*/);
  46. }
  47. /*FI*/return R;
  48. }
  49. T0* r522item(T522* C,int a1){
  50. T0* R=NULL;
  51. R=((((T522*)C))->_storage/*0*/)[(a1)-((((T522*)C))->_lower/*12*/)];
  52. return R;
  53. }
  54. void r522clear(T522* C){
  55. C->_upper=((((T522*)C))->_lower/*12*/)-(1);
  56. }
  57. /*No:ARRAY[E_REQUIRE].storage*/
  58. /*No:ARRAY[E_REQUIRE].capacity*/
  59. /*No:ARRAY[E_REQUIRE].lower*/
  60. int r522fast_index_of(T522* C,T0* a1){
  61. int R=0;
  62. R=((((T522*)C))->_lower/*12*/)+(r884fast_index_of((((T522*)C))->_storage/*0*/,a1,((((T522*)C))->_upper/*8*/)-((((T522*)C))->_lower/*12*/)));
  63. return R;
  64. }
  65. /*No:ARRAY[E_REQUIRE].put*/
  66. /*No:ARRAY[E_REQUIRE].upper*/
  67. void r522add_last(T522* C,T0* a1){
  68. int _new_capacity=0;
  69. /*IF*/if (((((T522*)C))->_capacity/*4*/)<((r522count(C))+(1))) {
  70. /*IF*/if (((((T522*)C))->_capacity/*4*/)==(0)) {
  71. C->_capacity=16;
  72. C->_storage=calloc((((T522*)C))->_capacity/*4*/,sizeof(T0*));
  73. }
  74. else {
  75. _new_capacity=(2)*((((T522*)C))->_capacity/*4*/);
  76. C->_storage=r884realloc((((T522*)C))->_storage/*0*/,(((T522*)C))->_capacity/*4*/,_new_capacity);
  77. C->_capacity=_new_capacity;
  78. }
  79. /*FI*/}
  80. /*FI*/C->_upper=((((T522*)C))->_upper/*8*/)+(1);
  81. /*[IRF3.6put*/{T522* C1=C;
  82. T0* b1=a1;
  83. int b2=(((T522*)C))->_upper/*8*/;
  84. ((((T522*)C1))->_storage/*0*/)[(b2)-((((T522*)C1))->_lower/*12*/)]=(b1);
  85. }/*]*/
  86. }
  87. int r522count(T522* C){
  88. int R=0;
  89. R=(((((T522*)C))->_upper/*8*/)-((((T522*)C))->_lower/*12*/))+(1);
  90. return R;
  91. }
  92. T0* r522first(T522* C){
  93. T0* R=NULL;
  94. R=r522item(C,(((T522*)C))->_lower/*12*/);
  95. return R;
  96. }
  97. T0* r552item(T552* C,int a1){
  98. T0* R=NULL;
  99. R=((((T552*)C))->_storage/*0*/)[(a1)-((((T552*)C))->_lower/*12*/)];
  100. return R;
  101. }
  102. /*No:ARRAY[RENAME_PAIR].storage*/
  103. /*No:ARRAY[RENAME_PAIR].capacity*/
  104. /*No:ARRAY[RENAME_PAIR].lower*/
  105. /*No:ARRAY[RENAME_PAIR].put*/
  106. /*No:ARRAY[RENAME_PAIR].upper*/
  107. int r552count(T552* C){
  108. int R=0;
  109. R=(((((T552*)C))->_upper/*8*/)-((((T552*)C))->_lower/*12*/))+(1);
  110. return R;
  111. }
  112. void r552add_last(T552* C,T0* a1){
  113. int _new_capacity=0;
  114. /*IF*/if (((((T552*)C))->_capacity/*4*/)<((r552count(C))+(1))) {
  115. /*IF*/if (((((T552*)C))->_capacity/*4*/)==(0)) {
  116. C->_capacity=16;
  117. C->_storage=calloc((((T552*)C))->_capacity/*4*/,sizeof(T0*));
  118. }
  119. else {
  120. _new_capacity=(2)*((((T552*)C))->_capacity/*4*/);
  121. C->_storage=r949realloc((((T552*)C))->_storage/*0*/,(((T552*)C))->_capacity/*4*/,_new_capacity);
  122. C->_capacity=_new_capacity;
  123. }
  124. /*FI*/}
  125. /*FI*/C->_upper=((((T552*)C))->_upper/*8*/)+(1);
  126. /*[IRF3.6put*/{T552* C1=C;
  127. T0* b1=a1;
  128. int b2=(((T552*)C))->_upper/*8*/;
  129. ((((T552*)C1))->_storage/*0*/)[(b2)-((((T552*)C1))->_lower/*12*/)]=(b1);
  130. }/*]*/
  131. }
  132. /*No:FIXED_ARRAY[E_FEATURE].item*/
  133. /*No:FIXED_ARRAY[E_FEATURE].clear*/
  134. /*No:FIXED_ARRAY[E_FEATURE].storage*/
  135. T0* r352twin(T352* C){
  136. T0* R=NULL;
  137. R=malloc(sizeof(*C));
  138. *((T352*)R)=M352;
  139. r352copy(((T352*)R),((T0*)C));
  140. return R;
  141. }
  142. /*No:FIXED_ARRAY[E_FEATURE].capacity*/
  143. void r352copy(T352* C,T0* a1){
  144. int _new_capacity=0;
  145. int _other_upper=0;
  146. _other_upper=(((T352*)((T352*)a1)))->_upper/*8*/;
  147. /*IF*/if ((_other_upper)>=(0)) {
  148. _new_capacity=(_other_upper)+(1);
  149. /*IF*/if (((((T352*)C))->_capacity/*4*/)<(_new_capacity)) {
  150. C->_capacity=_new_capacity;
  151. C->_storage=calloc(_new_capacity,sizeof(T0*));
  152. }
  153.  else if (((((T352*)C))->_capacity/*4*/)>(0)) {
  154. r822clear_all((((T352*)C))->_storage/*0*/,((((T352*)C))->_capacity/*4*/)-(1));
  155. }
  156. /*FI*/r822copy_from((((T352*)C))->_storage/*0*/,(((T352*)((T352*)a1)))->_storage/*0*/,_other_upper);
  157. }
  158.  else if (((((T352*)C))->_capacity/*4*/)>(0)) {
  159. r822clear_all((((T352*)C))->_storage/*0*/,((((T352*)C))->_capacity/*4*/)-(1));
  160. }
  161. /*FI*/C->_upper=_other_upper;
  162. }
  163. void r352with_capacity(T352* C,int a1){
  164. /*IF*/if (((((T352*)C))->_capacity/*4*/)<(a1)) {
  165. C->_storage=calloc(a1,sizeof(T0*));
  166. C->_capacity=a1;
  167. }
  168. /*FI*/C->_upper=-(1);
  169. }
  170. /*No:FIXED_ARRAY[E_FEATURE].put*/
  171. /*No:FIXED_ARRAY[E_FEATURE].upper*/
  172. void r352add_last(T352* C,T0* a1){
  173. int _new_capacity=0;
  174. /*IF*/if ((((((T352*)C))->_upper/*8*/)+(1))<=(((((T352*)C))->_capacity/*4*/)-(1))) {
  175. C->_upper=((((T352*)C))->_upper/*8*/)+(1);
  176. }
  177.  else if (((((T352*)C))->_capacity/*4*/)==(0)) {
  178. C->_storage=calloc(2,sizeof(T0*));
  179. C->_capacity=2;
  180. C->_upper=0;
  181. }
  182. else {
  183. _new_capacity=(2)*((((T352*)C))->_capacity/*4*/);
  184. C->_storage=r822realloc((((T352*)C))->_storage/*0*/,(((T352*)C))->_capacity/*4*/,_new_capacity);
  185. C->_capacity=_new_capacity;
  186. C->_upper=((((T352*)C))->_upper/*8*/)+(1);
  187. }
  188. /*FI*//*[IRF3.5put*/((((T352*)C))->_storage/*0*/)[(((T352*)C))->_upper/*8*/]=(a1);
  189. /*]*/
  190. }
  191. /*No:ARRAY[INDEX_CLAUSE].storage*/
  192. /*No:ARRAY[INDEX_CLAUSE].capacity*/
  193. /*No:ARRAY[INDEX_CLAUSE].lower*/
  194. /*No:ARRAY[INDEX_CLAUSE].put*/
  195. /*No:ARRAY[INDEX_CLAUSE].upper*/
  196. int r848count(T848* C){
  197. int R=0;
  198. R=(((((T848*)C))->_upper/*8*/)-((((T848*)C))->_lower/*12*/))+(1);
  199. return R;
  200. }
  201. void r848add_last(T848* C,T0* a1){
  202. int _new_capacity=0;
  203. /*IF*/if (((((T848*)C))->_capacity/*4*/)<((r848count(C))+(1))) {
  204. /*IF*/if (((((T848*)C))->_capacity/*4*/)==(0)) {
  205. C->_capacity=16;
  206. C->_storage=calloc((((T848*)C))->_capacity/*4*/,sizeof(T0*));
  207. }
  208. else {
  209. _new_capacity=(2)*((((T848*)C))->_capacity/*4*/);
  210. C->_storage=r100realloc((((T848*)C))->_storage/*0*/,(((T848*)C))->_capacity/*4*/,_new_capacity);
  211. C->_capacity=_new_capacity;
  212. }
  213. /*FI*/}
  214. /*FI*/C->_upper=((((T848*)C))->_upper/*8*/)+(1);
  215. /*[IRF3.6put*/{T848* C1=C;
  216. T0* b1=a1;
  217. int b2=(((T848*)C))->_upper/*8*/;
  218. ((((T848*)C1))->_storage/*0*/)[(b2)-((((T848*)C1))->_lower/*12*/)]=(b1);
  219. }/*]*/
  220. }
  221. int r38empty(T38* C){
  222. int R=0;
  223. R=(r38count(C))==(0);
  224. return R;
  225. }
  226. T0* r38item(T38* C,int a1){
  227. T0* R=NULL;
  228. R=((((T38*)C))->_storage/*0*/)[(a1)-((((T38*)C))->_lower/*12*/)];
  229. return R;
  230. }
  231. void r38clear(T38* C){
  232. C->_upper=((((T38*)C))->_lower/*12*/)-(1);
  233. }
  234. /*No:ARRAY[POSITION].storage*/
  235. /*No:ARRAY[POSITION].capacity*/
  236. int r38has(T38* C,T0* a1){
  237. int R=0;
  238. /*IF*/if ((r38count(C))>(0)) {
  239. R=(r38index_of(C,a1))<=((((T38*)C))->_upper/*8*/);
  240. }
  241. /*FI*/return R;
  242. }
  243. /*No:ARRAY[POSITION].lower*/
  244. void r38with_capacity(T38* C,int a1,int a2){
  245. /*IF*/if (((((T38*)C))->_capacity/*4*/)<(a1)) {
  246. C->_storage=calloc(a1,sizeof(T0*));
  247. C->_capacity=a1;
  248. }
  249. /*FI*/C->_lower=a2;
  250. C->_upper=(a2)-(1);
  251. }
  252. /*No:ARRAY[POSITION].put*/
  253. /*No:ARRAY[POSITION].upper*/
  254. void r38add_last(T38* C,T0* a1){
  255. int _new_capacity=0;
  256. /*IF*/if (((((T38*)C))->_capacity/*4*/)<((r38count(C))+(1))) {
  257. /*IF*/if (((((T38*)C))->_capacity/*4*/)==(0)) {
  258. C->_capacity=16;
  259. C->_storage=calloc((((T38*)C))->_capacity/*4*/,sizeof(T0*));
  260. }
  261. else {
  262. _new_capacity=(2)*((((T38*)C))->_capacity/*4*/);
  263. C->_storage=r379realloc((((T38*)C))->_storage/*0*/,(((T38*)C))->_capacity/*4*/,_new_capacity);
  264. C->_capacity=_new_capacity;
  265. }
  266. /*FI*/}
  267. /*FI*/C->_upper=((((T38*)C))->_upper/*8*/)+(1);
  268. /*[IRF3.6put*/{T38* C1=C;
  269. T0* b1=a1;
  270. int b2=(((T38*)C))->_upper/*8*/;
  271. ((((T38*)C1))->_storage/*0*/)[(b2)-((((T38*)C1))->_lower/*12*/)]=(b1);
  272. }/*]*/
  273. }
  274. int r38count(T38* C){
  275. int R=0;
  276. R=(((((T38*)C))->_upper/*8*/)-((((T38*)C))->_lower/*12*/))+(1);
  277. return R;
  278. }
  279. int r38index_of(T38* C,T0* a1){
  280. int R=0;
  281. R=((((T38*)C))->_lower/*12*/)+(r379index_of((((T38*)C))->_storage/*0*/,a1,((((T38*)C))->_upper/*8*/)-((((T38*)C))->_lower/*12*/)));
  282. return R;
  283. }
  284. int r854empty(T854* C){
  285. int R=0;
  286. R=(/*(IRF4.6count*/((((T854*)C))->_upper/*8*/)+(1)/*)*/)==(0);
  287. return R;
  288. }
  289. /*No:FIXED_ARRAY[PARENT].item*/
  290. /*No:FIXED_ARRAY[PARENT].clear*/
  291. /*No:FIXED_ARRAY[PARENT].storage*/
  292. /*No:FIXED_ARRAY[PARENT].capacity*/
  293. T0* r854last(T854* C){
  294. T0* R=NULL;
  295. R=/*(IRF4.6item*/((((T854*)C))->_storage/*0*/)[(((T854*)C))->_upper/*8*/]/*)*/;
  296. return R;
  297. }
  298. void r854with_capacity(T854* C,int a1){
  299. /*IF*/if (((((T854*)C))->_capacity/*4*/)<(a1)) {
  300. C->_storage=calloc(a1,sizeof(T0*));
  301. C->_capacity=a1;
  302. }
  303. /*FI*/C->_upper=-(1);
  304. }
  305. /*No:FIXED_ARRAY[PARENT].put*/
  306. /*No:FIXED_ARRAY[PARENT].upper*/
  307. void r854add_last(T854* C,T0* a1){
  308. int _new_capacity=0;
  309. /*IF*/if ((((((T854*)C))->_upper/*8*/)+(1))<=(((((T854*)C))->_capacity/*4*/)-(1))) {
  310. C->_upper=((((T854*)C))->_upper/*8*/)+(1);
  311. }
  312.  else if (((((T854*)C))->_capacity/*4*/)==(0)) {
  313. C->_storage=calloc(2,sizeof(T0*));
  314. C->_capacity=2;
  315. C->_upper=0;
  316. }
  317. else {
  318. _new_capacity=(2)*((((T854*)C))->_capacity/*4*/);
  319. C->_storage=r304realloc((((T854*)C))->_storage/*0*/,(((T854*)C))->_capacity/*4*/,_new_capacity);
  320. C->_capacity=_new_capacity;
  321. C->_upper=((((T854*)C))->_upper/*8*/)+(1);
  322. }
  323. /*FI*//*[IRF3.5put*/((((T854*)C))->_storage/*0*/)[(((T854*)C))->_upper/*8*/]=(a1);
  324. /*]*/
  325. }
  326. /*No:FIXED_ARRAY[PARENT].count*/
  327. void r854remove_last(T854* C){
  328. C->_upper=((((T854*)C))->_upper/*8*/)-(1);
  329. }
  330. T0* r26item(T26* C,int a1){
  331. T0* R=NULL;
  332. R=((((T26*)C))->_storage/*0*/)[(a1)-((((T26*)C))->_lower/*12*/)];
  333. return R;
  334. }
  335. /*No:ARRAY[PARENT].storage*/
  336. /*No:ARRAY[PARENT].capacity*/
  337. /*No:ARRAY[PARENT].lower*/
  338. /*No:ARRAY[PARENT].put*/
  339. /*No:ARRAY[PARENT].upper*/
  340. int r26count(T26* C){
  341. int R=0;
  342. R=(((((T26*)C))->_upper/*8*/)-((((T26*)C))->_lower/*12*/))+(1);
  343. return R;
  344. }
  345. void r26add_last(T26* C,T0* a1){
  346. int _new_capacity=0;
  347. /*IF*/if (((((T26*)C))->_capacity/*4*/)<((r26count(C))+(1))) {
  348. /*IF*/if (((((T26*)C))->_capacity/*4*/)==(0)) {
  349. C->_capacity=16;
  350. C->_storage=calloc((((T26*)C))->_capacity/*4*/,sizeof(T0*));
  351. }
  352. else {
  353. _new_capacity=(2)*((((T26*)C))->_capacity/*4*/);
  354. C->_storage=r304realloc((((T26*)C))->_storage/*0*/,(((T26*)C))->_capacity/*4*/,_new_capacity);
  355. C->_capacity=_new_capacity;
  356. }
  357. /*FI*/}
  358. /*FI*/C->_upper=((((T26*)C))->_upper/*8*/)+(1);
  359. /*[IRF3.6put*/{T26* C1=C;
  360. T0* b1=a1;
  361. int b2=(((T26*)C))->_upper/*8*/;
  362. ((((T26*)C1))->_storage/*0*/)[(b2)-((((T26*)C1))->_lower/*12*/)]=(b1);
  363. }/*]*/
  364. }
  365. T0* r26first(T26* C){
  366. T0* R=NULL;
  367. R=r26item(C,(((T26*)C))->_lower/*12*/);
  368. return R;
  369. }
  370. T0* r587item(T587* C,int a1){
  371. T0* R=NULL;
  372. R=((((T587*)C))->_storage/*0*/)[(a1)-((((T587*)C))->_lower/*12*/)];
  373. return R;
  374. }
  375. /*No:ARRAY[EXPORT_ITEM].storage*/
  376. /*No:ARRAY[EXPORT_ITEM].capacity*/
  377. /*No:ARRAY[EXPORT_ITEM].lower*/
  378. /*No:ARRAY[EXPORT_ITEM].put*/
  379. /*No:ARRAY[EXPORT_ITEM].upper*/
  380. int r587count(T587* C){
  381. int R=0;
  382. R=(((((T587*)C))->_upper/*8*/)-((((T587*)C))->_lower/*12*/))+(1);
  383. return R;
  384. }
  385. void r587add_last(T587* C,T0* a1){
  386. int _new_capacity=0;
  387. /*IF*/if (((((T587*)C))->_capacity/*4*/)<((r587count(C))+(1))) {
  388. /*IF*/if (((((T587*)C))->_capacity/*4*/)==(0)) {
  389. C->_capacity=16;
  390. C->_storage=calloc((((T587*)C))->_capacity/*4*/,sizeof(T0*));
  391. }
  392. else {
  393. _new_capacity=(2)*((((T587*)C))->_capacity/*4*/);
  394. C->_storage=r44realloc((((T587*)C))->_storage/*0*/,(((T587*)C))->_capacity/*4*/,_new_capacity);
  395. C->_capacity=_new_capacity;
  396. }
  397. /*FI*/}
  398. /*FI*/C->_upper=((((T587*)C))->_upper/*8*/)+(1);
  399. /*[IRF3.6put*/{T587* C1=C;
  400. T0* b1=a1;
  401. int b2=(((T587*)C))->_upper/*8*/;
  402. ((((T587*)C1))->_storage/*0*/)[(b2)-((((T587*)C1))->_lower/*12*/)]=(b1);
  403. }/*]*/
  404. }
  405. /*No:ARRAY[MANIFEST_STRING].clear_all*/
  406. /*No:ARRAY[MANIFEST_STRING].set_all_with*/
  407. void r381make(T381* C,int a1,int a2){
  408. int _needed=0;
  409. C->_lower=a1;
  410. C->_upper=a2;
  411. _needed=((a2)-(a1))+(1);
  412. /*IF*/if ((_needed)>(0)) {
  413. /*IF*/if (((((T381*)C))->_capacity/*8*/)<(_needed)) {
  414. /*IF*/if (((((T381*)C))->_capacity/*8*/)==(0)) {
  415. C->_storage=calloc(_needed,sizeof(T0*));
  416. }
  417. else {
  418. C->_storage=calloc(_needed,sizeof(T0*));
  419. }
  420. /*FI*/C->_capacity=_needed;
  421. }
  422. else {
  423. /*[IRF3.6clear_all*/{T381* C1=C;
  424. T0* __value=NULL;
  425. /*[IRF3.6set_all_with*/{T381* C2=C1;
  426. T0* c1=__value;
  427. r729set_all_with((((T381*)C2))->_storage/*4*/,c1,((((T381*)C2))->_upper/*12*/)-((((T381*)C2))->_lower/*16*/));
  428. }/*]*/
  429. }/*]*/
  430. }
  431. /*FI*/}
  432. /*FI*/}
  433. T0* r381item(T381* C,int a1){
  434. T0* R=NULL;
  435. R=((((T381*)C))->_storage/*4*/)[(a1)-((((T381*)C))->_lower/*16*/)];
  436. return R;
  437. }
  438. /*No:ARRAY[MANIFEST_STRING].storage*/
  439. T0* r381twin(T381* C){
  440. T0* R=NULL;
  441. R=malloc(sizeof(*C));
  442. *((T381*)R)=M381;
  443. r381copy(((T381*)R),((T0*)C));
  444. return R;
  445. }
  446. /*No:ARRAY[MANIFEST_STRING].capacity*/
  447. void r381copy(T381* C,T0* a1){
  448. int _needed_capacity=0;
  449. C->_lower=(((T381*)((T381*)a1)))->_lower/*16*/;
  450. C->_upper=(((T381*)((T381*)a1)))->_upper/*12*/;
  451. _needed_capacity=(((((T381*)C))->_upper/*12*/)-((((T381*)C))->_lower/*16*/))+(1);
  452. /*IF*/if (((((T381*)C))->_capacity/*8*/)<(_needed_capacity)) {
  453. C->_capacity=_needed_capacity;
  454. C->_storage=calloc((((T381*)C))->_capacity/*8*/,sizeof(T0*));
  455. }
  456. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  457. r729copy_from((((T381*)C))->_storage/*4*/,(((T381*)((T381*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  458. }
  459. /*FI*/}
  460. /*No:ARRAY[MANIFEST_STRING].lower*/
  461. /*No:ARRAY[MANIFEST_STRING].put*/
  462. /*No:ARRAY[MANIFEST_STRING].upper*/
  463. int r381count(T381* C){
  464. int R=0;
  465. R=(((((T381*)C))->_upper/*12*/)-((((T381*)C))->_lower/*16*/))+(1);
  466. return R;
  467. }
  468. void r381add_last(T381* C,T0* a1){
  469. int _new_capacity=0;
  470. /*IF*/if (((((T381*)C))->_capacity/*8*/)<((r381count(C))+(1))) {
  471. /*IF*/if (((((T381*)C))->_capacity/*8*/)==(0)) {
  472. C->_capacity=16;
  473. C->_storage=calloc((((T381*)C))->_capacity/*8*/,sizeof(T0*));
  474. }
  475. else {
  476. _new_capacity=(2)*((((T381*)C))->_capacity/*8*/);
  477. C->_storage=r729realloc((((T381*)C))->_storage/*4*/,(((T381*)C))->_capacity/*8*/,_new_capacity);
  478. C->_capacity=_new_capacity;
  479. }
  480. /*FI*/}
  481. /*FI*/C->_upper=((((T381*)C))->_upper/*12*/)+(1);
  482. /*[IRF3.6put*/{T381* C1=C;
  483. T0* b1=a1;
  484. int b2=(((T381*)C))->_upper/*12*/;
  485. ((((T381*)C1))->_storage/*4*/)[(b2)-((((T381*)C1))->_lower/*16*/)]=(b1);
  486. }/*]*/
  487. }
  488. T0* r381first(T381* C){
  489. T0* R=NULL;
  490. R=r381item(C,(((T381*)C))->_lower/*16*/);
  491. return R;
  492. }
  493. /*No:ARRAY[FEATURE_NAME].clear_all*/
  494. /*No:ARRAY[FEATURE_NAME].set_all_with*/
  495. void r855make(T855* C,int a1,int a2){
  496. int _needed=0;
  497. C->_lower=a1;
  498. C->_upper=a2;
  499. _needed=((a2)-(a1))+(1);
  500. /*IF*/if ((_needed)>(0)) {
  501. /*IF*/if (((((T855*)C))->_capacity/*4*/)<(_needed)) {
  502. /*IF*/if (((((T855*)C))->_capacity/*4*/)==(0)) {
  503. C->_storage=calloc(_needed,sizeof(T0*));
  504. }
  505. else {
  506. C->_storage=calloc(_needed,sizeof(T0*));
  507. }
  508. /*FI*/C->_capacity=_needed;
  509. }
  510. else {
  511. /*[IRF3.6clear_all*/{T855* C1=C;
  512. T0* __value=NULL;
  513. /*[IRF3.6set_all_with*/{T855* C2=C1;
  514. T0* c1=__value;
  515. r175set_all_with((((T855*)C2))->_storage/*0*/,c1,((((T855*)C2))->_upper/*8*/)-((((T855*)C2))->_lower/*12*/));
  516. }/*]*/
  517. }/*]*/
  518. }
  519. /*FI*/}
  520. /*FI*/}
  521. T0* r855item(T855* C,int a1){
  522. T0* R=NULL;
  523. R=((((T855*)C))->_storage/*0*/)[(a1)-((((T855*)C))->_lower/*12*/)];
  524. return R;
  525. }
  526. void r855clear(T855* C){
  527. C->_upper=((((T855*)C))->_lower/*12*/)-(1);
  528. }
  529. /*No:ARRAY[FEATURE_NAME].storage*/
  530. T0* r855twin(T855* C){
  531. T0* R=NULL;
  532. R=malloc(sizeof(*C));
  533. *((T855*)R)=M855;
  534. r855copy(((T855*)R),((T0*)C));
  535. return R;
  536. }
  537. /*No:ARRAY[FEATURE_NAME].capacity*/
  538. void r855copy(T855* C,T0* a1){
  539. int _needed_capacity=0;
  540. C->_lower=(((T855*)((T855*)a1)))->_lower/*12*/;
  541. C->_upper=(((T855*)((T855*)a1)))->_upper/*8*/;
  542. _needed_capacity=(((((T855*)C))->_upper/*8*/)-((((T855*)C))->_lower/*12*/))+(1);
  543. /*IF*/if (((((T855*)C))->_capacity/*4*/)<(_needed_capacity)) {
  544. C->_capacity=_needed_capacity;
  545. C->_storage=calloc((((T855*)C))->_capacity/*4*/,sizeof(T0*));
  546. }
  547. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  548. r175copy_from((((T855*)C))->_storage/*0*/,(((T855*)((T855*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  549. }
  550. /*FI*/}
  551. /*No:ARRAY[FEATURE_NAME].lower*/
  552. /*No:ARRAY[FEATURE_NAME].put*/
  553. /*No:ARRAY[FEATURE_NAME].upper*/
  554. int r855count(T855* C){
  555. int R=0;
  556. R=(((((T855*)C))->_upper/*8*/)-((((T855*)C))->_lower/*12*/))+(1);
  557. return R;
  558. }
  559. void r855add_last(T855* C,T0* a1){
  560. int _new_capacity=0;
  561. /*IF*/if (((((T855*)C))->_capacity/*4*/)<((r855count(C))+(1))) {
  562. /*IF*/if (((((T855*)C))->_capacity/*4*/)==(0)) {
  563. C->_capacity=16;
  564. C->_storage=calloc((((T855*)C))->_capacity/*4*/,sizeof(T0*));
  565. }
  566. else {
  567. _new_capacity=(2)*((((T855*)C))->_capacity/*4*/);
  568. C->_storage=r175realloc((((T855*)C))->_storage/*0*/,(((T855*)C))->_capacity/*4*/,_new_capacity);
  569. C->_capacity=_new_capacity;
  570. }
  571. /*FI*/}
  572. /*FI*/C->_upper=((((T855*)C))->_upper/*8*/)+(1);
  573. /*[IRF3.6put*/{T855* C1=C;
  574. T0* b1=a1;
  575. int b2=(((T855*)C))->_upper/*8*/;
  576. ((((T855*)C1))->_storage/*0*/)[(b2)-((((T855*)C1))->_lower/*12*/)]=(b1);
  577. }/*]*/
  578. }
  579. T0* r855first(T855* C){
  580. T0* R=NULL;
  581. R=r855item(C,(((T855*)C))->_lower/*12*/);
  582. return R;
  583. }
  584.  
  585.