home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / ppcsmalleiffel / lib_show / external / jvm / example11.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  25.6 KB  |  1,119 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.84)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "example1.h"
  10. char tag_pos_1[]="assignment";
  11. char tag_pos_2[]="boolean exp.";
  12. char tag_pos_3[]="instruction";
  13. char tag_pos_4[]="assertion";
  14. char tag_pos_5[]="creation call";
  15. char tag_pos_6[]="variant exp.";
  16. char Current[]="Current";
  17. char Result[]="Result";
  18. double*rs_bot;
  19. double*rs;
  20. double*rs_lb;
  21. double*rs_top;
  22. void se_rsg(int sz){
  23. if(rs+sz<rs_top)return;
  24. {int osz=(rs_top-rs_bot+1);
  25. int nsz;
  26. double*nrs_bot;
  27. int msz=262144;
  28. nsz=osz*2;
  29. nrs_bot=(void*)malloc(nsz*sizeof(double));
  30. if((osz>msz)||(nrs_bot==NULL)){
  31. printf("Stack Overflow (limit = %d).\n",msz);
  32. rsp();if(!se_rspf)exit(0);}
  33. ((void)memcpy(nrs_bot,rs_bot,osz*sizeof(double)));
  34. rs_lb=nrs_bot+(rs_lb-rs_bot);
  35. rs=nrs_bot+(rs-rs_bot);
  36. rs_top=nrs_bot+(nsz-1);
  37. free(rs_bot);
  38. rs_bot=nrs_bot;
  39. return;}}
  40. void rs_link(char*tag){
  41. se_rsg(1024);
  42. *((int*)rs++)=LINKid;
  43. *((int*)rs)=(rs-rs_lb);
  44. rs_lb=rs++;
  45. *((int*)rs++)=FTAGid;
  46. *((char**)rs++)=tag;}
  47. void rs_unlink(void){
  48. rs=rs_lb-1;
  49. rs_lb=rs_lb-(*((int*)rs_lb));}
  50. void rs_pPOS(char* tp,int l,int c,int f){
  51. *((int*)rs++)=LINEid;
  52. *((int*)rs++)=l;
  53. *((int*)rs++)=COLUMNid;
  54. *((int*)rs++)=c;
  55. *((int*)rs++)=PATHid;
  56. *((int*)rs++)=f;
  57. *((int*)rs++)=DOINGid;
  58. *((char**)rs++)=tp;}
  59. int rs_pop_int(int e){
  60. rs-=8;
  61. return e;}
  62. void rs_pINT(int*i,char*n){
  63. *((int*)rs++)=NAMEid;
  64. *((char**)rs++)=n;
  65. *((int*)rs++)=INTEGERid;
  66. *((int**)rs++)=i;}
  67. void rs_pCHA(char*c,char*n){
  68. *((int*)rs++)=NAMEid;
  69. *((char**)rs++)=n;
  70. *((int*)rs++)=CHARACTERid;
  71. *((char**)rs++)=c;}
  72. void rs_pBOO(int*b,char*n){
  73. *((int*)rs++)=NAMEid;
  74. *((char**)rs++)=n;
  75. *((int*)rs++)=BOOLEANid;
  76. *((int**)rs++)=b;}
  77. void rs_pREA(float*r,char*n){
  78. *((int*)rs++)=NAMEid;
  79. *((char**)rs++)=n;
  80. *((int*)rs++)=REALid;
  81. *((float**)rs++)=r;}
  82. void rs_pDOU(double*d,char*n){
  83. *((int*)rs++)=NAMEid;
  84. *((char**)rs++)=n;
  85. *((int*)rs++)=DOUBLEid;
  86. *((double**)rs++)=d;}
  87. void rs_pPOI(void*p,char*n){
  88. *((int*)rs++)=NAMEid;
  89. *((char**)rs++)=n;
  90. *((int*)rs++)=POINTERid;
  91. *((void**)rs++)=p;}
  92. void rs_pBIT(void*p,char*n){
  93. *((int*)rs++)=NAMEid;
  94. *((char**)rs++)=n;
  95. *((int*)rs++)=BITid;
  96. *((void**)rs++)=p;}
  97. void rs_pREF(void**r,char*n){
  98. *((int*)rs++)=NAMEid;
  99. *((char**)rs++)=n;
  100. *((int*)rs++)=REFid;
  101. *((void***)rs++)=r;}
  102. void rs_pEXP(void*e,char*n){
  103. *((int*)rs++)=NAMEid;
  104. *((char**)rs++)=n;
  105. *((int*)rs++)=expandedid;
  106. *((void**)rs++)=e;}
  107. int se_af=0;
  108. int se_rspf=0;
  109. int se_af_rlc;
  110. int se_af_rlr;
  111. void ac_req(int v){
  112. if (!v && se_af_rlc)
  113. error0("Require Assertion Violated.");
  114. se_af_rlr=se_af_rlr&&v;
  115. rs-=8;}
  116. void ac_ens(int v){
  117. if (!v) error0("Ensure Assertion Violated.");
  118. rs-=8;}
  119. void ac_inv(int v){
  120. if (!v) error0("Class Invariant Violation.");
  121. rs-=8;}
  122. int se_rciaux(double* sp){
  123. if((*((char**)sp))!=Current) return 0;sp++; if((*((int*)sp))!=REFid) return 0;return 1;}
  124. int se_rci(void*C){
  125. double*lb=rs_lb;
  126. double*sp;
  127. if(se_af)return 0;
  128. if(se_rspf)return 0;
  129. while(1){
  130. if(lb==rs_bot)return 0;
  131. sp=lb+4;
  132. if(se_rciaux(sp)){
  133. sp+=2;
  134. if((**((void***)sp))==C)break;}
  135. lb=lb-(*((int*)lb));}
  136. while(1){
  137. lb=lb-(*((int*)lb));
  138. if(lb==rs_bot)return 1;
  139. sp=lb+4;
  140. if(se_rciaux(sp)){
  141. sp+=2;
  142. if((**((void***)sp))==C)return 0;}}}
  143. void ac_liv(int v){
  144. if (!v) error0("Loop Invariant Violation.");
  145. rs-=8;}
  146. int lvc(int lc,int lv1,int lv2){
  147. if (lc==0){if (lv2 < 0){
  148. rsp();
  149. printf("Bad First Variant Value = %d\n",lv2);}
  150. else {rs-=8;return lv2;}}
  151. else if ((lv2 < 0)||(lv2 >= lv1)){
  152. rsp();
  153. printf("Loop Body Count = %d (done)\nNew Variant = %d\nPrevious Variant = %d\n",lc,lv2,lv1);}
  154. else {rs-=8;return lv2;}
  155. printf("*** Error at Run Time *** : Bad Loop Variant.\n");
  156. if(!se_rspf)exit(1);}
  157. void ac_civ(int v){
  158. if (!v) error0("Check Assertion Violated.");
  159. rs-=8;}
  160. void rT2append_in(int C,T0* a1){
  161. int _i=0;
  162. int _val=0;
  163. rs_link("append_in of INTEGER");
  164. rs_pINT(&C,Current);
  165. rs_pREF((void**)&a1,"str");
  166. rs_pINT(&_val,"val");
  167. rs_pINT(&_i,"i");
  168. se_af_rlc=1;
  169. if(!se_af){se_af=1;
  170. rs_pPOS(tag_pos_4,192,7,2);
  171. ac_req((a1)!=(((void*)NULL)));
  172. se_af=0;}
  173. /*IF*/if (rs_pPOS(tag_pos_2,196,14,2),rs_pop_int((C)==(0))) {
  174. rs_pPOS(tag_pos_3,197,10,2);
  175. rT7extend(ivT7(((T7*)ci(7,a1,197,6,2))),'0');
  176. rs-=8;
  177. }
  178. else {
  179. /*IF*/if (rs_pPOS(tag_pos_2,199,17,2),rs_pop_int((C)>(0))) {
  180. rs_pPOS(tag_pos_1,201,5,2);
  181. _i=((((T7*)ivT7(((T7*)ci(7,a1,201,10,2)))))->_count/*W3*/)+(1);
  182. rs-=8;
  183. _val=C;
  184. while (!(rs_pPOS(tag_pos_2,204,9,2),rs_pop_int((_val)==(0)))) {
  185. rs_pPOS(tag_pos_3,206,9,2);
  186. rT7extend(ivT7(((T7*)ci(7,a1,206,5,2))),rT2digit((_val)%(10)));
  187. rs-=8;
  188. _val=(_val)/(10);
  189. }
  190. }
  191. else {
  192. rs_pPOS(tag_pos_3,210,13,2);
  193. rT7extend(ivT7(((T7*)ci(7,a1,210,9,2))),'\55');
  194. rs-=8;
  195. rs_pPOS(tag_pos_1,212,5,2);
  196. _i=((((T7*)ivT7(((T7*)ci(7,a1,212,10,2)))))->_count/*W3*/)+(1);
  197. rs-=8;
  198. _val=C;
  199. while (!(rs_pPOS(tag_pos_2,215,9,2),rs_pop_int((_val)==(0)))) {
  200. rs_pPOS(tag_pos_3,217,9,2);
  201. rT7extend(ivT7(((T7*)ci(7,a1,217,5,2))),rT2digit(-((_val)%(10))));
  202. rs-=8;
  203. _val=(_val)/(10);
  204. }
  205. }
  206. /*FI*/_val=(((T7*)ivT7(((T7*)ci(7,a1,222,16,2)))))->_count/*W3*/;
  207. while (!(rs_pPOS(tag_pos_2,224,11,2),rs_pop_int((_i)>=(_val)))) {
  208. rs_pPOS(tag_pos_3,226,13,2);
  209. rT7swap(ivT7(((T7*)ci(7,a1,226,9,2))),_i,_val);
  210. rs-=8;
  211. _val=(_val)-(1);
  212. _i=(_i)+(1);
  213. }
  214. }
  215. /*FI*/rs_unlink();
  216. }
  217. int ofBC1tagged_out_memory=0;
  218. T0*oRBC1tagged_out_memory=NULL;
  219. T0* rT2tagged_out_memory(/*C*/void){
  220. if (ofBC1tagged_out_memory==0){
  221. T0* R=NULL;
  222. rs_link("tagged_out_memory of GENERAL");
  223. rs_pREF((void**)&R,Result);
  224. ofBC1tagged_out_memory=1;
  225. rs_pPOS(tag_pos_5,344,3,1);
  226. {T7*n;
  227. n=((void*)calloc(sizeof(T7),1));
  228. ((T0*)n)->id=7;
  229. rT7make(n,1024);
  230. R=(T0*)n;
  231. ivT7(n);}
  232. rs-=8;
  233. rs_unlink();
  234. oRBC1tagged_out_memory=R;}
  235. return oRBC1tagged_out_memory;}
  236. /*No:INTEGER.item*/
  237. void rT2fill_tagged_out_memory(int C){
  238. rs_link("out_in_tagged_out_memory of INTEGER");
  239. rs_pINT(&C,Current);
  240. rs_pPOS(tag_pos_3,315,11,2);
  241. rT2append_in(C,rT2tagged_out_memory());
  242. rs-=8;
  243. rs_unlink();
  244. }
  245. int rT2is_equal(int C,int a1){
  246. int R=0;
  247. rs_link("is_equal of COMPARABLE");
  248. rs_pINT(&C,Current);
  249. rs_pINT(&a1,"other");
  250. rs_pBOO(&R,Result);
  251. se_af_rlc=1;
  252. if(!se_af){se_af=1;
  253. se_af=0;}
  254. /*IF*/if (rs_pPOS(tag_pos_2,63,14,384),rs_pop_int((C)<(a1))) {
  255. }
  256.  else if (rs_pPOS(tag_pos_2,64,16,384),rs_pop_int((a1)<(C))) {
  257. }
  258. else {
  259. R=1;
  260. }
  261. /*FI*/if(!se_af){se_af=1;
  262. rs_pPOS(tag_pos_4,108,40,1);
  263. ac_ens((!((C)==(a1)))||(R));
  264. rs_pPOS(tag_pos_4,109,21,1);
  265. ac_ens((!(R))||(rT2is_equal(a1,C)));
  266. rs_pPOS(tag_pos_4,69,22,384);
  267. ac_ens((R)==(rT6_px_and(rT6_ix_not((C)<(a1)),rT6_ix_not((a1)<(C)))));
  268. se_af=0;}
  269. rs_unlink();
  270. return R;
  271. }
  272. int rT2valid_divisor(/*C*/int a1){
  273. int R=0;
  274. rs_link("valid_divisor of INTEGER_REF");
  275. rs_pINT(&a1,"other");
  276. rs_pBOO(&R,Result);
  277. se_af_rlc=1;
  278. if(!se_af){se_af=1;
  279. se_af=0;}
  280. rs_pPOS(tag_pos_1,120,3,509);
  281. R=(a1)!=(0);
  282. rs-=8;
  283. rs_unlink();
  284. return R;
  285. }
  286. char rT2digit(int C){
  287. char R=0;
  288. rs_link("digit of INTEGER");
  289. rs_pINT(&C,Current);
  290. rs_pCHA(&R,Result);
  291. se_af_rlc=1;
  292. if(!se_af){se_af=1;
  293. rs_pPOS(tag_pos_4,274,5,2);
  294. ac_req((0)<=(C));
  295. rs_pPOS(tag_pos_4,275,11,2);
  296. ac_req((C)<=(9));
  297. se_af=0;}
  298. R=(C)+(((unsigned char)'0'));
  299. if(!se_af){se_af=1;
  300. rs_pPOS(tag_pos_4,279,18,2);
  301. ac_ens(rT7has(((T7*)ms1_2),R));
  302. rs_pPOS(tag_pos_4,280,16,2);
  303. ac_ens((rT3value(R))==(C));
  304. se_af=0;}
  305. rs_unlink();
  306. return R;
  307. }
  308. T0* rT6to_string(int C){
  309. T0* R=NULL;
  310. rs_link("to_string of BOOLEAN");
  311. rs_pBOO(&C,Current);
  312. rs_pREF((void**)&R,Result);
  313. /*IF*/if (C) {
  314. R=ms1_6;
  315. }
  316. else {
  317. R=ms2_6;
  318. }
  319. /*FI*/rs_unlink();
  320. return R;
  321. }
  322. T0* rT6tagged_out_memory(/*C*/void){
  323. if (ofBC1tagged_out_memory==0){
  324. T0* R=NULL;
  325. rs_link("tagged_out_memory of GENERAL");
  326. rs_pREF((void**)&R,Result);
  327. ofBC1tagged_out_memory=1;
  328. rs_pPOS(tag_pos_5,344,3,1);
  329. {T7*n;
  330. n=((void*)calloc(sizeof(T7),1));
  331. ((T0*)n)->id=7;
  332. rT7make(n,1024);
  333. R=(T0*)n;
  334. ivT7(n);}
  335. rs-=8;
  336. rs_unlink();
  337. oRBC1tagged_out_memory=R;}
  338. return oRBC1tagged_out_memory;}
  339. void rT6fill_tagged_out_memory(int C){
  340. rs_link("out_in_tagged_out_memory of BOOLEAN");
  341. rs_pBOO(&C,Current);
  342. rs_pPOS(tag_pos_3,101,21,6);
  343. rT7append(ivT7(((T7*)ci(7,rT6tagged_out_memory(),101,3,6))),rT6to_string(C));
  344. rs-=8;
  345. rs_unlink();
  346. }
  347. int rT6_px_or(int C,int a1){
  348. int R=0;
  349. rs_link("infix or of BOOLEAN");
  350. rs_pBOO(&C,Current);
  351. rs_pBOO(&a1,"other");
  352. rs_pBOO(&R,Result);
  353. se_af_rlc=1;
  354. if(!se_af){se_af=1;
  355. se_af=0;}
  356. R=(C)||(a1);
  357. rs_unlink();
  358. return R;
  359. }
  360. int rT6_px_and(int C,int a1){
  361. int R=0;
  362. rs_link("infix and of BOOLEAN");
  363. rs_pBOO(&C,Current);
  364. rs_pBOO(&a1,"other");
  365. rs_pBOO(&R,Result);
  366. se_af_rlc=1;
  367. if(!se_af){se_af=1;
  368. se_af=0;}
  369. R=(C)&&(a1);
  370. rs_unlink();
  371. return R;
  372. }
  373. int rT6_ix_not(int C){
  374. int R=0;
  375. rs_link("prefix not of BOOLEAN");
  376. rs_pBOO(&C,Current);
  377. rs_pBOO(&R,Result);
  378. /*IF*/if (C) {
  379. }
  380. else {
  381. R=1;
  382. }
  383. /*FI*/rs_unlink();
  384. return R;
  385. }
  386. int rT3_px_60(char C,char a1){
  387. int R=0;
  388. rs_link("infix < of CHARACTER");
  389. rs_pCHA(&C,Current);
  390. rs_pCHA(&a1,"other");
  391. rs_pBOO(&R,Result);
  392. se_af_rlc=1;
  393. if(!se_af){se_af=1;
  394. se_af=0;}
  395. rs_pPOS(tag_pos_1,27,3,3);
  396. R=(((unsigned char)C))<(((unsigned char)a1));
  397. rs-=8;
  398. if(!se_af){se_af=1;
  399. rs_pPOS(tag_pos_4,20,22,384);
  400. ac_ens((!(R))||(rT6_ix_not(rT3_px_60(a1,C))));
  401. se_af=0;}
  402. rs_unlink();
  403. return R;
  404. }
  405. T0* rT3tagged_out_memory(/*C*/void){
  406. if (ofBC1tagged_out_memory==0){
  407. T0* R=NULL;
  408. rs_link("tagged_out_memory of GENERAL");
  409. rs_pREF((void**)&R,Result);
  410. ofBC1tagged_out_memory=1;
  411. rs_pPOS(tag_pos_5,344,3,1);
  412. {T7*n;
  413. n=((void*)calloc(sizeof(T7),1));
  414. ((T0*)n)->id=7;
  415. rT7make(n,1024);
  416. R=(T0*)n;
  417. ivT7(n);}
  418. rs-=8;
  419. rs_unlink();
  420. oRBC1tagged_out_memory=R;}
  421. return oRBC1tagged_out_memory;}
  422. void rT3fill_tagged_out_memory(char C){
  423. rs_link("out_in_tagged_out_memory of CHARACTER");
  424. rs_pCHA(&C,Current);
  425. rs_pPOS(tag_pos_3,268,21,3);
  426. rT7extend(ivT7(((T7*)ci(7,rT3tagged_out_memory(),268,3,3))),C);
  427. rs-=8;
  428. rs_unlink();
  429. }
  430. int rT3is_equal(char C,char a1){
  431. int R=0;
  432. rs_link("is_equal of COMPARABLE");
  433. rs_pCHA(&C,Current);
  434. rs_pCHA(&a1,"other");
  435. rs_pBOO(&R,Result);
  436. se_af_rlc=1;
  437. if(!se_af){se_af=1;
  438. se_af=0;}
  439. /*IF*/if (rs_pPOS(tag_pos_2,63,14,384),rs_pop_int(rT3_px_60(C,a1))) {
  440. }
  441.  else if (rs_pPOS(tag_pos_2,64,16,384),rs_pop_int(rT3_px_60(a1,C))) {
  442. }
  443. else {
  444. R=1;
  445. }
  446. /*FI*/if(!se_af){se_af=1;
  447. rs_pPOS(tag_pos_4,69,22,384);
  448. ac_ens((R)==(rT6_px_and(rT6_ix_not(rT3_px_60(C,a1)),rT6_ix_not(rT3_px_60(a1,C)))));
  449. rs_pPOS(tag_pos_4,108,40,1);
  450. ac_ens((!((C)==(a1)))||(R));
  451. rs_pPOS(tag_pos_4,109,21,1);
  452. ac_ens((!(R))||(rT3is_equal(a1,C)));
  453. se_af=0;}
  454. rs_unlink();
  455. return R;
  456. }
  457. int rT3value(char C){
  458. int R=0;
  459. rs_link("value of CHARACTER");
  460. rs_pCHA(&C,Current);
  461. rs_pINT(&R,Result);
  462. se_af_rlc=1;
  463. if(!se_af){se_af=1;
  464. rs_pPOS(tag_pos_4,60,3,3);
  465. ac_req(rT3is_digit(C));
  466. se_af=0;}
  467. rs_pPOS(tag_pos_1,62,3,3);
  468. R=(((unsigned char)C))-(48);
  469. rs-=8;
  470. if(!se_af){se_af=1;
  471. rs_pPOS(tag_pos_4,64,15,3);
  472. ac_ens(rT6_px_and((0)<=(R),(R)<=(9)));
  473. rs_pPOS(tag_pos_4,65,22,3);
  474. ac_ens((R)==((((unsigned char)C))-(48)));
  475. se_af=0;}
  476. rs_unlink();
  477. return R;
  478. }
  479. int rT3_px_6061(char C,char a1){
  480. int R=0;
  481. rs_link("infix <= of CHARACTER");
  482. rs_pCHA(&C,Current);
  483. rs_pCHA(&a1,"other");
  484. rs_pBOO(&R,Result);
  485. se_af_rlc=1;
  486. if(!se_af){se_af=1;
  487. se_af=0;}
  488. rs_pPOS(tag_pos_1,33,3,3);
  489. R=(((unsigned char)C))<=(((unsigned char)a1));
  490. rs-=8;
  491. if(!se_af){se_af=1;
  492. rs_pPOS(tag_pos_4,30,42,384);
  493. ac_ens(rT6_px_or((R)==(rT3_px_60(C,a1)),rT3is_equal(C,a1)));
  494. se_af=0;}
  495. rs_unlink();
  496. return R;
  497. }
  498. int rT3is_digit(char C){
  499. int R=0;
  500. rs_link("is_digit of CHARACTER");
  501. rs_pCHA(&C,Current);
  502. rs_pBOO(&R,Result);
  503. {int z1=C;
  504.  
  505. if(((48<=z1)&&(z1<=57))){
  506. R=1;
  507. }
  508. }
  509. if(!se_af){se_af=1;
  510. rs_pPOS(tag_pos_4,134,9,3);
  511. ac_ens((!(R))||(rT6_px_and(rT3_px_6061('0',C),rT3_px_6061(C,'9'))));
  512. se_af=0;}
  513. rs_unlink();
  514. return R;
  515. }
  516. void rT5append_in(double C,T0* a1){
  517. rs_link("append_in of DOUBLE");
  518. rs_pDOU(&C,Current);
  519. rs_pREF((void**)&a1,"str");
  520. se_af_rlc=1;
  521. if(!se_af){se_af=1;
  522. rs_pPOS(tag_pos_4,182,7,5);
  523. ac_req((a1)!=(((void*)NULL)));
  524. se_af=0;}
  525. rs_pPOS(tag_pos_3,184,3,5);
  526. rT5append_in_format(C,a1,6);
  527. rs-=8;
  528. rs_unlink();
  529. }
  530. void rT5append_in_format(double C,T0* a1,int a2){
  531. int _i=0;
  532. rs_link("append_in_format of DOUBLE");
  533. rs_pDOU(&C,Current);
  534. rs_pREF((void**)&a1,"str");
  535. rs_pINT(&a2,"f");
  536. rs_pINT(&_i,"i");
  537. se_af_rlc=1;
  538. if(!se_af){se_af=1;
  539. rs_pPOS(tag_pos_4,200,7,5);
  540. ac_req((a1)!=(((void*)NULL)));
  541. rs_pPOS(tag_pos_4,201,5,5);
  542. ac_req((a2)>=(0));
  543. se_af=0;}
  544. rs_pPOS(tag_pos_3,206,6,5);
  545. {int i;
  546. double d=C;
  547. sprintf(_spfd+2,"%d",(a2));
  548. for(i=2;_spfd[i]!=0;i++);
  549. _spfd[i]='f';
  550. _spfd[++i]=0;
  551. sprintf((rT5tmp_native_array()),_spfd,d);
  552. }
  553. rs-=8;
  554. _i=0;
  555. while (!(rs_pPOS(tag_pos_2,209,31,5),rs_pop_int(((rT5tmp_native_array())[_i])==('\0')))) {
  556. rs_pPOS(tag_pos_3,211,10,5);
  557. rT7extend(ivT7(((T7*)ci(7,a1,211,6,5))),(rT5tmp_native_array())[_i]);
  558. rs-=8;
  559. _i=(_i)+(1);
  560. }
  561. rs_unlink();
  562. }
  563. int ofBC5tmp_native_array=0;
  564. T510 oRBC5tmp_native_array=NULL;
  565. T510 rT5tmp_native_array(/*C*/void){
  566. if (ofBC5tmp_native_array==0){
  567. T510 R=NULL;
  568. rs_link("tmp_native_array of DOUBLE");
  569. rs_pEXP(&R,Result);
  570. ofBC5tmp_native_array=1;
  571. rs_pPOS(tag_pos_1,306,3,5);
  572. R=calloc(128,sizeof(char));
  573. rs-=8;
  574. rs_unlink();
  575. oRBC5tmp_native_array=R;}
  576. return oRBC5tmp_native_array;}
  577. void rT4append_in(float C,T0* a1){
  578. rs_link("append_in of REAL");
  579. rs_pREA(&C,Current);
  580. rs_pREF((void**)&a1,"str");
  581. se_af_rlc=1;
  582. if(!se_af){se_af=1;
  583. rs_pPOS(tag_pos_4,156,7,4);
  584. ac_req((a1)!=(((void*)NULL)));
  585. se_af=0;}
  586. rs_pPOS(tag_pos_3,158,13,4);
  587. rT5append_in(((double)C),a1);
  588. rs-=8;
  589. rs_unlink();
  590. }
  591. void rT8append_in(void* C,T0* a1){
  592. int _i=0;
  593. rs_link("append_in of POINTER");
  594. rs_pPOI(&C,Current);
  595. rs_pREF((void**)&a1,"str");
  596. rs_pINT(&_i,"i");
  597. rs_pPOS(tag_pos_3,41,3,8);
  598. {void*p=C;
  599. sprintf((rT8tmp_native_array()),"%p",p);}
  600. rs-=8;
  601. _i=0;
  602. while (!(rs_pPOS(tag_pos_2,45,31,8),rs_pop_int(((rT8tmp_native_array())[_i])==('\0')))) {
  603. rs_pPOS(tag_pos_3,47,10,8);
  604. rT7extend(ivT7(((T7*)ci(7,a1,47,6,8))),(rT8tmp_native_array())[_i]);
  605. rs-=8;
  606. _i=(_i)+(1);
  607. }
  608. rs_unlink();
  609. }
  610. int ofBC8tmp_native_array=0;
  611. T510 oRBC8tmp_native_array=NULL;
  612. T510 rT8tmp_native_array(/*C*/void){
  613. if (ofBC8tmp_native_array==0){
  614. T510 R=NULL;
  615. rs_link("tmp_native_array of POINTER");
  616. rs_pEXP(&R,Result);
  617. ofBC8tmp_native_array=1;
  618. rs_pPOS(tag_pos_1,65,3,8);
  619. R=calloc(32,sizeof(char));
  620. rs-=8;
  621. rs_unlink();
  622. oRBC8tmp_native_array=R;}
  623. return oRBC8tmp_native_array;}
  624. int rT510is_not_void(T510 C){
  625. int R=0;
  626. rs_link("is_not_void of NATIVE_ARRAY");
  627. rs_pEXP(&C,Current);
  628. rs_pBOO(&R,Result);
  629. R=(NULL!=((void*)C));
  630. rs_unlink();
  631. return R;
  632. }
  633. int rT510fast_index_of(T510 C,char a1,int a2){
  634. int R=0;
  635. rs_link("fast_index_of of NATIVE_ARRAY");
  636. rs_pEXP(&C,Current);
  637. rs_pCHA(&a1,"element");
  638. rs_pINT(&a2,"upper");
  639. rs_pINT(&R,Result);
  640. se_af_rlc=1;
  641. if(!se_af){se_af=1;
  642. rs_pPOS(tag_pos_4,125,9,864);
  643. ac_req((a2)>=(-(1)));
  644. se_af=0;}
  645. while (!(rs_pPOS(tag_pos_2,129,21,864),rs_pop_int(((R)>(a2))||((a1)==((C)[R]))))) {
  646. R=(R)+(1);
  647. }
  648. rs_unlink();
  649. return R;
  650. }
  651. void rT510copy_from(T510 C,T510 a1,int a2){
  652. int _i=0;
  653. rs_link("copy_from of NATIVE_ARRAY");
  654. rs_pEXP(&C,Current);
  655. rs_pEXP(&a1,"other");
  656. rs_pINT(&a2,"upper");
  657. rs_pINT(&_i,"i");
  658. _i=a2;
  659. while (!(rs_pPOS(tag_pos_2,217,8,864),rs_pop_int((_i)<(0)))) {
  660. rs_pPOS(tag_pos_3,219,6,864);
  661. (C)[_i]=((a1)[_i]);
  662. rs-=8;
  663. _i=(_i)-(1);
  664. }
  665. rs_unlink();
  666. }
  667. T510 rT510realloc(T510 C,int a1,int a2){
  668. T510 R=NULL;
  669. rs_link("realloc of NATIVE_ARRAY");
  670. rs_pEXP(&C,Current);
  671. rs_pINT(&a1,"old_nb_elts");
  672. rs_pINT(&a2,"new_nb_elts");
  673. rs_pEXP(&R,Result);
  674. se_af_rlc=1;
  675. if(!se_af){se_af=1;
  676. rs_pPOS(tag_pos_4,54,14,864);
  677. ac_req((NULL!=((void*)C)));
  678. rs_pPOS(tag_pos_4,55,15,864);
  679. ac_req((a1)<(a2));
  680. se_af=0;}
  681. rs_pPOS(tag_pos_1,57,3,864);
  682. R=calloc(a2,sizeof(char));
  683. rs-=8;
  684. rs_pPOS(tag_pos_3,58,10,864);
  685. rT510copy_from(R,C,(a1)-(1));
  686. rs-=8;
  687. rs_pPOS(tag_pos_3,59,3,864);
  688. free(C);
  689. rs-=8;
  690. rs_unlink();
  691. return R;
  692. }
  693. void rT7out_in_tagged_out_memory(T7* C){
  694. rs_link("out_in_tagged_out_memory of STRING");
  695. rs_pREF((void**)&C,Current);
  696. rs_pPOS(tag_pos_3,881,21,7);
  697. rT7append(ivT7(((T7*)ci(7,rT7tagged_out_memory(),881,3,7))),(T0*)C);
  698. rs-=8;
  699. if(se_rci(C))ivT7(C);
  700. rs_unlink();
  701. }
  702. void rT7extend(T7* C,char a1){
  703. int _new_capacity=0;
  704. int o1=(((T7*)C))->_count/*W3*/;
  705. rs_link("add_last of STRING");
  706. rs_pREF((void**)&C,Current);
  707. rs_pCHA(&a1,"ch");
  708. rs_pINT(&_new_capacity,"new_capacity");
  709. /*IF*/if (rs_pPOS(tag_pos_2,508,15,7),rs_pop_int(((((T7*)C))->_capacity/*W2*/)>((((T7*)C))->_count/*W3*/))) {
  710. }
  711.  else if (rs_pPOS(tag_pos_2,509,19,7),rs_pop_int(((((T7*)C))->_capacity/*W2*/)==(0))) {
  712. C->_capacity=32;
  713. rs_pPOS(tag_pos_1,511,6,7);
  714. C->_storage=calloc((((T7*)C))->_capacity/*W2*/,sizeof(char));
  715. rs-=8;
  716. }
  717. else {
  718. rs_pPOS(tag_pos_1,513,6,7);
  719. _new_capacity=(2)*((((T7*)C))->_capacity/*W2*/);
  720. rs-=8;
  721. rs_pPOS(tag_pos_1,514,6,7);
  722. C->_storage=rT510realloc((((T7*)C))->_storage/*W1*/,(((T7*)C))->_capacity/*W2*/,_new_capacity);
  723. rs-=8;
  724. C->_capacity=_new_capacity;
  725. }
  726. /*FI*/rs_pPOS(tag_pos_1,517,3,7);
  727. C->_count=((((T7*)C))->_count/*W3*/)+(1);
  728. rs-=8;
  729. rs_pPOS(tag_pos_3,518,3,7);
  730. rT7put(C,a1,(((T7*)C))->_count/*W3*/);
  731. rs-=8;
  732. if(se_rci(C))ivT7(C);
  733. if(!se_af){se_af=1;
  734. rs_pPOS(tag_pos_4,520,9,7);
  735. ac_ens(((((T7*)C))->_count/*W3*/)==((1)+(o1)));
  736. rs_pPOS(tag_pos_4,521,16,7);
  737. ac_ens((rT7item(C,(((T7*)C))->_count/*W3*/))==(a1));
  738. se_af=0;}
  739. rs_unlink();
  740. }
  741. void rT7make(T7* C,int a1){
  742. rs_link("make of STRING");
  743. rs_pREF((void**)&C,Current);
  744. rs_pINT(&a1,"needed_capacity");
  745. se_af_rlc=1;
  746. if(!se_af){se_af=1;
  747. rs_pPOS(tag_pos_4,37,19,7);
  748. ac_req((a1)>=(0));
  749. se_af=0;}
  750. /*IF*/if (rs_pPOS(tag_pos_2,39,22,7),rs_pop_int((a1)>(0))) {
  751. /*IF*/if (rs_pPOS(tag_pos_2,40,18,7),rs_pop_int(((((T7*)C))->_capacity/*W2*/)<(a1))) {
  752. /*IF*/if (rs_pPOS(tag_pos_2,41,21,7),rs_pop_int(((((T7*)C))->_capacity/*W2*/)>(0))) {
  753. rs_pPOS(tag_pos_3,42,13,7);
  754. free((((T7*)C))->_storage/*W1*/);
  755. rs-=8;
  756. }
  757. /*FI*/rs_pPOS(tag_pos_1,44,9,7);
  758. C->_storage=calloc(a1,sizeof(char));
  759. rs-=8;
  760. C->_capacity=a1;
  761. }
  762. /*FI*/}
  763. /*FI*/C->_count=0;
  764. if(se_rci(C))ivT7(C);
  765. if(!se_af){se_af=1;
  766. rs_pPOS(tag_pos_4,50,19,7);
  767. ac_ens((a1)<=((((T7*)C))->_capacity/*W2*/));
  768. rs_pPOS(tag_pos_4,51,9,7);
  769. ac_ens(((((T7*)C))->_count/*W3*/)==(0));
  770. se_af=0;}
  771. rs_unlink();
  772. }
  773. T0*oRBC1std_output=NULL;
  774. T0* rT7tagged_out_memory(/*C*/void){
  775. if (ofBC1tagged_out_memory==0){
  776. T0* R=NULL;
  777. rs_link("tagged_out_memory of GENERAL");
  778. rs_pREF((void**)&R,Result);
  779. ofBC1tagged_out_memory=1;
  780. rs_pPOS(tag_pos_5,344,3,1);
  781. {T7*n;
  782. n=((void*)calloc(sizeof(T7),1));
  783. ((T0*)n)->id=7;
  784. rT7make(n,1024);
  785. R=(T0*)n;
  786. ivT7(n);}
  787. rs-=8;
  788. rs_unlink();
  789. oRBC1tagged_out_memory=R;}
  790. return oRBC1tagged_out_memory;}
  791. char rT7item(T7* C,int a1){
  792. char R=0;
  793. rs_link("item of STRING");
  794. rs_pREF((void**)&C,Current);
  795. rs_pINT(&a1,"index");
  796. rs_pCHA(&R,Result);
  797. se_af_rlc=1;
  798. if(!se_af){se_af=1;
  799. rs_pPOS(tag_pos_4,78,3,7);
  800. ac_req(rT7valid_index(C,a1));
  801. se_af=0;}
  802. R=((((T7*)C))->_storage/*W1*/)[(a1)-(1)];
  803. if(se_rci(C))ivT7(C);
  804. rs_unlink();
  805. return R;
  806. }
  807. void rT7clear(T7* C){
  808. rs_link("clear of STRING");
  809. rs_pREF((void**)&C,Current);
  810. C->_count=0;
  811. if(se_rci(C))ivT7(C);
  812. if(!se_af){se_af=1;
  813. rs_pPOS(tag_pos_4,308,9,7);
  814. ac_ens(((((T7*)C))->_count/*W3*/)==(0));
  815. se_af=0;}
  816. rs_unlink();
  817. }
  818. void rT7fill_tagged_out_memory(T7* C){
  819. rs_link("fill_tagged_out_memory of STRING");
  820. rs_pREF((void**)&C,Current);
  821. rs_pPOS(tag_pos_3,886,21,7);
  822. rT7append(ivT7(((T7*)ci(7,rT7tagged_out_memory(),886,3,7))),ms3_7);
  823. rs-=8;
  824. rs_pPOS(tag_pos_3,887,9,7);
  825. rT2append_in((((T7*)C))->_count/*W3*/,rT7tagged_out_memory());
  826. rs-=8;
  827. rs_pPOS(tag_pos_3,888,21,7);
  828. rT7append(ivT7(((T7*)ci(7,rT7tagged_out_memory(),888,3,7))),ms4_7);
  829. rs-=8;
  830. rs_pPOS(tag_pos_3,889,12,7);
  831. rT2append_in((((T7*)C))->_capacity/*W2*/,rT7tagged_out_memory());
  832. rs-=8;
  833. rs_pPOS(tag_pos_3,890,21,7);
  834. rT7append(ivT7(((T7*)ci(7,rT7tagged_out_memory(),890,3,7))),ms5_7);
  835. rs-=8;
  836. rs_pPOS(tag_pos_3,891,21,7);
  837. rT7append(ivT7(((T7*)ci(7,rT7tagged_out_memory(),891,3,7))),(T0*)C);
  838. rs-=8;
  839. rs_pPOS(tag_pos_3,892,21,7);
  840. rT7extend(ivT7(((T7*)ci(7,rT7tagged_out_memory(),892,3,7))),'\42');
  841. rs-=8;
  842. if(se_rci(C))ivT7(C);
  843. rs_unlink();
  844. }
  845. /*No:STRING.storage*/
  846. void rT7print_on(T7* C,T0* a1){
  847. rs_link("print_on of GENERAL");
  848. rs_pREF((void**)&C,Current);
  849. rs_pREF((void**)&a1,"file");
  850. rs_pPOS(tag_pos_3,300,21,1);
  851. rT7clear(ivT7(((T7*)ci(7,rT7tagged_out_memory(),300,3,1))));
  852. rs-=8;
  853. rs_pPOS(tag_pos_3,301,3,1);
  854. rT7out_in_tagged_out_memory(C);
  855. rs-=8;
  856. rs_pPOS(tag_pos_3,302,8,1);
  857. X817put_string(302,3,1,a1,rT7tagged_out_memory());
  858. rs-=8;
  859. if(se_rci(C))ivT7(C);
  860. rs_unlink();
  861. }
  862. void rT7swap(T7* C,int a1,int a2){
  863. char _tmp=0;
  864. char o3=rT7item(C,a2);
  865. char o2=rT7item(C,a1);
  866. rs_link("swap of STRING");
  867. rs_pREF((void**)&C,Current);
  868. rs_pINT(&a1,"i1");
  869. rs_pINT(&a2,"i2");
  870. rs_pCHA(&_tmp,"tmp");
  871. se_af_rlc=1;
  872. if(!se_af){se_af=1;
  873. rs_pPOS(tag_pos_4,407,3,7);
  874. ac_req(rT7valid_index(C,a1));
  875. rs_pPOS(tag_pos_4,408,3,7);
  876. ac_req(rT7valid_index(C,a2));
  877. se_af=0;}
  878. _tmp=rT7item(C,a1);
  879. rs_pPOS(tag_pos_3,413,3,7);
  880. rT7put(C,rT7item(C,a2),a1);
  881. rs-=8;
  882. rs_pPOS(tag_pos_3,414,3,7);
  883. rT7put(C,_tmp,a2);
  884. rs-=8;
  885. if(se_rci(C))ivT7(C);
  886. if(!se_af){se_af=1;
  887. rs_pPOS(tag_pos_4,416,12,7);
  888. ac_ens((rT7item(C,a1))==(o3));
  889. rs_pPOS(tag_pos_4,417,12,7);
  890. ac_ens((rT7item(C,a2))==(o2));
  891. se_af=0;}
  892. rs_unlink();
  893. }
  894. /*No:STRING.capacity*/
  895. int rT7has(T7* C,char a1){
  896. int R=0;
  897. rs_link("has of STRING");
  898. rs_pREF((void**)&C,Current);
  899. rs_pCHA(&a1,"ch");
  900. rs_pBOO(&R,Result);
  901. rs_pPOS(tag_pos_1,241,3,7);
  902. R=(rT7index_of(C,a1))!=(((((T7*)C))->_count/*W3*/)+(1));
  903. rs-=8;
  904. if(se_rci(C))ivT7(C);
  905. rs_unlink();
  906. return R;
  907. }
  908. void rT7put(T7* C,char a1,int a2){
  909. rs_link("put of STRING");
  910. rs_pREF((void**)&C,Current);
  911. rs_pCHA(&a1,"ch");
  912. rs_pINT(&a2,"index");
  913. se_af_rlc=1;
  914. if(!se_af){se_af=1;
  915. rs_pPOS(tag_pos_4,398,3,7);
  916. ac_req(rT7valid_index(C,a2));
  917. se_af=0;}
  918. rs_pPOS(tag_pos_3,400,11,7);
  919. ((((T7*)C))->_storage/*W1*/)[(a2)-(1)]=(a1);
  920. rs-=8;
  921. if(se_rci(C))ivT7(C);
  922. if(!se_af){se_af=1;
  923. rs_pPOS(tag_pos_4,402,16,7);
  924. ac_ens((rT7item(C,a2))==(a1));
  925. se_af=0;}
  926. rs_unlink();
  927. }
  928. int rT7valid_index(T7* C,int a1){
  929. int R=0;
  930. rs_link("valid_index of STRING");
  931. rs_pREF((void**)&C,Current);
  932. rs_pINT(&a1,"index");
  933. rs_pBOO(&R,Result);
  934. rs_pPOS(tag_pos_1,86,3,7);
  935. R=((1)<=(a1))&&((a1)<=((((T7*)C))->_count/*W3*/));
  936. rs-=8;
  937. if(se_rci(C))ivT7(C);
  938. if(!se_af){se_af=1;
  939. rs_pPOS(tag_pos_4,88,10,7);
  940. ac_ens((R)==(rT6_px_and((1)<=(a1),(a1)<=((((T7*)C))->_count/*W3*/))));
  941. se_af=0;}
  942. rs_unlink();
  943. return R;
  944. }
  945. /*No:STRING.count*/
  946. int rT7index_of(T7* C,char a1){
  947. int R=0;
  948. rs_link("index_of of STRING");
  949. rs_pREF((void**)&C,Current);
  950. rs_pCHA(&a1,"ch");
  951. rs_pINT(&R,Result);
  952. rs_pPOS(tag_pos_1,185,3,7);
  953. R=(1)+(rT510fast_index_of((((T7*)C))->_storage/*W1*/,a1,((((T7*)C))->_count/*W3*/)-(1)));
  954. rs-=8;
  955. if(se_rci(C))ivT7(C);
  956. if(!se_af){se_af=1;
  957. rs_pPOS(tag_pos_4,187,25,7);
  958. ac_ens((!((R)!=(((((T7*)C))->_count/*W3*/)+(1))))||((rT7item(C,R))==(a1)));
  959. se_af=0;}
  960. rs_unlink();
  961. return R;
  962. }
  963. void rT7print(/*C*/T0* a1){
  964. rs_link("print of GENERAL");
  965. rs_pREF((void**)&a1,"some");
  966. /*IF*/if (rs_pPOS(tag_pos_2,286,11,1),rs_pop_int((a1)==(((void*)NULL)))) {
  967. rs_pPOS(tag_pos_3,287,17,1);
  968. X830put_string(287,6,1,oRBC1std_output,ms1_1);
  969. rs-=8;
  970. }
  971. else {
  972. rs_pPOS(tag_pos_3,289,11,1);
  973. X1print_on(289,6,1,a1,oRBC1std_output);
  974. rs-=8;
  975. }
  976. /*FI*/rs_unlink();
  977. }
  978. void rT7append(T7* C,T0* a1){
  979. int _i=0;
  980. rs_link("append of STRING");
  981. rs_pREF((void**)&C,Current);
  982. rs_pREF((void**)&a1,"other");
  983. rs_pINT(&_i,"i");
  984. se_af_rlc=1;
  985. if(!se_af){se_af=1;
  986. rs_pPOS(tag_pos_4,344,9,7);
  987. ac_req((a1)!=(((void*)NULL)));
  988. se_af=0;}
  989. _i=1;
  990. while (!(rs_pPOS(tag_pos_2,351,8,7),rs_pop_int((_i)>((((T7*)ivT7(((T7*)ci(7,a1,351,10,7)))))->_count/*W3*/)))) {
  991. rs_pPOS(tag_pos_3,353,6,7);
  992. rT7extend(C,rT7item(ivT7(((T7*)ci(7,a1,353,13,7))),_i));
  993. rs-=8;
  994. _i=(_i)+(1);
  995. }
  996. if(se_rci(C))ivT7(C);
  997. rs_unlink();
  998. }
  999. T7 *ivT7(T7 *C){
  1000. *((int*)rs++)=INVid;*((char**)rs++)=p[7];
  1001. if(!se_af){se_af=1;
  1002. rs_pPOS(tag_pos_4,1163,6,7);
  1003. ac_inv((0)<=((((T7*)C))->_count/*W3*/));
  1004. rs_pPOS(tag_pos_4,1165,10,7);
  1005. ac_inv(((((T7*)C))->_count/*W3*/)<=((((T7*)C))->_capacity/*W2*/));
  1006. rs_pPOS(tag_pos_4,1167,17,7);
  1007. ac_inv((!(((((T7*)C))->_capacity/*W2*/)>(0)))||(rT510is_not_void((((T7*)C))->_storage/*W1*/)));
  1008. se_af=0;}
  1009. rs-=2;return C;}
  1010. void rT830out_in_tagged_out_memory(T830* C){
  1011. rs_link("out_in_tagged_out_memory of GENERAL");
  1012. rs_pREF((void**)&C,Current);
  1013. rs_pPOS(tag_pos_3,332,21,1);
  1014. rT7append(ivT7(((T7*)ci(7,rT830tagged_out_memory(),332,3,1))),((T0*)(gt[(C)->id])));
  1015. rs-=8;
  1016. /*IF*/{/*AT*/rs_pPOS(tag_pos_3,334,24,1);
  1017. rT7extend(ivT7(((T7*)ci(7,rT830tagged_out_memory(),334,6,1))),'\43');
  1018. rs-=8;
  1019. rs_pPOS(tag_pos_3,335,25,1);
  1020. rT8append_in(((void*)C),rT830tagged_out_memory());
  1021. rs-=8;
  1022. }
  1023. /*FI*/rs_pPOS(tag_pos_3,337,21,1);
  1024. rT7extend(ivT7(((T7*)ci(7,rT830tagged_out_memory(),337,3,1))),'\133');
  1025. rs-=8;
  1026. rs_pPOS(tag_pos_3,338,3,1);
  1027. rT830fill_tagged_out_memory();
  1028. rs-=8;
  1029. rs_pPOS(tag_pos_3,339,21,1);
  1030. rT7extend(ivT7(((T7*)ci(7,rT830tagged_out_memory(),339,3,1))),'\135');
  1031. rs-=8;
  1032. rs_unlink();
  1033. }
  1034. void rT830make(/*C*/void){
  1035. rs_link("make of STD_OUTPUT");
  1036. rs_unlink();
  1037. }
  1038. T0* rT830tagged_out_memory(/*C*/void){
  1039. if (ofBC1tagged_out_memory==0){
  1040. T0* R=NULL;
  1041. rs_link("tagged_out_memory of GENERAL");
  1042. rs_pREF((void**)&R,Result);
  1043. ofBC1tagged_out_memory=1;
  1044. rs_pPOS(tag_pos_5,344,3,1);
  1045. {T7*n;
  1046. n=((void*)calloc(sizeof(T7),1));
  1047. ((T0*)n)->id=7;
  1048. rT7make(n,1024);
  1049. R=(T0*)n;
  1050. ivT7(n);}
  1051. rs-=8;
  1052. rs_unlink();
  1053. oRBC1tagged_out_memory=R;}
  1054. return oRBC1tagged_out_memory;}
  1055. void rT830fill_tagged_out_memory(/*C*/void){
  1056. rs_link("fill_tagged_out_memory of GENERAL");
  1057. rs_unlink();
  1058. }
  1059. void rT830print_on(T830* C,T0* a1){
  1060. rs_link("print_on of GENERAL");
  1061. rs_pREF((void**)&C,Current);
  1062. rs_pREF((void**)&a1,"file");
  1063. rs_pPOS(tag_pos_3,300,21,1);
  1064. rT7clear(ivT7(((T7*)ci(7,rT830tagged_out_memory(),300,3,1))));
  1065. rs-=8;
  1066. rs_pPOS(tag_pos_3,301,3,1);
  1067. rT830out_in_tagged_out_memory(C);
  1068. rs-=8;
  1069. rs_pPOS(tag_pos_3,302,8,1);
  1070. X817put_string(302,3,1,a1,rT830tagged_out_memory());
  1071. rs-=8;
  1072. rs_unlink();
  1073. }
  1074. void rT830put_string(T830* C,T0* a1){
  1075. int _i=0;
  1076. rs_link("put_string of OUTPUT_STREAM");
  1077. rs_pREF((void**)&C,Current);
  1078. rs_pREF((void**)&a1,"s");
  1079. rs_pINT(&_i,"i");
  1080. se_af_rlc=1;
  1081. if(!se_af){se_af=1;
  1082. rs_pPOS(tag_pos_4,27,5,817);
  1083. ac_req((a1)!=(((void*)NULL)));
  1084. se_af=0;}
  1085. _i=1;
  1086. while (!(rs_pPOS(tag_pos_2,34,8,817),rs_pop_int((_i)>((((T7*)ivT7(((T7*)ci(7,a1,34,10,817)))))->_count/*W3*/)))) {
  1087. rs_pPOS(tag_pos_3,36,6,817);
  1088. rT830put_character(C,rT7item(ivT7(((T7*)ci(7,a1,36,20,817))),_i));
  1089. rs-=8;
  1090. _i=(_i)+(1);
  1091. }
  1092. rs_unlink();
  1093. }
  1094. void rT830put_character(T830* C,char a1){
  1095. rs_link("put_character of STD_OUTPUT");
  1096. rs_pREF((void**)&C,Current);
  1097. rs_pCHA(&a1,"c");
  1098. rs_pPOS(tag_pos_3,33,3,830);
  1099. fputc(a1,stdout);
  1100. rs-=8;
  1101. rs_unlink();
  1102. }
  1103. void rT830print(/*C*/T0* a1){
  1104. rs_link("print of GENERAL");
  1105. rs_pREF((void**)&a1,"some");
  1106. /*IF*/if (rs_pPOS(tag_pos_2,286,11,1),rs_pop_int((a1)==(((void*)NULL)))) {
  1107. rs_pPOS(tag_pos_3,287,17,1);
  1108. X830put_string(287,6,1,oRBC1std_output,ms1_1);
  1109. rs-=8;
  1110. }
  1111. else {
  1112. rs_pPOS(tag_pos_3,289,11,1);
  1113. X1print_on(289,6,1,a1,oRBC1std_output);
  1114. rs-=8;
  1115. }
  1116. /*FI*/rs_unlink();
  1117. }
  1118.  
  1119.