home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ppcsmalleiffel / source.lha / bin_c / compile_to_jvm5.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  13.0 KB  |  538 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. void r705copy_from(T705 C,T705 a1,int a2){
  10. int _i=0;
  11. _i=a2;
  12. while (!((_i)<(0))) {
  13. (C)[_i]=((a1)[_i]);
  14. _i=(_i)-(1);
  15. }
  16. }
  17. T705 r705realloc(T705 C,int a1,int a2){
  18. T705 R=NULL;
  19. R=calloc(a2,sizeof(T0*));
  20. r705copy_from(R,C,(a1)-(1));
  21. return R;
  22. }
  23. void r513copy_from(T513 C,T513 a1,int a2){
  24. int _i=0;
  25. _i=a2;
  26. while (!((_i)<(0))) {
  27. (C)[_i]=((a1)[_i]);
  28. _i=(_i)-(1);
  29. }
  30. }
  31. T513 r513realloc(T513 C,int a1,int a2){
  32. T513 R=NULL;
  33. R=calloc(a2,sizeof(T0*));
  34. r513copy_from(R,C,(a1)-(1));
  35. return R;
  36. }
  37. void r221copy_from(T221 C,T221 a1,int a2){
  38. int _i=0;
  39. _i=a2;
  40. while (!((_i)<(0))) {
  41. (C)[_i]=((a1)[_i]);
  42. _i=(_i)-(1);
  43. }
  44. }
  45. T221 r221realloc(T221 C,int a1,int a2){
  46. T221 R=NULL;
  47. R=calloc(a2,sizeof(T0*));
  48. r221copy_from(R,C,(a1)-(1));
  49. return R;
  50. }
  51. void r686clear_all(T686 C,int a1){
  52. int _i=0;
  53. int _v=0;
  54. _i=a1;
  55. while (!((_i)<(0))) {
  56. (C)[_i]=(_v);
  57. _i=(_i)-(1);
  58. }
  59. }
  60. void r686set_all_with(T686 C,int a1,int a2){
  61. int _i=0;
  62. _i=a2;
  63. while (!((_i)<(0))) {
  64. (C)[_i]=(a1);
  65. _i=(_i)-(1);
  66. }
  67. }
  68. int r686fast_index_of(T686 C,int a1,int a2){
  69. int R=0;
  70. while (!(((R)>(a2))||((a1)==((C)[R])))) {
  71. R=(R)+(1);
  72. }
  73. return R;
  74. }
  75. void r686copy_from(T686 C,T686 a1,int a2){
  76. int _i=0;
  77. _i=a2;
  78. while (!((_i)<(0))) {
  79. (C)[_i]=((a1)[_i]);
  80. _i=(_i)-(1);
  81. }
  82. }
  83. T686 r686realloc(T686 C,int a1,int a2){
  84. T686 R=NULL;
  85. R=calloc(a2,sizeof(int));
  86. r686copy_from(R,C,(a1)-(1));
  87. return R;
  88. }
  89. void r857set_all_with(T857 C,T0* a1,int a2){
  90. int _i=0;
  91. _i=a2;
  92. while (!((_i)<(0))) {
  93. (C)[_i]=(a1);
  94. _i=(_i)-(1);
  95. }
  96. }
  97. void r857copy_from(T857 C,T857 a1,int a2){
  98. int _i=0;
  99. _i=a2;
  100. while (!((_i)<(0))) {
  101. (C)[_i]=((a1)[_i]);
  102. _i=(_i)-(1);
  103. }
  104. }
  105. T857 r857realloc(T857 C,int a1,int a2){
  106. T857 R=NULL;
  107. R=calloc(a2,sizeof(T0*));
  108. r857copy_from(R,C,(a1)-(1));
  109. return R;
  110. }
  111. void r44copy_from(T44 C,T44 a1,int a2){
  112. int _i=0;
  113. _i=a2;
  114. while (!((_i)<(0))) {
  115. (C)[_i]=((a1)[_i]);
  116. _i=(_i)-(1);
  117. }
  118. }
  119. T44 r44realloc(T44 C,int a1,int a2){
  120. T44 R=NULL;
  121. R=calloc(a2,sizeof(T0*));
  122. r44copy_from(R,C,(a1)-(1));
  123. return R;
  124. }
  125. void r191copy_from(T191 C,T191 a1,int a2){
  126. int _i=0;
  127. _i=a2;
  128. while (!((_i)<(0))) {
  129. (C)[_i]=((a1)[_i]);
  130. _i=(_i)-(1);
  131. }
  132. }
  133. T191 r191realloc(T191 C,int a1,int a2){
  134. T191 R=NULL;
  135. R=calloc(a2,sizeof(T0*));
  136. r191copy_from(R,C,(a1)-(1));
  137. return R;
  138. }
  139. void r7add_first(T7* C,char a1){
  140. int _i=0;
  141. r7extend(C,'\40');
  142. _i=(((T7*)C))->_count/*4*/;
  143. while (!((_i)==(1))) {
  144. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]=(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[((_i)-(1))-(1)]/*)*/);
  145. /*]*/
  146. _i=(_i)-(1);
  147. }
  148. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(1)-(1)]=(a1);
  149. /*]*/
  150. }
  151. void r7extend(T7* C,char a1){
  152. int _new_capacity=0;
  153. /*IF*/if (((((T7*)C))->_capacity/*8*/)>((((T7*)C))->_count/*4*/)) {
  154. }
  155.  else if (((((T7*)C))->_capacity/*8*/)==(0)) {
  156. C->_capacity=32;
  157. C->_storage=calloc((((T7*)C))->_capacity/*8*/,sizeof(char));
  158. }
  159. else {
  160. _new_capacity=(2)*((((T7*)C))->_capacity/*8*/);
  161. C->_storage=r9realloc((((T7*)C))->_storage/*0*/,(((T7*)C))->_capacity/*8*/,_new_capacity);
  162. C->_capacity=_new_capacity;
  163. }
  164. /*FI*/C->_count=((((T7*)C))->_count/*4*/)+(1);
  165. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[((((T7*)C))->_count/*4*/)-(1)]=(a1);
  166. /*]*/
  167. }
  168. void r7set_last(T7* C,char a1){
  169. /*IF*/if ((((((T7*)C))->_count/*4*/)==(0))||((/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[((((T7*)C))->_count/*4*/)-(1)]/*)*/)!=(a1))) {
  170. r7extend(C,a1);
  171. }
  172. /*FI*/}
  173. /*No:STRING.remove_suffix*/
  174. int r7hash_code(T7* C){
  175. int R=0;
  176. R=r9hashcode((((T7*)C))->_storage/*0*/,((((T7*)C))->_count/*4*/)-(1));
  177. return R;
  178. }
  179. void r7to_lower(T7* C){
  180. int _i=0;
  181. _i=(((T7*)C))->_count/*4*/;
  182. while (!((_i)==(0))) {
  183. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]=(r3to_lower(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]/*)*/));
  184. /*]*/
  185. _i=(_i)-(1);
  186. }
  187. }
  188. /*No:STRING.empty*/
  189. int r7index_of_string(T7* C,T0* a1){
  190. int R=0;
  191. int _i3=0;
  192. int _i2=0;
  193. int _i1=0;
  194. int _stop=0;
  195. _i1=1;
  196. _i2=(((T7*)((T7*)a1)))->_count/*4*/;
  197. _i3=_i2;
  198. while (!((R)!=(0))) {
  199. /*IF*/if ((_i2)>((((T7*)C))->_count/*4*/)) {
  200. R=((((T7*)C))->_count/*4*/)+(1);
  201. }
  202. else {
  203. _stop=0;
  204. while (!(_stop)) {
  205. /*IF*/if ((_i3)==(0)) {
  206. _stop=1;
  207. R=_i1;
  208. }
  209.  else if ((/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(_i3)-(1)]/*)*/)!=(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_i2)-(1)]/*)*/)) {
  210. _stop=1;
  211. }
  212. /*FI*/_i3=(_i3)-(1);
  213. _i2=(_i2)-(1);
  214. }
  215. }
  216. /*FI*/_i1=(_i1)+(1);
  217. _i3=(((T7*)((T7*)a1)))->_count/*4*/;
  218. _i2=((_i1)+(_i3))-(1);
  219. }
  220. return R;
  221. }
  222. int r7_px_60(T7* C,T0* a1){
  223. int R=0;
  224. int _i=0;
  225. _i=1;
  226. while (!(((((((T7*)C))->_count/*4*/)<(_i))||(((((T7*)((T7*)a1)))->_count/*4*/)<(_i)))||((/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]/*)*/)!=(/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(_i)-(1)]/*)*/)))) {
  227. _i=(_i)+(1);
  228. }
  229. /*IF*/if (((((T7*)C))->_count/*4*/)<(_i)) {
  230. R=((((T7*)((T7*)a1)))->_count/*4*/)>=(_i);
  231. }
  232.  else if (((((T7*)((T7*)a1)))->_count/*4*/)<(_i)) {
  233. R=0;
  234. }
  235. else {
  236. R=(((unsigned)(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]/*)*/))<((unsigned)(/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(_i)-(1)]/*)*/)));
  237. }
  238. /*FI*/return R;
  239. }
  240. void r7make(T7* C,int a1){
  241. /*IF*/if ((a1)>(0)) {
  242. /*IF*/if (((((T7*)C))->_capacity/*8*/)<(a1)) {
  243. C->_storage=calloc(a1,sizeof(char));
  244. C->_capacity=a1;
  245. }
  246. /*FI*/}
  247. /*FI*/C->_count=0;
  248. }
  249. void* r7to_external(T7* C){
  250. void* R=0;
  251. /*IF*/if (((((T7*)C))->_capacity/*8*/)>((((T7*)C))->_count/*4*/)) {
  252. C->_count=((((T7*)C))->_count/*4*/)+(1);
  253. /*IF*/if ((/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[((((T7*)C))->_count/*4*/)-(1)]/*)*/)!=('\0')) {
  254. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[((((T7*)C))->_count/*4*/)-(1)]=('\0');
  255. /*]*/
  256. }
  257. /*FI*/}
  258. else {
  259. r7extend(C,'\0');
  260. }
  261. /*FI*/C->_count=((((T7*)C))->_count/*4*/)-(1);
  262. R=((void*)(((T7*)C))->_storage/*0*/);
  263. return R;
  264. }
  265. /*No:STRING.item*/
  266. int r7has_string(T7* C,T0* a1){
  267. int R=0;
  268. R=(r7index_of_string(C,a1))!=(((((T7*)C))->_count/*4*/)+(1));
  269. return R;
  270. }
  271. /*No:STRING.clear*/
  272. /*No:STRING.storage*/
  273. T0* r7twin(T7* C){
  274. T0* R=NULL;
  275. R=malloc(sizeof(*C));
  276. *((T7*)R)=M7;
  277. r7copy(((T7*)R),((T0*)C));
  278. return R;
  279. }
  280. int r7is_equal(T7* C,T0* a1){
  281. int R=0;
  282. /*IF*/if ((C)==((void*)(a1))) {
  283. R=1;
  284. }
  285.  else if (((((T7*)C))->_count/*4*/)==((((T7*)((T7*)a1)))->_count/*4*/)) {
  286. /*IF*/if (((((T7*)C))->_count/*4*/)>(0)) {
  287. R=r9fast_memcmp((((T7*)C))->_storage/*0*/,(((T7*)((T7*)a1)))->_storage/*0*/,(((T7*)C))->_count/*4*/);
  288. }
  289. else {
  290. R=1;
  291. }
  292. /*FI*/}
  293. /*FI*/return R;
  294. }
  295. void r7swap(T7* C,int a1,int a2){
  296. char _tmp=0;
  297. _tmp=/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(a1)-(1)]/*)*/;
  298. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(a1)-(1)]=(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(a2)-(1)]/*)*/);
  299. /*]*/
  300. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(a2)-(1)]=(_tmp);
  301. /*]*/
  302. }
  303. char r7last(T7* C){
  304. char R=0;
  305. R=/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[((((T7*)C))->_count/*4*/)-(1)]/*)*/;
  306. return R;
  307. }
  308. /*No:STRING.capacity*/
  309. int r7has_suffix(T7* C,T0* a1){
  310. int R=0;
  311. int _i2=0;
  312. int _i1=0;
  313. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)<=((((T7*)C))->_count/*4*/)) {
  314. _i1=(((((T7*)C))->_count/*4*/)-((((T7*)((T7*)a1)))->_count/*4*/))+(1);
  315. _i2=1;
  316. while (!((((_i1)>((((T7*)C))->_count/*4*/))||((_i2)>((((T7*)((T7*)a1)))->_count/*4*/)))||((/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_i1)-(1)]/*)*/)!=(/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(_i2)-(1)]/*)*/)))) {
  317. _i1=(_i1)+(1);
  318. _i2=(_i2)+(1);
  319. }
  320. R=(_i1)>((((T7*)C))->_count/*4*/);
  321. }
  322. /*FI*/return R;
  323. }
  324. int r7has(T7* C,char a1){
  325. int R=0;
  326. R=(r7index_of(C,a1))!=(((((T7*)C))->_count/*4*/)+(1));
  327. return R;
  328. }
  329. void r7copy(T7* C,T0* a1){
  330. C->_count=(((T7*)((T7*)a1)))->_count/*4*/;
  331. /*IF*/if (((((T7*)C))->_count/*4*/)>(0)) {
  332. /*IF*/if (((((T7*)C))->_capacity/*8*/)<((((T7*)C))->_count/*4*/)) {
  333. C->_storage=calloc((((T7*)C))->_count/*4*/,sizeof(char));
  334. C->_capacity=(((T7*)C))->_count/*4*/;
  335. }
  336. /*FI*/r9copy_from((((T7*)C))->_storage/*0*/,(((T7*)((T7*)a1)))->_storage/*0*/,((((T7*)C))->_count/*4*/)-(1));
  337. }
  338. /*FI*/}
  339. int r7same_as(T7* C,T0* a1){
  340. int R=0;
  341. int _i=0;
  342. /*IF*/if ((a1)==((void*)(C))) {
  343. R=1;
  344. }
  345. else {
  346. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)!=((((T7*)C))->_count/*4*/)) {
  347. }
  348. else {
  349. _i=(((T7*)C))->_count/*4*/;
  350. while (!(((_i)==(0))||(!(r3same_as(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]/*)*/,/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(_i)-(1)]/*)*/))))) {
  351. _i=(_i)-(1);
  352. }
  353. R=(_i)==(0);
  354. }
  355. /*FI*/}
  356. /*FI*/return R;
  357. }
  358. /*No:STRING.put*/
  359. void r7prepend(T7* C,T0* a1){
  360. int _old_count=0;
  361. int _i=0;
  362. _old_count=(((T7*)C))->_count/*4*/;
  363. _i=(((T7*)((T7*)a1)))->_count/*4*/;
  364. while (!((_i)==(0))) {
  365. r7extend(C,'\40');
  366. _i=(_i)-(1);
  367. }
  368. _i=(((T7*)C))->_count/*4*/;
  369. while (!((_old_count)==(0))) {
  370. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]=(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_old_count)-(1)]/*)*/);
  371. /*]*/
  372. _i=(_i)-(1);
  373. _old_count=(_old_count)-(1);
  374. }
  375. _i=(((T7*)((T7*)a1)))->_count/*4*/;
  376. while (!((_i)==(0))) {
  377. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]=(/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(_i)-(1)]/*)*/);
  378. /*]*/
  379. _i=(_i)-(1);
  380. }
  381. }
  382. /*No:STRING.count*/
  383. void r7to_upper(T7* C){
  384. int _i=0;
  385. _i=(((T7*)C))->_count/*4*/;
  386. while (!((_i)==(0))) {
  387. /*[IRF3.5put*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]=(r3to_upper(/*(IRF4.6item*/((((T7*)C))->_storage/*0*/)[(_i)-(1)]/*)*/));
  388. /*]*/
  389. _i=(_i)-(1);
  390. }
  391. }
  392. void r7remove_last(T7* C,int a1){
  393. C->_count=((((T7*)C))->_count/*4*/)-(a1);
  394. }
  395. /*No:STRING.first*/
  396. int r7index_of(T7* C,char a1){
  397. int R=0;
  398. R=(1)+(r9fast_index_of((((T7*)C))->_storage/*0*/,a1,((((T7*)C))->_count/*4*/)-(1)));
  399. return R;
  400. }
  401. void r7append(T7* C,T0* a1){
  402. int _i=0;
  403. _i=1;
  404. while (!((_i)>((((T7*)((T7*)a1)))->_count/*4*/))) {
  405. r7extend(C,/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(_i)-(1)]/*)*/);
  406. _i=(_i)+(1);
  407. }
  408. }
  409. /*No:ARRAY[INTEGER_CONSTANT].clear_all*/
  410. /*No:ARRAY[INTEGER_CONSTANT].set_all_with*/
  411. void r28make(T28* C,int a1,int a2){
  412. int _needed=0;
  413. C->_lower=a1;
  414. C->_upper=a2;
  415. _needed=((a2)-(a1))+(1);
  416. /*IF*/if ((_needed)>(0)) {
  417. /*IF*/if (((((T28*)C))->_capacity/*8*/)<(_needed)) {
  418. /*IF*/if (((((T28*)C))->_capacity/*8*/)==(0)) {
  419. C->_storage=calloc(_needed,sizeof(T0*));
  420. }
  421. else {
  422. C->_storage=calloc(_needed,sizeof(T0*));
  423. }
  424. /*FI*/C->_capacity=_needed;
  425. }
  426. else {
  427. /*[IRF3.6clear_all*/{T28* C1=C;
  428. T0* __value=NULL;
  429. /*[IRF3.6set_all_with*/{T28* C2=C1;
  430. T0* c1=__value;
  431. r392set_all_with((((T28*)C2))->_storage/*4*/,c1,((((T28*)C2))->_upper/*12*/)-((((T28*)C2))->_lower/*16*/));
  432. }/*]*/
  433. }/*]*/
  434. }
  435. /*FI*/}
  436. /*FI*/}
  437. T0* r28item(T28* C,int a1){
  438. T0* R=NULL;
  439. R=((((T28*)C))->_storage/*4*/)[(a1)-((((T28*)C))->_lower/*16*/)];
  440. return R;
  441. }
  442. /*No:ARRAY[INTEGER_CONSTANT].storage*/
  443. T0* r28twin(T28* C){
  444. T0* R=NULL;
  445. R=malloc(sizeof(*C));
  446. *((T28*)R)=M28;
  447. r28copy(((T28*)R),((T0*)C));
  448. return R;
  449. }
  450. /*No:ARRAY[INTEGER_CONSTANT].capacity*/
  451. void r28copy(T28* C,T0* a1){
  452. int _needed_capacity=0;
  453. C->_lower=(((T28*)((T28*)a1)))->_lower/*16*/;
  454. C->_upper=(((T28*)((T28*)a1)))->_upper/*12*/;
  455. _needed_capacity=(((((T28*)C))->_upper/*12*/)-((((T28*)C))->_lower/*16*/))+(1);
  456. /*IF*/if (((((T28*)C))->_capacity/*8*/)<(_needed_capacity)) {
  457. C->_capacity=_needed_capacity;
  458. C->_storage=calloc((((T28*)C))->_capacity/*8*/,sizeof(T0*));
  459. }
  460. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  461. r392copy_from((((T28*)C))->_storage/*4*/,(((T28*)((T28*)a1)))->_storage/*4*/,(_needed_capacity)-(1));
  462. }
  463. /*FI*/}
  464. /*No:ARRAY[INTEGER_CONSTANT].lower*/
  465. /*No:ARRAY[INTEGER_CONSTANT].put*/
  466. /*No:ARRAY[INTEGER_CONSTANT].upper*/
  467. void r28add_last(T28* C,T0* a1){
  468. int _new_capacity=0;
  469. /*IF*/if (((((T28*)C))->_capacity/*8*/)<((r28count(C))+(1))) {
  470. /*IF*/if (((((T28*)C))->_capacity/*8*/)==(0)) {
  471. C->_capacity=16;
  472. C->_storage=calloc((((T28*)C))->_capacity/*8*/,sizeof(T0*));
  473. }
  474. else {
  475. _new_capacity=(2)*((((T28*)C))->_capacity/*8*/);
  476. C->_storage=r392realloc((((T28*)C))->_storage/*4*/,(((T28*)C))->_capacity/*8*/,_new_capacity);
  477. C->_capacity=_new_capacity;
  478. }
  479. /*FI*/}
  480. /*FI*/C->_upper=((((T28*)C))->_upper/*12*/)+(1);
  481. /*[IRF3.6put*/{T28* C1=C;
  482. T0* b1=a1;
  483. int b2=(((T28*)C))->_upper/*12*/;
  484. ((((T28*)C1))->_storage/*4*/)[(b2)-((((T28*)C1))->_lower/*16*/)]=(b1);
  485. }/*]*/
  486. }
  487. int r28count(T28* C){
  488. int R=0;
  489. R=(((((T28*)C))->_upper/*12*/)-((((T28*)C))->_lower/*16*/))+(1);
  490. return R;
  491. }
  492. T0* r28first(T28* C){
  493. T0* R=NULL;
  494. R=r28item(C,(((T28*)C))->_lower/*16*/);
  495. return R;
  496. }
  497. T0* r235item(T235* C,int a1){
  498. T0* R=NULL;
  499. R=((((T235*)C))->_storage/*0*/)[(a1)-((((T235*)C))->_lower/*12*/)];
  500. return R;
  501. }
  502. /*No:ARRAY[CREATION_CLAUSE].storage*/
  503. /*No:ARRAY[CREATION_CLAUSE].capacity*/
  504. /*No:ARRAY[CREATION_CLAUSE].lower*/
  505. /*No:ARRAY[CREATION_CLAUSE].put*/
  506. /*No:ARRAY[CREATION_CLAUSE].upper*/
  507. int r235count(T235* C){
  508. int R=0;
  509. R=(((((T235*)C))->_upper/*8*/)-((((T235*)C))->_lower/*12*/))+(1);
  510. return R;
  511. }
  512. void r235add_last(T235* C,T0* a1){
  513. int _new_capacity=0;
  514. /*IF*/if (((((T235*)C))->_capacity/*4*/)<((r235count(C))+(1))) {
  515. /*IF*/if (((((T235*)C))->_capacity/*4*/)==(0)) {
  516. C->_capacity=16;
  517. C->_storage=calloc((((T235*)C))->_capacity/*4*/,sizeof(T0*));
  518. }
  519. else {
  520. _new_capacity=(2)*((((T235*)C))->_capacity/*4*/);
  521. C->_storage=r513realloc((((T235*)C))->_storage/*0*/,(((T235*)C))->_capacity/*4*/,_new_capacity);
  522. C->_capacity=_new_capacity;
  523. }
  524. /*FI*/}
  525. /*FI*/C->_upper=((((T235*)C))->_upper/*8*/)+(1);
  526. /*[IRF3.6put*/{T235* C1=C;
  527. T0* b1=a1;
  528. int b2=(((T235*)C))->_upper/*8*/;
  529. ((((T235*)C1))->_storage/*0*/)[(b2)-((((T235*)C1))->_lower/*12*/)]=(b1);
  530. }/*]*/
  531. }
  532. T0* r235first(T235* C){
  533. T0* R=NULL;
  534. R=r235item(C,(((T235*)C))->_lower/*12*/);
  535. return R;
  536. }
  537.  
  538.