home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 3 / AACD03.BIN / AACD / Programming / sofa / archive / SmallEiffel.lha / SmallEiffel / lib_show / directory / example012.c < prev    next >
C/C++ Source or Header  |  1999-06-05  |  70KB  |  2,935 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.78Beta#1)--
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                  http://SmallEiffel.loria.fr/                --
  7. */
  8. #include "example01.h"
  9.  
  10.  
  11. T6 r660standard_is_equal(se_dump_stack*caller,T660* C,T0* a1){
  12. T6 R=0;
  13. void**locals[2];
  14. se_dump_stack ds;
  15. ds.fd=&f660standard_is_equal;
  16. ds.current=((void**)&C);
  17. ds.l=120;
  18. ds.c=11;
  19. ds.f=1;
  20. ds.caller=caller;
  21. ds.locals=locals;
  22. locals[0]=(void**)&a1;
  23. locals[1]=(void**)&R;
  24. se_dst=&ds;/*link*/
  25. se_require_uppermost_flag=1;
  26. if(f660standard_is_equal.assertion_flag){
  27. f660standard_is_equal.assertion_flag=0;
  28. se_trace(&ds,123,9,1);
  29. ac_req((a1)!=((void*)(NULL)));
  30. f660standard_is_equal.assertion_flag=1;
  31. }
  32. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f660standard_is_equal.assertion_flag){
  33. f660standard_is_equal.assertion_flag=0;
  34. se_trace(&ds,126,21,1);
  35. ac_ens((!(R))||(r660standard_is_equal(&ds,((T660*)ci(660,a1,126,29,1)),(T0*)C)));
  36. f660standard_is_equal.assertion_flag=1;
  37. }
  38. se_dst=caller;/*unlink*/
  39. return R;
  40. }
  41. se_frame_descriptor f660standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R660%other%R660%Result%E6%",1};
  42.  
  43.  
  44. T6 r660has(se_dump_stack*caller,T660* C,T0* a1){
  45. T6 R=0;
  46. void**locals[2];
  47. se_dump_stack ds;
  48. ds.fd=&f660has;
  49. ds.current=((void**)&C);
  50. ds.l=96;
  51. ds.c=4;
  52. ds.f=660;
  53. ds.caller=caller;
  54. ds.locals=locals;
  55. locals[0]=(void**)&a1;
  56. locals[1]=(void**)&R;
  57. se_dst=&ds;/*link*/
  58. se_require_uppermost_flag=1;
  59. if(f660has.assertion_flag){
  60. f660has.assertion_flag=0;
  61. se_trace(&ds,99,3,660);
  62. ac_req((C)->_is_connected/*8*/);
  63. se_trace(&ds,100,3,660);
  64. ac_req(r6_ix_not(&ds,r7empty(&ds,se_i7(&ds,((T7*)ci(7,a1,100,7,660))))));
  65. f660has.assertion_flag=1;
  66. }
  67. se_trace(&ds,102,3,660);
  68. R=r1405has(&ds,((T1405*)ci(1405,(C)->_basic_directory/*4*/,102,13,660)),a1);
  69. se_dst=caller;/*unlink*/
  70. return R;
  71. }
  72. se_frame_descriptor f660has={"has of DIRECTORY",1,2,"%R660%entry_name%R7%Result%E6%",1};
  73. /*No:DIRECTORY.basic_directory*/
  74.  
  75.  
  76. T0* r660path(se_dump_stack*caller,T660* C){
  77. T0* R=NULL;
  78. void**locals[1];
  79. se_dump_stack ds;
  80. ds.fd=&f660path;
  81. ds.current=((void**)&C);
  82. ds.l=78;
  83. ds.c=4;
  84. ds.f=660;
  85. ds.caller=caller;
  86. ds.locals=locals;
  87. locals[0]=(void**)&R;
  88. se_dst=&ds;/*link*/
  89. se_require_uppermost_flag=1;
  90. if(f660path.assertion_flag){
  91. f660path.assertion_flag=0;
  92. se_trace(&ds,80,3,660);
  93. ac_req((C)->_is_connected/*8*/);
  94. f660path.assertion_flag=1;
  95. }
  96. se_trace(&ds,82,3,660);
  97. R=(((T1405*)ci(1405,(C)->_basic_directory/*4*/,82,13,660)))->_path/*4*/;
  98. se_dst=caller;/*unlink*/
  99. return R;
  100. }
  101. se_frame_descriptor f660path={"path of DIRECTORY",1,1,"%R660%Result%R7%",1};
  102.  
  103.  
  104. T6 r660is_equal(se_dump_stack*caller,T660* C,T0* a1){
  105. T6 R=0;
  106. void**locals[2];
  107. se_dump_stack ds;
  108. ds.fd=&f660is_equal;
  109. ds.current=((void**)&C);
  110. ds.l=91;
  111. ds.c=4;
  112. ds.f=1;
  113. ds.caller=caller;
  114. ds.locals=locals;
  115. locals[0]=(void**)&a1;
  116. locals[1]=(void**)&R;
  117. se_dst=&ds;/*link*/
  118. se_require_uppermost_flag=1;
  119. if(f660is_equal.assertion_flag){
  120. f660is_equal.assertion_flag=0;
  121. se_trace(&ds,95,25,1);
  122. ac_req((a1)!=((void*)(NULL)));
  123. f660is_equal.assertion_flag=1;
  124. }
  125. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f660is_equal.assertion_flag){
  126. f660is_equal.assertion_flag=0;
  127. se_trace(&ds,98,40,1);
  128. ac_ens((!(r660standard_is_equal(&ds,C,a1)))||(R));
  129. se_trace(&ds,99,21,1);
  130. ac_ens((!(R))||(r660is_equal(&ds,((T660*)ci(660,a1,99,29,1)),(T0*)C)));
  131. f660is_equal.assertion_flag=1;
  132. }
  133. se_dst=caller;/*unlink*/
  134. return R;
  135. }
  136. se_frame_descriptor f660is_equal={"is_equal of GENERAL",1,2,"%R660%other%R660%Result%E6%",1};
  137.  
  138.  
  139. T6 r660valid_index(se_dump_stack*caller,T660* C,T2 a1){
  140. T6 R=0;
  141. void**locals[2];
  142. se_dump_stack ds;
  143. ds.fd=&f660valid_index;
  144. ds.current=((void**)&C);
  145. ds.l=67;
  146. ds.c=4;
  147. ds.f=660;
  148. ds.caller=caller;
  149. ds.locals=locals;
  150. locals[0]=(void**)&a1;
  151. locals[1]=(void**)&R;
  152. se_dst=&ds;/*link*/
  153. /*[IF*/
  154. if((se_trace(&ds,69,12,660),(a1)>=(1))){
  155. /*[IF*/
  156. if((se_trace(&ds,70,9,660),(C)->_is_connected/*8*/)){
  157. se_trace(&ds,71,9,660);
  158. R=r1405valid_index(&ds,((T1405*)ci(1405,(C)->_basic_directory/*4*/,71,19,660)),(a1)-(1));
  159. }
  160. /*FI]*/
  161. }
  162. /*FI]*/
  163. if(f660valid_index.assertion_flag){
  164. f660valid_index.assertion_flag=0;
  165. se_trace(&ds,75,10,660);
  166. ac_ens((R)==(r2in_range(&ds,a1,1,r660count(&ds,C))));
  167. f660valid_index.assertion_flag=1;
  168. }
  169. se_dst=caller;/*unlink*/
  170. return R;
  171. }
  172. se_frame_descriptor f660valid_index={"valid_index of DIRECTORY",1,2,"%R660%index%E2%Result%E6%",1};
  173.  
  174.  
  175. void r660connect_to(se_dump_stack*caller,T660* C,T0* a1){
  176. void**locals[1];
  177. se_dump_stack ds;
  178. ds.fd=&f660connect_to;
  179. ds.current=((void**)&C);
  180. ds.l=30;
  181. ds.c=4;
  182. ds.f=660;
  183. ds.caller=caller;
  184. ds.locals=locals;
  185. locals[0]=(void**)&a1;
  186. se_dst=&ds;/*link*/
  187. se_require_uppermost_flag=1;
  188. if(f660connect_to.assertion_flag){
  189. f660connect_to.assertion_flag=0;
  190. se_trace(&ds,32,3,660);
  191. ac_req(r6_ix_not(&ds,r7empty(&ds,se_i7(&ds,((T7*)ci(7,a1,32,7,660))))));
  192. f660connect_to.assertion_flag=1;
  193. }
  194. /*[IF*/
  195. if((se_trace(&ds,34,22,660),((C)->_basic_directory/*4*/)==((void*)(NULL)))){
  196. se_trace(&ds,35,6,660);
  197. {T1405*n=new1405();
  198. r1405make(&ds,n);
  199. C->_basic_directory=(T0*)n;
  200. }
  201. }
  202. /*FI]*/
  203. /*[IF*/
  204. if((se_trace(&ds,37,22,660),r1405set_path(&ds,((T1405*)ci(1405,(C)->_basic_directory/*4*/,37,6,660)),a1))){
  205. se_trace(&ds,38,6,660);
  206. C->_is_connected=1;
  207. }
  208. else{
  209. se_trace(&ds,40,6,660);
  210. C->_is_connected=0;
  211. }
  212. /*FI]*/
  213. se_dst=caller;/*unlink*/
  214. }
  215. se_frame_descriptor f660connect_to={"connect_to of DIRECTORY",1,1,"%R660%new_path%R7%",1};
  216. /*No:DIRECTORY.is_connected*/
  217.  
  218.  
  219. T2 r660count(se_dump_stack*caller,T660* C){
  220. T2 R=0;
  221. void**locals[1];
  222. se_dump_stack ds;
  223. ds.fd=&f660count;
  224. ds.current=((void**)&C);
  225. ds.l=57;
  226. ds.c=4;
  227. ds.f=660;
  228. ds.caller=caller;
  229. ds.locals=locals;
  230. locals[0]=(void**)&R;
  231. se_dst=&ds;/*link*/
  232. /*[IF*/
  233. if((se_trace(&ds,60,6,660),(C)->_is_connected/*8*/)){
  234. se_trace(&ds,61,6,660);
  235. R=r1405count(&ds,((T1405*)ci(1405,(C)->_basic_directory/*4*/,61,16,660)));
  236. }
  237. /*FI]*/
  238. if(f660count.assertion_flag){
  239. f660count.assertion_flag=0;
  240. se_trace(&ds,64,10,660);
  241. ac_ens((R)>=(0));
  242. f660count.assertion_flag=1;
  243. }
  244. se_dst=caller;/*unlink*/
  245. return R;
  246. }
  247. se_frame_descriptor f660count={"count of DIRECTORY",1,1,"%R660%Result%E2%",1};
  248. /*No:DIRECTORY.lower*/
  249.  
  250.  
  251. T0* r660name(se_dump_stack*caller,T660* C,T2 a1){
  252. T0* R=NULL;
  253. void**locals[2];
  254. se_dump_stack ds;
  255. ds.fd=&f660name;
  256. ds.current=((void**)&C);
  257. ds.l=85;
  258. ds.c=4;
  259. ds.f=660;
  260. ds.caller=caller;
  261. ds.locals=locals;
  262. locals[0]=(void**)&a1;
  263. locals[1]=(void**)&R;
  264. se_dst=&ds;/*link*/
  265. se_require_uppermost_flag=1;
  266. if(f660name.assertion_flag){
  267. f660name.assertion_flag=0;
  268. se_trace(&ds,88,3,660);
  269. ac_req((C)->_is_connected/*8*/);
  270. se_trace(&ds,89,3,660);
  271. ac_req(r660valid_index(&ds,C,a1));
  272. f660name.assertion_flag=1;
  273. }
  274. se_trace(&ds,91,3,660);
  275. R=r1405name(&ds,((T1405*)ci(1405,(C)->_basic_directory/*4*/,91,13,660)),(a1)-(1));
  276. if(f660name.assertion_flag){
  277. f660name.assertion_flag=0;
  278. se_trace(&ds,93,3,660);
  279. ac_ens(r660has(&ds,C,R));
  280. f660name.assertion_flag=1;
  281. }
  282. se_dst=caller;/*unlink*/
  283. return R;
  284. }
  285. se_frame_descriptor f660name={"name of DIRECTORY",1,2,"%R660%index%E2%Result%R7%",1};
  286.  
  287.  
  288. T6 r474standard_is_equal(se_dump_stack*caller,T474* C,T0* a1){
  289. T6 R=0;
  290. void**locals[2];
  291. se_dump_stack ds;
  292. ds.fd=&f474standard_is_equal;
  293. ds.current=((void**)&C);
  294. ds.l=120;
  295. ds.c=11;
  296. ds.f=1;
  297. ds.caller=caller;
  298. ds.locals=locals;
  299. locals[0]=(void**)&a1;
  300. locals[1]=(void**)&R;
  301. se_dst=&ds;/*link*/
  302. se_require_uppermost_flag=1;
  303. if(f474standard_is_equal.assertion_flag){
  304. f474standard_is_equal.assertion_flag=0;
  305. se_trace(&ds,123,9,1);
  306. ac_req((a1)!=((void*)(NULL)));
  307. f474standard_is_equal.assertion_flag=1;
  308. }
  309. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f474standard_is_equal.assertion_flag){
  310. f474standard_is_equal.assertion_flag=0;
  311. se_trace(&ds,126,21,1);
  312. ac_ens((!(R))||(r474standard_is_equal(&ds,((T474*)ci(474,a1,126,29,1)),(T0*)C)));
  313. f474standard_is_equal.assertion_flag=1;
  314. }
  315. se_dst=caller;/*unlink*/
  316. return R;
  317. }
  318. se_frame_descriptor f474standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R474%other%R474%Result%E6%",1};
  319.  
  320.  
  321. T6 r474is_equal(se_dump_stack*caller,T474* C,T0* a1){
  322. T6 R=0;
  323. void**locals[2];
  324. se_dump_stack ds;
  325. ds.fd=&f474is_equal;
  326. ds.current=((void**)&C);
  327. ds.l=91;
  328. ds.c=4;
  329. ds.f=1;
  330. ds.caller=caller;
  331. ds.locals=locals;
  332. locals[0]=(void**)&a1;
  333. locals[1]=(void**)&R;
  334. se_dst=&ds;/*link*/
  335. se_require_uppermost_flag=1;
  336. if(f474is_equal.assertion_flag){
  337. f474is_equal.assertion_flag=0;
  338. se_trace(&ds,95,25,1);
  339. ac_req((a1)!=((void*)(NULL)));
  340. f474is_equal.assertion_flag=1;
  341. }
  342. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f474is_equal.assertion_flag){
  343. f474is_equal.assertion_flag=0;
  344. se_trace(&ds,98,40,1);
  345. ac_ens((!(r474standard_is_equal(&ds,C,a1)))||(R));
  346. se_trace(&ds,99,21,1);
  347. ac_ens((!(R))||(r474is_equal(&ds,((T474*)ci(474,a1,99,29,1)),(T0*)C)));
  348. f474is_equal.assertion_flag=1;
  349. }
  350. se_dst=caller;/*unlink*/
  351. return R;
  352. }
  353. se_frame_descriptor f474is_equal={"is_equal of GENERAL",1,2,"%R474%other%R474%Result%E6%",1};
  354. /*No:BOOLEAN_REF.item*/
  355.  
  356.  
  357. T6 r1405standard_is_equal(se_dump_stack*caller,T1405* C,T0* a1){
  358. T6 R=0;
  359. void**locals[2];
  360. se_dump_stack ds;
  361. ds.fd=&f1405standard_is_equal;
  362. ds.current=((void**)&C);
  363. ds.l=120;
  364. ds.c=11;
  365. ds.f=1;
  366. ds.caller=caller;
  367. ds.locals=locals;
  368. locals[0]=(void**)&a1;
  369. locals[1]=(void**)&R;
  370. se_dst=&ds;/*link*/
  371. se_require_uppermost_flag=1;
  372. if(f1405standard_is_equal.assertion_flag){
  373. f1405standard_is_equal.assertion_flag=0;
  374. se_trace(&ds,123,9,1);
  375. ac_req((a1)!=((void*)(NULL)));
  376. f1405standard_is_equal.assertion_flag=1;
  377. }
  378. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f1405standard_is_equal.assertion_flag){
  379. f1405standard_is_equal.assertion_flag=0;
  380. se_trace(&ds,126,21,1);
  381. ac_ens((!(R))||(r1405standard_is_equal(&ds,((T1405*)ci(1405,a1,126,29,1)),(T0*)C)));
  382. f1405standard_is_equal.assertion_flag=1;
  383. }
  384. se_dst=caller;/*unlink*/
  385. return R;
  386. }
  387. se_frame_descriptor f1405standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R1405%other%R1405%Result%E6%",1};
  388.  
  389.  
  390. T6 r1405has(se_dump_stack*caller,T1405* C,T0* a1){
  391. T6 R=0;
  392. void**locals[2];
  393. se_dump_stack ds;
  394. ds.fd=&f1405has;
  395. ds.current=((void**)&C);
  396. ds.l=136;
  397. ds.c=4;
  398. ds.f=1405;
  399. ds.caller=caller;
  400. ds.locals=locals;
  401. locals[0]=(void**)&a1;
  402. locals[1]=(void**)&R;
  403. se_dst=&ds;/*link*/
  404. se_require_uppermost_flag=1;
  405. if(f1405has.assertion_flag){
  406. f1405has.assertion_flag=0;
  407. se_trace(&ds,139,3,1405);
  408. ac_req(r6_ix_not(&ds,r7empty(&ds,se_i7(&ds,((T7*)ci(7,a1,139,7,1405))))));
  409. f1405has.assertion_flag=1;
  410. }
  411. se_trace(&ds,141,3,1405);
  412. R=r1886has(&ds,se_i1886(&ds,((T1886*)ci(1886,(C)->_name_list/*8*/,141,13,1405))),a1);
  413. se_dst=caller;/*unlink*/
  414. return R;
  415. }
  416. se_frame_descriptor f1405has={"has of BASIC_DIRECTORY",1,2,"%R1405%entry_name%R7%Result%E6%",1};
  417. /*No:BASIC_DIRECTORY.name_list*/
  418. /*No:BASIC_DIRECTORY.path*/
  419.  
  420.  
  421. T6 r1405is_equal(se_dump_stack*caller,T1405* C,T0* a1){
  422. T6 R=0;
  423. void**locals[2];
  424. se_dump_stack ds;
  425. ds.fd=&f1405is_equal;
  426. ds.current=((void**)&C);
  427. ds.l=91;
  428. ds.c=4;
  429. ds.f=1;
  430. ds.caller=caller;
  431. ds.locals=locals;
  432. locals[0]=(void**)&a1;
  433. locals[1]=(void**)&R;
  434. se_dst=&ds;/*link*/
  435. se_require_uppermost_flag=1;
  436. if(f1405is_equal.assertion_flag){
  437. f1405is_equal.assertion_flag=0;
  438. se_trace(&ds,95,25,1);
  439. ac_req((a1)!=((void*)(NULL)));
  440. f1405is_equal.assertion_flag=1;
  441. }
  442. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f1405is_equal.assertion_flag){
  443. f1405is_equal.assertion_flag=0;
  444. se_trace(&ds,98,40,1);
  445. ac_ens((!(r1405standard_is_equal(&ds,C,a1)))||(R));
  446. se_trace(&ds,99,21,1);
  447. ac_ens((!(R))||(r1405is_equal(&ds,((T1405*)ci(1405,a1,99,29,1)),(T0*)C)));
  448. f1405is_equal.assertion_flag=1;
  449. }
  450. se_dst=caller;/*unlink*/
  451. return R;
  452. }
  453. se_frame_descriptor f1405is_equal={"is_equal of GENERAL",1,2,"%R1405%other%R1405%Result%E6%",1};
  454.  
  455.  
  456. T6 r1405valid_index(se_dump_stack*caller,T1405* C,T2 a1){
  457. T6 R=0;
  458. void**locals[2];
  459. se_dump_stack ds;
  460. ds.fd=&f1405valid_index;
  461. ds.current=((void**)&C);
  462. ds.l=57;
  463. ds.c=4;
  464. ds.f=1405;
  465. ds.caller=caller;
  466. ds.locals=locals;
  467. locals[0]=(void**)&a1;
  468. locals[1]=(void**)&R;
  469. se_dst=&ds;/*link*/
  470. se_trace(&ds,59,3,1405);
  471. R=((a1)>=(0))&&((a1)<=((se_i1886(&ds,((T1886*)ci(1886,(C)->_name_list/*8*/,59,42,1405))))->_upper/*12*/));
  472. if(f1405valid_index.assertion_flag){
  473. f1405valid_index.assertion_flag=0;
  474. se_trace(&ds,61,10,1405);
  475. ac_ens((R)==(r2in_range(&ds,a1,0,r1405upper(&ds,C))));
  476. f1405valid_index.assertion_flag=1;
  477. }
  478. se_dst=caller;/*unlink*/
  479. return R;
  480. }
  481. se_frame_descriptor f1405valid_index={"valid_index of BASIC_DIRECTORY",1,2,"%R1405%index%E2%Result%E6%",1};
  482.  
  483.  
  484. T6 r1405set_path(se_dump_stack*caller,T1405* C,T0* a1){
  485. T6 R=0;
  486. void**locals[2];
  487. se_dump_stack ds;
  488. ds.fd=&f1405set_path;
  489. ds.current=((void**)&C);
  490. ds.l=246;
  491. ds.c=4;
  492. ds.f=1405;
  493. ds.caller=caller;
  494. ds.locals=locals;
  495. locals[0]=(void**)&a1;
  496. locals[1]=(void**)&R;
  497. se_dst=&ds;/*link*/
  498. se_require_uppermost_flag=1;
  499. if(f1405set_path.assertion_flag){
  500. f1405set_path.assertion_flag=0;
  501. se_trace(&ds,253,3,1405);
  502. ac_req(r6_ix_not(&ds,r7empty(&ds,se_i7(&ds,((T7*)ci(7,a1,253,7,1405))))));
  503. f1405set_path.assertion_flag=1;
  504. }
  505. se_trace(&ds,255,3,1405);
  506. C->_path=a1;
  507. /*[IF*/
  508. if((se_trace(&ds,256,6,1405),r1405update(&ds,C))){
  509. se_trace(&ds,257,6,1405);
  510. R=1;
  511. }
  512. else{
  513. se_trace(&ds,259,6,1405);
  514. C->_path=NULL;
  515. }
  516. /*FI]*/
  517. if(f1405set_path.assertion_flag){
  518. f1405set_path.assertion_flag=0;
  519. se_trace(&ds,262,10,1405);
  520. ac_ens((!(R))||(((C)->_path/*4*/)==((void*)(a1))));
  521. f1405set_path.assertion_flag=1;
  522. }
  523. se_dst=caller;/*unlink*/
  524. return R;
  525. }
  526. se_frame_descriptor f1405set_path={"set_path of BASIC_DIRECTORY",1,2,"%R1405%p%R7%Result%E6%",1};
  527.  
  528.  
  529. T2 r1405count(se_dump_stack*caller,T1405* C){
  530. T2 R=0;
  531. void**locals[1];
  532. se_dump_stack ds;
  533. ds.fd=&f1405count;
  534. ds.current=((void**)&C);
  535. ds.l=49;
  536. ds.c=4;
  537. ds.f=1405;
  538. ds.caller=caller;
  539. ds.locals=locals;
  540. locals[0]=(void**)&R;
  541. se_dst=&ds;/*link*/
  542. se_trace(&ds,52,3,1405);
  543. R=r1886count(&ds,se_i1886(&ds,((T1886*)ci(1886,(C)->_name_list/*8*/,52,13,1405))));
  544. if(f1405count.assertion_flag){
  545. f1405count.assertion_flag=0;
  546. se_trace(&ds,54,10,1405);
  547. ac_ens((R)>=(0));
  548. f1405count.assertion_flag=1;
  549. }
  550. se_dst=caller;/*unlink*/
  551. return R;
  552. }
  553. se_frame_descriptor f1405count={"count of BASIC_DIRECTORY",1,1,"%R1405%Result%E2%",1};
  554.  
  555.  
  556. void r1405make(se_dump_stack*caller,T1405* C){
  557. se_dump_stack ds;
  558. ds.fd=&f1405make;
  559. ds.current=((void**)&C);
  560. ds.l=30;
  561. ds.c=4;
  562. ds.f=1405;
  563. ds.caller=caller;
  564. se_dst=&ds;/*link*/
  565. se_trace(&ds,35,3,1405);
  566. {T1886*n=new1886();
  567. r1886with_capacity(&ds,n,64);
  568. C->_name_list=(T0*)n;
  569. se_i1886(&ds,n);}
  570. se_dst=caller;/*unlink*/
  571. }
  572. se_frame_descriptor f1405make={"make of BASIC_DIRECTORY",1,0,"%R1405%",1};
  573.  
  574.  
  575. T6 r1405update(se_dump_stack*caller,T1405* C){
  576. T6 R=0;
  577. T0* _entry=NULL;
  578. T8 _entry_pointer=0;
  579. T8 _dirstream_pointer=0;
  580. T8 _path_pointer=0;
  581. void**locals[5];
  582. se_dump_stack ds;
  583. ds.fd=&f1405update;
  584. ds.current=((void**)&C);
  585. ds.l=217;
  586. ds.c=4;
  587. ds.f=1405;
  588. ds.caller=caller;
  589. ds.locals=locals;
  590. locals[0]=(void**)&R;
  591. locals[1]=(void**)&_entry;
  592. locals[2]=(void**)&_entry_pointer;
  593. locals[3]=(void**)&_dirstream_pointer;
  594. locals[4]=(void**)&_path_pointer;
  595. se_dst=&ds;/*link*/
  596. se_trace(&ds,225,13,1405);
  597. r1886clear(&ds,se_i1886(&ds,((T1886*)ci(1886,(C)->_name_list/*8*/,225,3,1405))));
  598. se_trace(&ds,226,3,1405);
  599. _path_pointer=r7to_external(&ds,se_i7(&ds,((T7*)ci(7,(C)->_path/*4*/,226,19,1405))));
  600. se_trace(&ds,227,3,1405);
  601. _dirstream_pointer=se_dir_open(_path_pointer);
  602. /*[IF*/
  603. if((se_trace(&ds,228,24,1405),(NULL!=_dirstream_pointer))){
  604. se_trace(&ds,230,9,1405);
  605. R=1;
  606. while (!((se_trace(&ds,232,27,1405),r8is_null(&ds,_dirstream_pointer)))) {
  607. se_trace(&ds,234,9,1405);
  608. _entry_pointer=se_dir_name(_dirstream_pointer);
  609. /*[IF*/
  610. if((se_trace(&ds,235,26,1405),(NULL!=_entry_pointer))){
  611. se_trace(&ds,236,5,1405);
  612. {T7*n=new7();
  613. r7from_external_copy(&ds,n,_entry_pointer);
  614. _entry=(T0*)n;
  615. se_i7(&ds,n);}
  616. se_trace(&ds,237,15,1405);
  617. r1886add_last(&ds,se_i1886(&ds,((T1886*)ci(1886,(C)->_name_list/*8*/,237,5,1405))),_entry);
  618. }
  619. /*FI]*/
  620. se_trace(&ds,239,9,1405);
  621. _dirstream_pointer=se_dir_next(_dirstream_pointer);
  622. }
  623. }
  624. /*FI]*/
  625. se_dst=caller;/*unlink*/
  626. return R;
  627. }
  628. se_frame_descriptor f1405update={"update of BASIC_DIRECTORY",1,5,"%R1405%Result%E6%entry%R7%entry_pointer%E8%dirstream_pointer%E8%path_pointer%E8%",1};
  629.  
  630.  
  631. T2 r1405upper(se_dump_stack*caller,T1405* C){
  632. T2 R=0;
  633. void**locals[1];
  634. se_dump_stack ds;
  635. ds.fd=&f1405upper;
  636. ds.current=((void**)&C);
  637. ds.l=43;
  638. ds.c=4;
  639. ds.f=1405;
  640. ds.caller=caller;
  641. ds.locals=locals;
  642. locals[0]=(void**)&R;
  643. se_dst=&ds;/*link*/
  644. se_trace(&ds,46,3,1405);
  645. R=(se_i1886(&ds,((T1886*)ci(1886,(C)->_name_list/*8*/,46,13,1405))))->_upper/*12*/;
  646. se_dst=caller;/*unlink*/
  647. return R;
  648. }
  649. se_frame_descriptor f1405upper={"upper of BASIC_DIRECTORY",1,1,"%R1405%Result%E2%",1};
  650.  
  651.  
  652. T0* r1405name(se_dump_stack*caller,T1405* C,T2 a1){
  653. T0* R=NULL;
  654. void**locals[2];
  655. se_dump_stack ds;
  656. ds.fd=&f1405name;
  657. ds.current=((void**)&C);
  658. ds.l=183;
  659. ds.c=4;
  660. ds.f=1405;
  661. ds.caller=caller;
  662. ds.locals=locals;
  663. locals[0]=(void**)&a1;
  664. locals[1]=(void**)&R;
  665. se_dst=&ds;/*link*/
  666. se_require_uppermost_flag=1;
  667. if(f1405name.assertion_flag){
  668. f1405name.assertion_flag=0;
  669. se_trace(&ds,186,3,1405);
  670. ac_req(r1405valid_index(&ds,C,a1));
  671. f1405name.assertion_flag=1;
  672. }
  673. se_trace(&ds,188,3,1405);
  674. R=r1886item(&ds,se_i1886(&ds,((T1886*)ci(1886,(C)->_name_list/*8*/,188,13,1405))),a1);
  675. if(f1405name.assertion_flag){
  676. f1405name.assertion_flag=0;
  677. se_trace(&ds,190,3,1405);
  678. ac_ens(r1405has(&ds,C,R));
  679. f1405name.assertion_flag=1;
  680. }
  681. se_dst=caller;/*unlink*/
  682. return R;
  683. }
  684. se_frame_descriptor f1405name={"name of BASIC_DIRECTORY",1,2,"%R1405%index%E2%Result%R7%",1};
  685.  
  686.  
  687. T6 r701standard_is_equal(se_dump_stack*caller,T701* C,T0* a1){
  688. T6 R=0;
  689. void**locals[2];
  690. se_dump_stack ds;
  691. ds.fd=&f701standard_is_equal;
  692. ds.current=((void**)&C);
  693. ds.l=120;
  694. ds.c=11;
  695. ds.f=1;
  696. ds.caller=caller;
  697. ds.locals=locals;
  698. locals[0]=(void**)&a1;
  699. locals[1]=(void**)&R;
  700. se_dst=&ds;/*link*/
  701. se_require_uppermost_flag=1;
  702. if(f701standard_is_equal.assertion_flag){
  703. f701standard_is_equal.assertion_flag=0;
  704. se_trace(&ds,123,9,1);
  705. ac_req((a1)!=((void*)(NULL)));
  706. f701standard_is_equal.assertion_flag=1;
  707. }
  708. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f701standard_is_equal.assertion_flag){
  709. f701standard_is_equal.assertion_flag=0;
  710. se_trace(&ds,126,21,1);
  711. ac_ens((!(R))||(r701standard_is_equal(&ds,((T701*)ci(701,a1,126,29,1)),(T0*)C)));
  712. f701standard_is_equal.assertion_flag=1;
  713. }
  714. se_dst=caller;/*unlink*/
  715. return R;
  716. }
  717. se_frame_descriptor f701standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R701%other%R701%Result%E6%",1};
  718.  
  719.  
  720. T6 r701is_equal(se_dump_stack*caller,T701* C,T0* a1){
  721. T6 R=0;
  722. void**locals[2];
  723. se_dump_stack ds;
  724. ds.fd=&f701is_equal;
  725. ds.current=((void**)&C);
  726. ds.l=91;
  727. ds.c=4;
  728. ds.f=1;
  729. ds.caller=caller;
  730. ds.locals=locals;
  731. locals[0]=(void**)&a1;
  732. locals[1]=(void**)&R;
  733. se_dst=&ds;/*link*/
  734. se_require_uppermost_flag=1;
  735. if(f701is_equal.assertion_flag){
  736. f701is_equal.assertion_flag=0;
  737. se_trace(&ds,95,25,1);
  738. ac_req((a1)!=((void*)(NULL)));
  739. f701is_equal.assertion_flag=1;
  740. }
  741. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f701is_equal.assertion_flag){
  742. f701is_equal.assertion_flag=0;
  743. se_trace(&ds,98,40,1);
  744. ac_ens((!(r701standard_is_equal(&ds,C,a1)))||(R));
  745. se_trace(&ds,99,21,1);
  746. ac_ens((!(R))||(r701is_equal(&ds,((T701*)ci(701,a1,99,29,1)),(T0*)C)));
  747. f701is_equal.assertion_flag=1;
  748. }
  749. se_dst=caller;/*unlink*/
  750. return R;
  751. }
  752. se_frame_descriptor f701is_equal={"is_equal of GENERAL",1,2,"%R701%other%R701%Result%E6%",1};
  753. T0*oBC1std_output=NULL;
  754. T0*oBC1io=NULL;
  755.  
  756.  
  757. T0* r701argument(se_dump_stack*caller,T701* C,T2 a1){
  758. T0* R=NULL;
  759. void**locals[2];
  760. se_dump_stack ds;
  761. ds.fd=&f701argument;
  762. ds.current=((void**)&C);
  763. ds.l=413;
  764. ds.c=4;
  765. ds.f=1;
  766. ds.caller=caller;
  767. ds.locals=locals;
  768. locals[0]=(void**)&a1;
  769. locals[1]=(void**)&R;
  770. se_dst=&ds;/*link*/
  771. se_require_uppermost_flag=1;
  772. if(f701argument.assertion_flag){
  773. f701argument.assertion_flag=0;
  774. se_trace(&ds,417,5,1);
  775. ac_req((a1)>=(0));
  776. se_trace(&ds,418,5,1);
  777. ac_req((a1)<=(r701argument_count(&ds,C)));
  778. f701argument.assertion_flag=1;
  779. }
  780. se_trace(&ds,420,3,1);
  781. R=r1886item(&ds,se_i1886(&ds,((T1886*)ci(1886,r701command_arguments(&ds),420,13,1))),a1);
  782. if(f701argument.assertion_flag){
  783. f701argument.assertion_flag=0;
  784. se_trace(&ds,422,10,1);
  785. ac_ens((R)!=((void*)(NULL)));
  786. f701argument.assertion_flag=1;
  787. }
  788. se_dst=caller;/*unlink*/
  789. return R;
  790. }
  791. se_frame_descriptor f701argument={"argument of GENERAL",1,2,"%R701%i%E2%Result%R7%",1};
  792.  
  793.  
  794. void r701make(se_dump_stack*caller,T701* C){
  795. se_dump_stack ds;
  796. ds.fd=&f701make;
  797. ds.current=((void**)&C);
  798. ds.l=11;
  799. ds.c=4;
  800. ds.f=701;
  801. ds.caller=caller;
  802. se_dst=&ds;/*link*/
  803. /*[IF*/
  804. if((se_trace(&ds,13,21,701),(r701argument_count(&ds,C))!=(1))){
  805. se_trace(&ds,14,9,701);
  806. r2074put_string(&ds,((T2074*)ci(2074,oBC1io,14,6,701)),((T0*)ms701_31430));
  807. }
  808. else{
  809. se_trace(&ds,16,6,701);
  810. r701list_directory(&ds,C,r701argument(&ds,C,1));
  811. }
  812. /*FI]*/
  813. se_dst=caller;/*unlink*/
  814. }
  815. se_frame_descriptor f701make={"make of EXAMPLE01",1,0,"%R701%",1};
  816.  
  817.  
  818. T2 r701argument_count(se_dump_stack*caller,T701* C){
  819. T2 R=0;
  820. void**locals[1];
  821. se_dump_stack ds;
  822. ds.fd=&f701argument_count;
  823. ds.current=((void**)&C);
  824. ds.l=404;
  825. ds.c=4;
  826. ds.f=1;
  827. ds.caller=caller;
  828. ds.locals=locals;
  829. locals[0]=(void**)&R;
  830. se_dst=&ds;/*link*/
  831. se_trace(&ds,408,3,1);
  832. R=(se_i1886(&ds,((T1886*)ci(1886,r701command_arguments(&ds),408,13,1))))->_upper/*12*/;
  833. if(f701argument_count.assertion_flag){
  834. f701argument_count.assertion_flag=0;
  835. se_trace(&ds,410,10,1);
  836. ac_ens((R)>=(0));
  837. f701argument_count.assertion_flag=1;
  838. }
  839. se_dst=caller;/*unlink*/
  840. return R;
  841. }
  842. se_frame_descriptor f701argument_count={"argument_count of GENERAL",1,1,"%R701%Result%E2%",1};
  843. int fBC1command_arguments=0;
  844. T0*oBC1command_arguments=NULL;
  845.  
  846.  
  847. T0* r701command_arguments(se_dump_stack*caller){
  848. if(fBC1command_arguments==0){
  849. T0* _arg=NULL;
  850. T2 _i=0;
  851. void**locals[3];
  852. se_dump_stack ds;
  853. ds.fd=&f701command_arguments;
  854. ds.current=NULL;
  855. ds.l=425;
  856. ds.c=11;
  857. ds.f=1;
  858. ds.caller=caller;
  859. ds.locals=locals;
  860. locals[0]=(void**)&oBC1command_arguments;
  861. locals[1]=(void**)&_arg;
  862. locals[2]=(void**)&_i;
  863. se_dst=&ds;/*link*/
  864. fBC1command_arguments=1;
  865. se_trace(&ds,433,6,1);
  866. _i=se_argc;
  867. se_trace(&ds,434,6,1);
  868. {T1886*n=new1886();
  869. r1886make(&ds,n,_i);
  870. oBC1command_arguments=(T0*)n;
  871. se_i1886(&ds,n);}
  872. while (!((se_trace(&ds,436,8,1),(_i)==(0)))) {
  873. se_trace(&ds,438,6,1);
  874. _i=(_i)-(1);
  875. se_trace(&ds,439,6,1);
  876. _arg=((T0*)e2s(se_argv[_i]));
  877. se_trace(&ds,440,13,1);
  878. r1886put(&ds,se_i1886(&ds,((T1886*)ci(1886,oBC1command_arguments,440,6,1))),_arg,_i);
  879. }
  880. if(f701command_arguments.assertion_flag){
  881. f701command_arguments.assertion_flag=0;
  882. se_trace(&ds,443,3,1);
  883. ac_ens(r6_ix_not(&ds,r1886empty(&ds,se_i1886(&ds,((T1886*)ci(1886,oBC1command_arguments,443,7,1))))));
  884. f701command_arguments.assertion_flag=1;
  885. }
  886. se_dst=caller;/*unlink*/
  887. }
  888. return oBC1command_arguments;}
  889. se_frame_descriptor f701command_arguments={"command_arguments of GENERAL",0,3,"Result%R1886%arg%R7%i%E2%",1};
  890.  
  891.  
  892. void r701list_directory(se_dump_stack*caller,T701* C,T0* a1){
  893. T2 _i=0;
  894. T0* _d=NULL;
  895. void**locals[3];
  896. se_dump_stack ds;
  897. ds.fd=&f701list_directory;
  898. ds.current=((void**)&C);
  899. ds.l=20;
  900. ds.c=4;
  901. ds.f=701;
  902. ds.caller=caller;
  903. ds.locals=locals;
  904. locals[0]=(void**)&a1;
  905. locals[1]=(void**)&_i;
  906. locals[2]=(void**)&_d;
  907. se_dst=&ds;/*link*/
  908. se_trace(&ds,25,14,701);
  909. X878put_string(&ds,25,3,701,oBC1std_output,((T0*)ms701_17488));
  910. se_trace(&ds,26,14,701);
  911. X878put_string(&ds,26,3,701,oBC1std_output,a1);
  912. se_trace(&ds,27,14,701);
  913. X878put_string(&ds,27,3,701,oBC1std_output,((T0*)ms701_288aa));
  914. se_trace(&ds,28,3,701);
  915. {T660*n=new660();
  916. r660connect_to(&ds,n,a1);
  917. _d=(T0*)n;
  918. }
  919. /*[IF*/
  920. if((se_trace(&ds,29,8,701),(((T660*)ci(660,_d,29,6,701)))->_is_connected/*8*/)){
  921. se_trace(&ds,30,17,701);
  922. X878put_integer(&ds,30,6,701,oBC1std_output,r660count(&ds,((T660*)ci(660,_d,30,29,701))));
  923. se_trace(&ds,31,17,701);
  924. X878put_string(&ds,31,6,701,oBC1std_output,((T0*)ms701_52800));
  925. se_trace(&ds,32,17,701);
  926. X878put_string(&ds,32,6,701,oBC1std_output,r660path(&ds,((T660*)ci(660,_d,32,28,701))));
  927. se_trace(&ds,33,17,701);
  928. X878put_string(&ds,33,6,701,oBC1std_output,((T0*)ms701_288));
  929. se_trace(&ds,35,9,701);
  930. _i=1;
  931. while (!((se_trace(&ds,37,11,701),(_i)>(r660count(&ds,((T660*)ci(660,_d,37,13,701))))))) {
  932. se_trace(&ds,39,20,701);
  933. X878put_character(&ds,39,9,701,oBC1std_output,'\11');
  934. se_trace(&ds,40,20,701);
  935. X878put_string(&ds,40,9,701,oBC1std_output,r660name(&ds,((T660*)ci(660,_d,40,31,701)),_i));
  936. se_trace(&ds,41,20,701);
  937. X878put_character(&ds,41,9,701,oBC1std_output,'\n');
  938. se_trace(&ds,42,9,701);
  939. _i=(_i)+(1);
  940. }
  941. }
  942. else{
  943. se_trace(&ds,45,17,701);
  944. X878put_string(&ds,45,6,701,oBC1std_output,((T0*)ms701_36322));
  945. se_trace(&ds,46,17,701);
  946. X878put_string(&ds,46,6,701,oBC1std_output,a1);
  947. se_trace(&ds,47,17,701);
  948. X878put_string(&ds,47,6,701,oBC1std_output,((T0*)ms701_288a));
  949. }
  950. /*FI]*/
  951. se_dst=caller;/*unlink*/
  952. }
  953. se_frame_descriptor f701list_directory={"list_directory of EXAMPLE01",1,3,"%R701%path%R7%i%E2%d%R660%",1};
  954.  
  955.  
  956. T6 r878standard_is_equal(se_dump_stack*caller,T878* C,T0* a1){
  957. T6 R=0;
  958. void**locals[2];
  959. se_dump_stack ds;
  960. ds.fd=&f878standard_is_equal;
  961. ds.current=((void**)&C);
  962. ds.l=120;
  963. ds.c=11;
  964. ds.f=1;
  965. ds.caller=caller;
  966. ds.locals=locals;
  967. locals[0]=(void**)&a1;
  968. locals[1]=(void**)&R;
  969. se_dst=&ds;/*link*/
  970. se_require_uppermost_flag=1;
  971. if(f878standard_is_equal.assertion_flag){
  972. f878standard_is_equal.assertion_flag=0;
  973. se_trace(&ds,123,9,1);
  974. ac_req((a1)!=((void*)(NULL)));
  975. f878standard_is_equal.assertion_flag=1;
  976. }
  977. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f878standard_is_equal.assertion_flag){
  978. f878standard_is_equal.assertion_flag=0;
  979. se_trace(&ds,126,21,1);
  980. ac_ens((!(R))||(X878standard_is_equal(&ds,126,29,1,a1,(T0*)C)));
  981. f878standard_is_equal.assertion_flag=1;
  982. }
  983. se_dst=caller;/*unlink*/
  984. return R;
  985. }
  986. se_frame_descriptor f878standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R878%other%R878%Result%E6%",1};
  987.  
  988.  
  989. T6 r878is_equal(se_dump_stack*caller,T878* C,T0* a1){
  990. T6 R=0;
  991. void**locals[2];
  992. se_dump_stack ds;
  993. ds.fd=&f878is_equal;
  994. ds.current=((void**)&C);
  995. ds.l=91;
  996. ds.c=4;
  997. ds.f=1;
  998. ds.caller=caller;
  999. ds.locals=locals;
  1000. locals[0]=(void**)&a1;
  1001. locals[1]=(void**)&R;
  1002. se_dst=&ds;/*link*/
  1003. se_require_uppermost_flag=1;
  1004. if(f878is_equal.assertion_flag){
  1005. f878is_equal.assertion_flag=0;
  1006. se_trace(&ds,95,25,1);
  1007. ac_req((a1)!=((void*)(NULL)));
  1008. f878is_equal.assertion_flag=1;
  1009. }
  1010. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f878is_equal.assertion_flag){
  1011. f878is_equal.assertion_flag=0;
  1012. se_trace(&ds,98,40,1);
  1013. ac_ens((!(r878standard_is_equal(&ds,C,a1)))||(R));
  1014. se_trace(&ds,99,21,1);
  1015. ac_ens((!(R))||(X878is_equal(&ds,99,29,1,a1,(T0*)C)));
  1016. f878is_equal.assertion_flag=1;
  1017. }
  1018. se_dst=caller;/*unlink*/
  1019. return R;
  1020. }
  1021. se_frame_descriptor f878is_equal={"is_equal of GENERAL",1,2,"%R878%other%R878%Result%E6%",1};
  1022. /*No:STD_OUTPUT.is_connected*/
  1023.  
  1024.  
  1025. void r878put_string(se_dump_stack*caller,T878* C,T0* a1){
  1026. T2 _i=0;
  1027. void**locals[2];
  1028. se_dump_stack ds;
  1029. ds.fd=&f878put_string;
  1030. ds.current=((void**)&C);
  1031. ds.l=34;
  1032. ds.c=4;
  1033. ds.f=1070;
  1034. ds.caller=caller;
  1035. ds.locals=locals;
  1036. locals[0]=(void**)&a1;
  1037. locals[1]=(void**)&_i;
  1038. se_dst=&ds;/*link*/
  1039. se_require_uppermost_flag=1;
  1040. if(f878put_string.assertion_flag){
  1041. f878put_string.assertion_flag=0;
  1042. se_trace(&ds,37,3,1070);
  1043. ac_req(1);
  1044. se_trace(&ds,38,5,1070);
  1045. ac_req((a1)!=((void*)(NULL)));
  1046. f878put_string.assertion_flag=1;
  1047. }
  1048. se_trace(&ds,43,6,1070);
  1049. _i=1;
  1050. while (!((se_trace(&ds,45,8,1070),(_i)>((se_i7(&ds,((T7*)ci(7,a1,45,10,1070))))->_count/*8*/)))) {
  1051. se_trace(&ds,47,6,1070);
  1052. r878put_character(&ds,C,r7item(&ds,se_i7(&ds,((T7*)ci(7,a1,47,20,1070))),_i));
  1053. se_trace(&ds,48,6,1070);
  1054. _i=(_i)+(1);
  1055. }
  1056. se_dst=caller;/*unlink*/
  1057. }
  1058. se_frame_descriptor f878put_string={"put_string of OUTPUT_STREAM",1,2,"%R878%s%R7%i%E2%",1};
  1059.  
  1060.  
  1061. void r878make(se_dump_stack*caller,T878* C){
  1062. se_dump_stack ds;
  1063. ds.fd=&f878make;
  1064. ds.current=((void**)&C);
  1065. ds.l=33;
  1066. ds.c=4;
  1067. ds.f=878;
  1068. ds.caller=caller;
  1069. se_dst=&ds;/*link*/
  1070. se_dst=caller;/*unlink*/
  1071. }
  1072. se_frame_descriptor f878make={"make of STD_OUTPUT",1,0,"%R878%",1};
  1073.  
  1074.  
  1075. void r878put_character(se_dump_stack*caller,T878* C,T3 a1){
  1076. void**locals[1];
  1077. se_dump_stack ds;
  1078. ds.fd=&f878put_character;
  1079. ds.current=((void**)&C);
  1080. ds.l=39;
  1081. ds.c=4;
  1082. ds.f=878;
  1083. ds.caller=caller;
  1084. ds.locals=locals;
  1085. locals[0]=(void**)&a1;
  1086. se_dst=&ds;/*link*/
  1087. se_require_uppermost_flag=1;
  1088. if(f878put_character.assertion_flag){
  1089. f878put_character.assertion_flag=0;
  1090. se_trace(&ds,28,3,1070);
  1091. ac_req(1);
  1092. f878put_character.assertion_flag=1;
  1093. }
  1094. se_trace(&ds,41,3,878);
  1095. putc(a1,((FILE*)(stdout)));
  1096. se_dst=caller;/*unlink*/
  1097. }
  1098. se_frame_descriptor f878put_character={"put_character of STD_OUTPUT",1,1,"%R878%c%E3%",1};
  1099. int fBC1070tmp_string=0;
  1100. T0*oBC1070tmp_string=NULL;
  1101.  
  1102.  
  1103. T0* r878tmp_string(se_dump_stack*caller){
  1104. if(fBC1070tmp_string==0){
  1105. void**locals[1];
  1106. se_dump_stack ds;
  1107. ds.fd=&f878tmp_string;
  1108. ds.current=NULL;
  1109. ds.l=216;
  1110. ds.c=4;
  1111. ds.f=1070;
  1112. ds.caller=caller;
  1113. ds.locals=locals;
  1114. locals[0]=(void**)&oBC1070tmp_string;
  1115. se_dst=&ds;/*link*/
  1116. fBC1070tmp_string=1;
  1117. se_trace(&ds,218,3,1070);
  1118. {T7*n=new7();
  1119. r7make(&ds,n,512);
  1120. oBC1070tmp_string=(T0*)n;
  1121. se_i7(&ds,n);}
  1122. se_dst=caller;/*unlink*/
  1123. }
  1124. return oBC1070tmp_string;}
  1125. se_frame_descriptor f878tmp_string={"tmp_string of OUTPUT_STREAM",0,1,"Result%R7%",1};
  1126.  
  1127.  
  1128. void r878put_integer(se_dump_stack*caller,T878* C,T2 a1){
  1129. void**locals[1];
  1130. se_dump_stack ds;
  1131. ds.fd=&f878put_integer;
  1132. ds.current=((void**)&C);
  1133. ds.l=60;
  1134. ds.c=4;
  1135. ds.f=1070;
  1136. ds.caller=caller;
  1137. ds.locals=locals;
  1138. locals[0]=(void**)&a1;
  1139. se_dst=&ds;/*link*/
  1140. se_require_uppermost_flag=1;
  1141. if(f878put_integer.assertion_flag){
  1142. f878put_integer.assertion_flag=0;
  1143. se_trace(&ds,63,3,1070);
  1144. ac_req(1);
  1145. f878put_integer.assertion_flag=1;
  1146. }
  1147. se_trace(&ds,65,14,1070);
  1148. r7clear(&ds,se_i7(&ds,((T7*)ci(7,r878tmp_string(&ds),65,3,1070))));
  1149. se_trace(&ds,66,5,1070);
  1150. r2append_in(&ds,a1,r878tmp_string(&ds));
  1151. se_trace(&ds,67,3,1070);
  1152. r878put_string(&ds,C,r878tmp_string(&ds));
  1153. se_dst=caller;/*unlink*/
  1154. }
  1155. se_frame_descriptor f878put_integer={"put_integer of OUTPUT_STREAM",1,1,"%R878%i%E2%",1};
  1156.  
  1157.  
  1158. T6 r2074standard_is_equal(se_dump_stack*caller,T2074* C,T0* a1){
  1159. T6 R=0;
  1160. void**locals[2];
  1161. se_dump_stack ds;
  1162. ds.fd=&f2074standard_is_equal;
  1163. ds.current=((void**)&C);
  1164. ds.l=120;
  1165. ds.c=11;
  1166. ds.f=1;
  1167. ds.caller=caller;
  1168. ds.locals=locals;
  1169. locals[0]=(void**)&a1;
  1170. locals[1]=(void**)&R;
  1171. se_dst=&ds;/*link*/
  1172. se_require_uppermost_flag=1;
  1173. if(f2074standard_is_equal.assertion_flag){
  1174. f2074standard_is_equal.assertion_flag=0;
  1175. se_trace(&ds,123,9,1);
  1176. ac_req((a1)!=((void*)(NULL)));
  1177. f2074standard_is_equal.assertion_flag=1;
  1178. }
  1179. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f2074standard_is_equal.assertion_flag){
  1180. f2074standard_is_equal.assertion_flag=0;
  1181. se_trace(&ds,126,21,1);
  1182. ac_ens((!(R))||(r2074standard_is_equal(&ds,((T2074*)ci(2074,a1,126,29,1)),(T0*)C)));
  1183. f2074standard_is_equal.assertion_flag=1;
  1184. }
  1185. se_dst=caller;/*unlink*/
  1186. return R;
  1187. }
  1188. se_frame_descriptor f2074standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R2074%other%R2074%Result%E6%",1};
  1189.  
  1190.  
  1191. T6 r2074is_equal(se_dump_stack*caller,T2074* C,T0* a1){
  1192. T6 R=0;
  1193. void**locals[2];
  1194. se_dump_stack ds;
  1195. ds.fd=&f2074is_equal;
  1196. ds.current=((void**)&C);
  1197. ds.l=91;
  1198. ds.c=4;
  1199. ds.f=1;
  1200. ds.caller=caller;
  1201. ds.locals=locals;
  1202. locals[0]=(void**)&a1;
  1203. locals[1]=(void**)&R;
  1204. se_dst=&ds;/*link*/
  1205. se_require_uppermost_flag=1;
  1206. if(f2074is_equal.assertion_flag){
  1207. f2074is_equal.assertion_flag=0;
  1208. se_trace(&ds,95,25,1);
  1209. ac_req((a1)!=((void*)(NULL)));
  1210. f2074is_equal.assertion_flag=1;
  1211. }
  1212. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f2074is_equal.assertion_flag){
  1213. f2074is_equal.assertion_flag=0;
  1214. se_trace(&ds,98,40,1);
  1215. ac_ens((!(r2074standard_is_equal(&ds,C,a1)))||(R));
  1216. se_trace(&ds,99,21,1);
  1217. ac_ens((!(R))||(r2074is_equal(&ds,((T2074*)ci(2074,a1,99,29,1)),(T0*)C)));
  1218. f2074is_equal.assertion_flag=1;
  1219. }
  1220. se_dst=caller;/*unlink*/
  1221. return R;
  1222. }
  1223. se_frame_descriptor f2074is_equal={"is_equal of GENERAL",1,2,"%R2074%other%R2074%Result%E6%",1};
  1224. /*No:STD_INPUT_OUTPUT.is_connected*/
  1225.  
  1226.  
  1227. void r2074put_string(se_dump_stack*caller,T2074* C,T0* a1){
  1228. T2 _i=0;
  1229. void**locals[2];
  1230. se_dump_stack ds;
  1231. ds.fd=&f2074put_string;
  1232. ds.current=((void**)&C);
  1233. ds.l=34;
  1234. ds.c=4;
  1235. ds.f=1070;
  1236. ds.caller=caller;
  1237. ds.locals=locals;
  1238. locals[0]=(void**)&a1;
  1239. locals[1]=(void**)&_i;
  1240. se_dst=&ds;/*link*/
  1241. se_require_uppermost_flag=1;
  1242. if(f2074put_string.assertion_flag){
  1243. f2074put_string.assertion_flag=0;
  1244. se_trace(&ds,38,5,1070);
  1245. ac_req((a1)!=((void*)(NULL)));
  1246. f2074put_string.assertion_flag=1;
  1247. }
  1248. se_trace(&ds,43,6,1070);
  1249. _i=1;
  1250. while (!((se_trace(&ds,45,8,1070),(_i)>((se_i7(&ds,((T7*)ci(7,a1,45,10,1070))))->_count/*8*/)))) {
  1251. se_trace(&ds,47,6,1070);
  1252. r2074put_character(&ds,C,r7item(&ds,se_i7(&ds,((T7*)ci(7,a1,47,20,1070))),_i));
  1253. se_trace(&ds,48,6,1070);
  1254. _i=(_i)+(1);
  1255. }
  1256. se_dst=caller;/*unlink*/
  1257. }
  1258. se_frame_descriptor f2074put_string={"put_string of OUTPUT_STREAM",1,2,"%R2074%s%R7%i%E2%",1};
  1259.  
  1260.  
  1261. void r2074make(se_dump_stack*caller,T2074* C){
  1262. se_dump_stack ds;
  1263. ds.fd=&f2074make;
  1264. ds.current=((void**)&C);
  1265. ds.l=33;
  1266. ds.c=4;
  1267. ds.f=878;
  1268. ds.caller=caller;
  1269. se_dst=&ds;/*link*/
  1270. se_dst=caller;/*unlink*/
  1271. }
  1272. se_frame_descriptor f2074make={"make of STD_OUTPUT",1,0,"%R2074%",1};
  1273.  
  1274.  
  1275. void r2074put_character(se_dump_stack*caller,T2074* C,T3 a1){
  1276. void**locals[1];
  1277. se_dump_stack ds;
  1278. ds.fd=&f2074put_character;
  1279. ds.current=((void**)&C);
  1280. ds.l=39;
  1281. ds.c=4;
  1282. ds.f=878;
  1283. ds.caller=caller;
  1284. ds.locals=locals;
  1285. locals[0]=(void**)&a1;
  1286. se_dst=&ds;/*link*/
  1287. se_require_uppermost_flag=1;
  1288. se_trace(&ds,41,3,878);
  1289. putc(a1,((FILE*)(stdout)));
  1290. se_dst=caller;/*unlink*/
  1291. }
  1292. se_frame_descriptor f2074put_character={"put_character of STD_OUTPUT",1,1,"%R2074%c%E3%",1};
  1293.  
  1294.  
  1295. T0* r2074tmp_string(se_dump_stack*caller){
  1296. if(fBC1070tmp_string==0){
  1297. void**locals[1];
  1298. se_dump_stack ds;
  1299. ds.fd=&f2074tmp_string;
  1300. ds.current=NULL;
  1301. ds.l=216;
  1302. ds.c=4;
  1303. ds.f=1070;
  1304. ds.caller=caller;
  1305. ds.locals=locals;
  1306. locals[0]=(void**)&oBC1070tmp_string;
  1307. se_dst=&ds;/*link*/
  1308. fBC1070tmp_string=1;
  1309. se_trace(&ds,218,3,1070);
  1310. {T7*n=new7();
  1311. r7make(&ds,n,512);
  1312. oBC1070tmp_string=(T0*)n;
  1313. se_i7(&ds,n);}
  1314. se_dst=caller;/*unlink*/
  1315. }
  1316. return oBC1070tmp_string;}
  1317. se_frame_descriptor f2074tmp_string={"tmp_string of OUTPUT_STREAM",0,1,"Result%R7%",1};
  1318.  
  1319.  
  1320. void r2074put_integer(se_dump_stack*caller,T2074* C,T2 a1){
  1321. void**locals[1];
  1322. se_dump_stack ds;
  1323. ds.fd=&f2074put_integer;
  1324. ds.current=((void**)&C);
  1325. ds.l=60;
  1326. ds.c=4;
  1327. ds.f=1070;
  1328. ds.caller=caller;
  1329. ds.locals=locals;
  1330. locals[0]=(void**)&a1;
  1331. se_dst=&ds;/*link*/
  1332. se_require_uppermost_flag=1;
  1333. se_trace(&ds,65,14,1070);
  1334. r7clear(&ds,se_i7(&ds,((T7*)ci(7,r2074tmp_string(&ds),65,3,1070))));
  1335. se_trace(&ds,66,5,1070);
  1336. r2append_in(&ds,a1,r2074tmp_string(&ds));
  1337. se_trace(&ds,67,3,1070);
  1338. r2074put_string(&ds,C,r2074tmp_string(&ds));
  1339. se_dst=caller;/*unlink*/
  1340. }
  1341. se_frame_descriptor f2074put_integer={"put_integer of OUTPUT_STREAM",1,1,"%R2074%i%E2%",1};
  1342.  
  1343.  
  1344. T6 r714standard_is_equal(se_dump_stack*caller,T714* C,T0* a1){
  1345. T6 R=0;
  1346. void**locals[2];
  1347. se_dump_stack ds;
  1348. ds.fd=&f714standard_is_equal;
  1349. ds.current=((void**)&C);
  1350. ds.l=120;
  1351. ds.c=11;
  1352. ds.f=1;
  1353. ds.caller=caller;
  1354. ds.locals=locals;
  1355. locals[0]=(void**)&a1;
  1356. locals[1]=(void**)&R;
  1357. se_dst=&ds;/*link*/
  1358. se_require_uppermost_flag=1;
  1359. if(f714standard_is_equal.assertion_flag){
  1360. f714standard_is_equal.assertion_flag=0;
  1361. se_trace(&ds,123,9,1);
  1362. ac_req((a1)!=((void*)(NULL)));
  1363. f714standard_is_equal.assertion_flag=1;
  1364. }
  1365. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f714standard_is_equal.assertion_flag){
  1366. f714standard_is_equal.assertion_flag=0;
  1367. se_trace(&ds,126,21,1);
  1368. ac_ens((!(R))||(r714standard_is_equal(&ds,((T714*)ci(714,a1,126,29,1)),(T0*)C)));
  1369. f714standard_is_equal.assertion_flag=1;
  1370. }
  1371. se_dst=caller;/*unlink*/
  1372. return R;
  1373. }
  1374. se_frame_descriptor f714standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R714%other%R714%Result%E6%",1};
  1375.  
  1376.  
  1377. T6 r714is_equal(se_dump_stack*caller,T714* C,T0* a1){
  1378. T6 R=0;
  1379. void**locals[2];
  1380. se_dump_stack ds;
  1381. ds.fd=&f714is_equal;
  1382. ds.current=((void**)&C);
  1383. ds.l=91;
  1384. ds.c=4;
  1385. ds.f=1;
  1386. ds.caller=caller;
  1387. ds.locals=locals;
  1388. locals[0]=(void**)&a1;
  1389. locals[1]=(void**)&R;
  1390. se_dst=&ds;/*link*/
  1391. se_require_uppermost_flag=1;
  1392. if(f714is_equal.assertion_flag){
  1393. f714is_equal.assertion_flag=0;
  1394. se_trace(&ds,95,25,1);
  1395. ac_req((a1)!=((void*)(NULL)));
  1396. f714is_equal.assertion_flag=1;
  1397. }
  1398. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f714is_equal.assertion_flag){
  1399. f714is_equal.assertion_flag=0;
  1400. se_trace(&ds,98,40,1);
  1401. ac_ens((!(r714standard_is_equal(&ds,C,a1)))||(R));
  1402. se_trace(&ds,99,21,1);
  1403. ac_ens((!(R))||(r714is_equal(&ds,((T714*)ci(714,a1,99,29,1)),(T0*)C)));
  1404. f714is_equal.assertion_flag=1;
  1405. }
  1406. se_dst=caller;/*unlink*/
  1407. return R;
  1408. }
  1409. se_frame_descriptor f714is_equal={"is_equal of GENERAL",1,2,"%R714%other%R714%Result%E6%",1};
  1410. /*No:CHARACTER_REF.item*/
  1411.  
  1412.  
  1413. T6 r528standard_is_equal(se_dump_stack*caller,T528* C,T0* a1){
  1414. T6 R=0;
  1415. void**locals[2];
  1416. se_dump_stack ds;
  1417. ds.fd=&f528standard_is_equal;
  1418. ds.current=((void**)&C);
  1419. ds.l=120;
  1420. ds.c=11;
  1421. ds.f=1;
  1422. ds.caller=caller;
  1423. ds.locals=locals;
  1424. locals[0]=(void**)&a1;
  1425. locals[1]=(void**)&R;
  1426. se_dst=&ds;/*link*/
  1427. se_require_uppermost_flag=1;
  1428. if(f528standard_is_equal.assertion_flag){
  1429. f528standard_is_equal.assertion_flag=0;
  1430. se_trace(&ds,123,9,1);
  1431. ac_req((a1)!=((void*)(NULL)));
  1432. f528standard_is_equal.assertion_flag=1;
  1433. }
  1434. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f528standard_is_equal.assertion_flag){
  1435. f528standard_is_equal.assertion_flag=0;
  1436. se_trace(&ds,126,21,1);
  1437. ac_ens((!(R))||(r528standard_is_equal(&ds,((T528*)ci(528,a1,126,29,1)),(T0*)C)));
  1438. f528standard_is_equal.assertion_flag=1;
  1439. }
  1440. se_dst=caller;/*unlink*/
  1441. return R;
  1442. }
  1443. se_frame_descriptor f528standard_is_equal={"standard_is_equal of GENERAL",1,2,"%R528%other%R528%Result%E6%",1};
  1444.  
  1445.  
  1446. T6 r528is_equal(se_dump_stack*caller,T528* C,T0* a1){
  1447. T6 R=0;
  1448. void**locals[2];
  1449. se_dump_stack ds;
  1450. ds.fd=&f528is_equal;
  1451. ds.current=((void**)&C);
  1452. ds.l=91;
  1453. ds.c=4;
  1454. ds.f=1;
  1455. ds.caller=caller;
  1456. ds.locals=locals;
  1457. locals[0]=(void**)&a1;
  1458. locals[1]=(void**)&R;
  1459. se_dst=&ds;/*link*/
  1460. se_require_uppermost_flag=1;
  1461. if(f528is_equal.assertion_flag){
  1462. f528is_equal.assertion_flag=0;
  1463. se_trace(&ds,95,25,1);
  1464. ac_req((a1)!=((void*)(NULL)));
  1465. f528is_equal.assertion_flag=1;
  1466. }
  1467. R=((C->id==a1->id)?!memcmp(C,a1,sizeof(*C)):0);if(f528is_equal.assertion_flag){
  1468. f528is_equal.assertion_flag=0;
  1469. se_trace(&ds,98,40,1);
  1470. ac_ens((!(r528standard_is_equal(&ds,C,a1)))||(R));
  1471. se_trace(&ds,99,21,1);
  1472. ac_ens((!(R))||(r528is_equal(&ds,((T528*)ci(528,a1,99,29,1)),(T0*)C)));
  1473. f528is_equal.assertion_flag=1;
  1474. }
  1475. se_dst=caller;/*unlink*/
  1476. return R;
  1477. }
  1478. se_frame_descriptor f528is_equal={"is_equal of GENERAL",1,2,"%R528%other%R528%Result%E6%",1};
  1479. /*No:INTEGER_REF.item*/
  1480. T701*eiffel_root_object=NULL;
  1481. int se_argc;
  1482. char**se_argv;
  1483. T7* g[2136];
  1484. T7* t[2136];
  1485. char* p[2136];
  1486. void(*se_prinT[2136])(void**);
  1487.  
  1488.  
  1489. void initialize_eiffel_runtime(int argc,char*argv[]){
  1490. se_frame_descriptor irfd={"Initialysing runtime.",0,0,"",1};
  1491. se_dump_stack ds = {NULL,NULL,0,0,0,NULL,NULL};
  1492. ds.fd=&irfd;
  1493. ds.caller=se_dst;
  1494. se_argc=argc;
  1495. se_argv=argv;
  1496. gcmt=malloc((gcmt_max+1)*sizeof(void*));
  1497. stack_bottom=((void*)(&argc));
  1498. p[0]="???";
  1499. p[204]="/home/colnet/SmallEiffel/lib_std/hashable.e";
  1500. p[592]="/home/colnet/SmallEiffel/lib_std/collection.e";
  1501. p[619]="/home/colnet/SmallEiffel/lib_std/std_input.e";
  1502. p[674]="/home/colnet/SmallEiffel/lib_std/fixed_array.e";
  1503. p[605]="/home/colnet/SmallEiffel/lib_std/pointer_ref.e";
  1504. p[660]="/home/colnet/SmallEiffel/lib_std/directory.e";
  1505. p[474]="/home/colnet/SmallEiffel/lib_std/boolean_ref.e";
  1506. p[1405]="/home/colnet/SmallEiffel/lib_std/basic_directory.e";
  1507. p[701]="./example01.e";
  1508. p[2]="/home/colnet/SmallEiffel/lib_std/integer.e";
  1509. p[869]="/home/colnet/SmallEiffel/lib_std/input_stream.e";
  1510. p[98]="/home/colnet/SmallEiffel/lib_std/any.e";
  1511. p[3]="/home/colnet/SmallEiffel/lib_std/character.e";
  1512. p[1070]="/home/colnet/SmallEiffel/lib_std/output_stream.e";
  1513. p[7]="/home/colnet/SmallEiffel/lib_std/string.e";
  1514. p[842]="/home/colnet/SmallEiffel/lib_std/native_array.e";
  1515. p[878]="/home/colnet/SmallEiffel/lib_std/std_output.e";
  1516. p[2074]="/home/colnet/SmallEiffel/lib_std/std_input_output.e";
  1517. p[8]="/home/colnet/SmallEiffel/lib_std/pointer.e";
  1518. p[375]="/home/colnet/SmallEiffel/lib_std/comparable.e";
  1519. p[714]="/home/colnet/SmallEiffel/lib_std/character_ref.e";
  1520. p[1]="/home/colnet/SmallEiffel/lib_std/general.e";
  1521. p[252]="/home/colnet/SmallEiffel/lib_std/numeric.e";
  1522. p[6]="/home/colnet/SmallEiffel/lib_std/boolean.e";
  1523. p[437]="/home/colnet/SmallEiffel/lib_std/platform.e";
  1524. p[1626]="/home/colnet/SmallEiffel/lib_std/arrayed_collection.e";
  1525. p[528]="/home/colnet/SmallEiffel/lib_std/integer_ref.e";
  1526. se_prinT[2135]=((void(*)(void**))se_prinT2135);
  1527. p[2135]=p[842];
  1528. se_prinT[660]=((void(*)(void**))se_prinT660);
  1529. se_prinT[474]=((void(*)(void**))se_prinT474);
  1530. se_prinT[1405]=((void(*)(void**))se_prinT1405);
  1531. se_prinT[701]=((void(*)(void**))se_prinT701);
  1532. se_prinT[2]=((void(*)(void**))se_prinT2);
  1533. se_prinT[3]=((void(*)(void**))se_prinT3);
  1534. se_prinT[1886]=((void(*)(void**))se_prinT1886);
  1535. p[1886]=p[674];
  1536. se_prinT[9]=((void(*)(void**))se_prinT9);
  1537. p[9]=p[842];
  1538. se_prinT[7]=((void(*)(void**))se_prinT7);
  1539. se_prinT[878]=((void(*)(void**))se_prinT878);
  1540. se_prinT[2074]=((void(*)(void**))se_prinT2074);
  1541. se_prinT[8]=((void(*)(void**))se_prinT8);
  1542. se_prinT[714]=((void(*)(void**))se_prinT714);
  1543. se_prinT[6]=((void(*)(void**))se_prinT6);
  1544. se_prinT[528]=((void(*)(void**))se_prinT528);
  1545. g[204]=e2s("HASHABLE");
  1546. g[592]=e2s("COLLECTION");
  1547. g[619]=e2s("STD_INPUT");
  1548. g[674]=e2s("FIXED_ARRAY");
  1549. g[605]=e2s("POINTER_REF");
  1550. g[660]=e2s("DIRECTORY");
  1551. g[474]=e2s("BOOLEAN_REF");
  1552. g[1405]=e2s("BASIC_DIRECTORY");
  1553. g[701]=e2s("EXAMPLE01");
  1554. g[2]=e2s("INTEGER");
  1555. g[869]=e2s("INPUT_STREAM");
  1556. g[98]=e2s("ANY");
  1557. g[3]=e2s("CHARACTER");
  1558. g[1070]=e2s("OUTPUT_STREAM");
  1559. g[7]=e2s("STRING");
  1560. g[842]=e2s("NATIVE_ARRAY");
  1561. g[878]=e2s("STD_OUTPUT");
  1562. g[2074]=e2s("STD_INPUT_OUTPUT");
  1563. g[8]=e2s("POINTER");
  1564. g[375]=e2s("COMPARABLE");
  1565. g[714]=e2s("CHARACTER_REF");
  1566. g[1]=e2s("GENERAL");
  1567. g[252]=e2s("NUMERIC");
  1568. g[6]=e2s("BOOLEAN");
  1569. g[437]=e2s("PLATFORM");
  1570. g[1626]=e2s("ARRAYED_COLLECTION");
  1571. g[528]=e2s("INTEGER_REF");
  1572. g[2135]=g[842];
  1573. g[1886]=g[674];
  1574. g[9]=g[842];
  1575. t[2135]=e2s("NATIVE_ARRAY[STRING]");
  1576. t[660]=g[660];
  1577. t[474]=g[474];
  1578. t[1405]=g[1405];
  1579. t[701]=g[701];
  1580. t[2]=g[2];
  1581. t[3]=g[3];
  1582. t[1886]=e2s("FIXED_ARRAY[STRING]");
  1583. t[9]=e2s("NATIVE_ARRAY[CHARACTER]");
  1584. t[7]=g[7];
  1585. t[878]=g[878];
  1586. t[2074]=g[2074];
  1587. t[8]=g[8];
  1588. t[714]=g[714];
  1589. t[6]=g[6];
  1590. t[528]=g[528];
  1591. #ifdef SIGINT
  1592. signal(SIGINT,sigrsp);
  1593. #endif
  1594. #ifdef SIGQUIT
  1595. signal(SIGQUIT,sigrsp);
  1596. #endif
  1597. #ifdef SIGTERM
  1598. signal(SIGTERM,sigrsp);
  1599. #endif
  1600. #ifdef SIGBREAK
  1601. signal(SIGBREAK,sigrsp);
  1602. #endif
  1603. #ifdef SIGKILL
  1604. signal(SIGKILL,sigrsp);
  1605. #endif
  1606. se_msi1();
  1607. oBC1io=NULL;
  1608. se_trace(&ds,276,3,1);
  1609. {T2074*n=new2074();
  1610. r2074make(&ds,n);
  1611. oBC1io=(T0*)n;
  1612. }
  1613. if(ds.fd->assertion_flag){
  1614. ds.fd->assertion_flag=0;
  1615. se_trace(&ds,278,10,1);
  1616. ac_ens((oBC1io)!=((void*)(NULL)));
  1617. ds.fd->assertion_flag=1;
  1618. }
  1619. /*PCO*/
  1620. oBC1std_output=NULL;
  1621. se_trace(&ds,290,3,1);
  1622. {T878*n=new878();
  1623. r878make(&ds,n);
  1624. oBC1std_output=(T0*)n;
  1625. }
  1626. /*PCO*/
  1627. gc_is_off=0;
  1628. eiffel_root_object=malloc(sizeof(double)+sizeof(*eiffel_root_object));
  1629. *eiffel_root_object=M701;
  1630. se_dst=NULL;
  1631. }
  1632. int main(int argc,char*argv[]){
  1633. initialize_eiffel_runtime(argc,argv);
  1634. {T701*n=eiffel_root_object;
  1635. se_frame_descriptor root={"System root.",1,0,"%R701%",1};
  1636. se_dump_stack ds;
  1637. ds.fd=&root;
  1638. ds.current=((void**)(&n));
  1639. ds.l=11;
  1640. ds.c=4;
  1641. ds.f=701;
  1642. ds.caller=NULL;
  1643. se_dst=&ds;/*link*/
  1644. r701make(&ds,n);
  1645. }
  1646. exit(0);
  1647. }
  1648. T7*ms701_288aa;
  1649. T7*ms701_52800;
  1650. T7*ms701_31430;
  1651. T7*ms701_17488;
  1652. T7*ms2_8350;
  1653. T7*ms701_288a;
  1654. T7*ms701_36322;
  1655. T7*ms701_288;
  1656.  
  1657.  
  1658. void se_msi1(void){
  1659. ms701_288aa=se_ms(3,"\".\n");
  1660. ms701_52800=se_ms(33," item(s) (file or directory) in \"");
  1661. ms701_31430=se_ms(35,"usage : example01 <directory_name>\n");
  1662. ms701_17488=se_ms(16,"Trying to list \"");
  1663. ms2_8350=se_ms(10,"0123456789");
  1664. ms701_288a=se_ms(3,"\".\n");
  1665. ms701_36322=se_ms(26,"Unable to open directory \"");
  1666. ms701_288=se_ms(3,"\".\n");
  1667. }
  1668.  
  1669.  
  1670. void manifest_string_mark1(void){
  1671. ((rsoh*)(ms701_288aa->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1672. ((rsoh*)(ms701_52800->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1673. ((rsoh*)(ms701_31430->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1674. ((rsoh*)(ms701_17488->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1675. ((rsoh*)(ms2_8350->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1676. ((rsoh*)(ms701_288a->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1677. ((rsoh*)(ms701_36322->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1678. ((rsoh*)(ms701_288->_storage)-1)->header.magic_flag=RSOH_MARKED;
  1679. }
  1680.  
  1681.  
  1682. void once_function_mark(void){
  1683. if(NULL!=oBC1070tmp_string)gc_mark7((void*)(oBC1070tmp_string));
  1684. if(NULL!=oBC1std_output)Xgc_mark878((void*)(oBC1std_output));
  1685. if(NULL!=oBC1io)gc_mark2074((void*)(oBC1io));
  1686. if(NULL!=oBC1command_arguments)gc_mark1886((void*)(oBC1command_arguments));
  1687. }
  1688. /*
  1689. -- This file is  free  software, which  comes  along  with  SmallEiffel. This
  1690. -- software  is  distributed  in the hope that it will be useful, but WITHOUT 
  1691. -- ANY  WARRANTY;  without  even  the  implied warranty of MERCHANTABILITY or
  1692. -- FITNESS  FOR A PARTICULAR PURPOSE. You can modify it as you want, provided
  1693. -- this header is kept unaltered, and a notification of the changes is added.
  1694. -- You  are  allowed  to  redistribute  it and sell it, alone or as a part of 
  1695. -- another product.
  1696. --          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
  1697. --            Dominique COLNET and Suzanne COLLIN - colnet@loria.fr 
  1698. --                       http://www.loria.fr/SmallEiffel
  1699. --
  1700. */
  1701. /* 
  1702.    Stack and Registers traversal for PC Linux.
  1703.    Addresses decrease as the stack grows.
  1704.    Registers are saved using SETJMP().
  1705. */
  1706.  
  1707. void mark_stack_and_registers (void) {
  1708.   void** max = stack_bottom + 4;
  1709.   void** stack_pointer;
  1710.   jmp_buf registers;
  1711.  
  1712.   (void)setjmp(registers);
  1713.   stack_pointer = ((void**)(®isters));
  1714.   while (stack_pointer < max) {
  1715.     gc_mark(*(stack_pointer++));
  1716.   }
  1717. }
  1718.  
  1719.  
  1720. void gc_start(void){
  1721. if(gc_is_off)return;
  1722. if(garbage_delayed())return;
  1723. gcmt_tail_addr=(((char*)(gcmt[gcmt_used-1]))+(gcmt[gcmt_used-1])->size);
  1724. ((gc701*)eiffel_root_object)->header.flag=FSOH_UNMARKED;
  1725. if(na_env2135.store_left>0){
  1726. na_env2135.store->header.size=na_env2135.store_left;
  1727. na_env2135.store->header.magic_flag=RSOH_FREE;
  1728. na_env2135.store_left=0;
  1729. }
  1730. na_env2135.chunk_list=NULL;
  1731. na_env2135.store_chunk=NULL;
  1732. gc_free660=NULL;
  1733. gc_free474=NULL;
  1734. gc_free1405=NULL;
  1735. gc_free701=NULL;
  1736. gc_free1886=NULL;
  1737. if(na_env9.store_left>0){
  1738. na_env9.store->header.size=na_env9.store_left;
  1739. na_env9.store->header.magic_flag=RSOH_FREE;
  1740. na_env9.store_left=0;
  1741. }
  1742. na_env9.chunk_list=NULL;
  1743. na_env9.store_chunk=NULL;
  1744. gc_free7=NULL;
  1745. gc_free878=NULL;
  1746. gc_free2074=NULL;
  1747. gc_free714=NULL;
  1748. gc_free528=NULL;
  1749. gc_mark701(eiffel_root_object);
  1750. manifest_string_mark1();
  1751. once_function_mark();
  1752. {int i=SE_MAXID-1;
  1753. while(i>=0){
  1754. if(g[i]!=NULL)gc_mark9((g[i])->_storage);
  1755. i--;}
  1756. }
  1757. {int i=SE_MAXID-1;
  1758. while(i>=0){
  1759. if(t[i]!=NULL)gc_mark9((t[i])->_storage);
  1760. i--;}
  1761. }
  1762. mark_stack_and_registers();
  1763. gc_sweep();
  1764. gc_start_count++;
  1765. }
  1766. na_env na_env2135={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark2135};
  1767. gc660*store660=NULL;
  1768. int store_left660=0;
  1769. fsoc*store_chunk660=NULL;
  1770. gc660*gc_free660=NULL;
  1771. gc474*store474=NULL;
  1772. int store_left474=0;
  1773. fsoc*store_chunk474=NULL;
  1774. gc474*gc_free474=NULL;
  1775. gc1405*store1405=NULL;
  1776. int store_left1405=0;
  1777. fsoc*store_chunk1405=NULL;
  1778. gc1405*gc_free1405=NULL;
  1779. gc701*store701=NULL;
  1780. int store_left701=0;
  1781. fsoc*store_chunk701=NULL;
  1782. gc701*gc_free701=NULL;
  1783. gc1886*store1886=NULL;
  1784. int store_left1886=0;
  1785. fsoc*store_chunk1886=NULL;
  1786. gc1886*gc_free1886=NULL;
  1787. na_env na_env9={0,NULL,NULL,NULL,(void(*)(T0*))gc_mark9};
  1788. gc7*store7=NULL;
  1789. int store_left7=0;
  1790. fsoc*store_chunk7=NULL;
  1791. gc7*gc_free7=NULL;
  1792. gc878*store878=NULL;
  1793. int store_left878=0;
  1794. fsoc*store_chunk878=NULL;
  1795. gc878*gc_free878=NULL;
  1796. gc2074*store2074=NULL;
  1797. int store_left2074=0;
  1798. fsoc*store_chunk2074=NULL;
  1799. gc2074*gc_free2074=NULL;
  1800. gc714*store714=NULL;
  1801. int store_left714=0;
  1802. fsoc*store_chunk714=NULL;
  1803. gc714*gc_free714=NULL;
  1804. gc528*store528=NULL;
  1805. int store_left528=0;
  1806. fsoc*store_chunk528=NULL;
  1807. gc528*gc_free528=NULL;
  1808.  
  1809.  
  1810. void gc_mark2135(T2135 o){
  1811. rsoh*h=((rsoh*)o)-1;
  1812. if((h->header.magic_flag)==RSOH_UNMARKED){
  1813. h->header.magic_flag=RSOH_MARKED;
  1814. {T0* e;
  1815. T0**p=((void*)(o+((((h->header.size)-sizeof(rsoh))/sizeof(e))-1)));
  1816. for(;((void*)p)>=((void*)o);p--){
  1817. e=*p;
  1818. if(NULL!=e)gc_mark7((void*)(e));
  1819.  
  1820. }
  1821. }
  1822. }}
  1823.  
  1824.  
  1825. T2135 new2135(int size){
  1826. size=(size*sizeof(T0*))+sizeof(rsoh);
  1827. if((size%sizeof(double))!=0)size+=(sizeof(double)-(size%sizeof(double)));
  1828. if (size<=(na_env2135.store_left)){
  1829. rsoh*r=na_env2135.store;
  1830. na_env2135.store_left-=size;
  1831. if(na_env2135.store_left>sizeof(rsoh)){
  1832. r->header.size=size;
  1833. na_env2135.store=((rsoh*)(((char*)(na_env2135.store))+size));
  1834. }
  1835. else {
  1836. r->header.size=size+na_env2135.store_left;
  1837. na_env2135.store_left=0;
  1838. }
  1839. (r->header.magic_flag)=RSOH_UNMARKED;
  1840. ((void)memset((r+1),0,r->header.size-sizeof(rsoh)));
  1841. return (void*)(r+1);
  1842. }
  1843. return (void*)new_na(&na_env2135,size);
  1844. }
  1845.  
  1846.  
  1847. void gc_sweep660(fsoc*c){
  1848. gc660*o1,*o2,*flt,flh;
  1849. o1=((void*)(&(c->first_object)));
  1850. if(c->header.state_type==FSO_STORE_CHUNK){
  1851. for(;o1<store660;o1++){
  1852. if((o1->header.flag)==FSOH_MARKED){
  1853. o1->header.flag=FSOH_UNMARKED;
  1854. }
  1855. else{
  1856. o1->header.next=gc_free660;
  1857. gc_free660=o1;
  1858. }
  1859. }
  1860. }
  1861. else{
  1862. int dead=1;
  1863. flh.header.next=NULL;
  1864. flt=&flh;
  1865. o2=o1+c->count_minus_one;
  1866. for(;o1<=o2;o2--){
  1867. if((o2->header.flag)==FSOH_MARKED){
  1868. o2->header.flag=FSOH_UNMARKED;
  1869. dead=0;}
  1870. else{
  1871. flt->header.next=o2;
  1872. flt=o2;
  1873. }
  1874. }
  1875. if (dead){
  1876. c->next=fsocfl;
  1877. fsocfl=c;
  1878. c->header.state_type=FSO_FREE_CHUNK;
  1879. }
  1880. else if(flh.header.next!=NULL){
  1881. flt->header.next=gc_free660;
  1882. gc_free660=flh.header.next;
  1883. }
  1884. }
  1885. }
  1886.  
  1887.  
  1888. void gc_mark660(T660*o){
  1889. se_gc_check_id(o,660);
  1890. {if(((gc660*)o)->header.flag==FSOH_UNMARKED){
  1891. ((gc660*)o)->header.flag=FSOH_MARKED;
  1892. if(NULL!=o->_basic_directory/*4*/)gc_mark1405((void*)(o->_basic_directory/*4*/));
  1893. }
  1894. }}
  1895.  
  1896.  
  1897. void gc_align_mark660(fsoc*c,gc660*p){
  1898. gc660*b=(void*)(&(c->first_object));
  1899. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store660)))return;
  1900. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  1901. if(((char*)p)<((char*)b))return;
  1902. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  1903. if(p->header.flag==FSOH_UNMARKED){
  1904. T660*o=(void*)p;
  1905. ((gc660*)o)->header.flag=FSOH_MARKED;
  1906. if(NULL!=o->_basic_directory/*4*/)gc_mark1405((void*)(o->_basic_directory/*4*/));
  1907. }
  1908. }
  1909. }
  1910. fsoc H660={{FSOC_SIZE,FSO_STORE_CHUNK,
  1911. (void(*)(mch*,void*))gc_align_mark660,
  1912. (void(*)(mch*))gc_sweep660},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc660))-1)};
  1913.  
  1914.  
  1915. T660*new660(void){
  1916. gc660*n;
  1917. if(store_left660>1){
  1918. store_left660--;
  1919. n=store660++;
  1920. }
  1921. else if (gc_free660!=NULL){
  1922. n=gc_free660;
  1923. gc_free660=n->header.next;
  1924. }
  1925. else if(store_left660==1){
  1926. store_left660=0;
  1927. store_chunk660->header.state_type=FSO_USED_CHUNK;
  1928. n=store660++;
  1929. }
  1930. else if(fsocfl!=NULL) {
  1931. store_chunk660=fsocfl;
  1932. fsocfl=fsocfl->next;
  1933. *store_chunk660=H660;
  1934. store660=(void*)(&(store_chunk660->first_object));
  1935. store_left660=H660.count_minus_one;
  1936. n=store660++;
  1937. }
  1938. else if(fsoc_count_ceil>fsoc_count) {
  1939. store_chunk660=malloc(FSOC_SIZE);
  1940. fsoc_count++;
  1941. {mch**p;
  1942. if(gcmt_used==gcmt_max){
  1943. gcmt_max<<=1;
  1944. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  1945. }
  1946. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk660));p--)
  1947. *(p+1)=*p;
  1948. *(p+1)=(mch*)store_chunk660;
  1949. }
  1950. *store_chunk660=H660;
  1951. store660=(void*)(&(store_chunk660->first_object));
  1952. store_left660=H660.count_minus_one;
  1953. n=store660++;
  1954. }
  1955. else{
  1956. gc_start();
  1957. if(NULL!=gc_free660){
  1958. n=gc_free660;
  1959. gc_free660=n->header.next;
  1960. }
  1961. else{
  1962. store_chunk660=new_fsoc();
  1963. *store_chunk660=H660;
  1964. store660=(void*)(&(store_chunk660->first_object));
  1965. store_left660=H660.count_minus_one;
  1966. n=store660++;
  1967. }
  1968. }
  1969. n->header.flag=FSOH_UNMARKED;
  1970. n->object=M660;
  1971. return (void*)n;
  1972. }
  1973.  
  1974.  
  1975. void gc_sweep474(fsoc*c){
  1976. gc474*o1,*o2,*flt,flh;
  1977. o1=((void*)(&(c->first_object)));
  1978. if(c->header.state_type==FSO_STORE_CHUNK){
  1979. for(;o1<store474;o1++){
  1980. if((o1->header.flag)==FSOH_MARKED){
  1981. o1->header.flag=FSOH_UNMARKED;
  1982. }
  1983. else{
  1984. o1->header.next=gc_free474;
  1985. gc_free474=o1;
  1986. }
  1987. }
  1988. }
  1989. else{
  1990. int dead=1;
  1991. flh.header.next=NULL;
  1992. flt=&flh;
  1993. o2=o1+c->count_minus_one;
  1994. for(;o1<=o2;o2--){
  1995. if((o2->header.flag)==FSOH_MARKED){
  1996. o2->header.flag=FSOH_UNMARKED;
  1997. dead=0;}
  1998. else{
  1999. flt->header.next=o2;
  2000. flt=o2;
  2001. }
  2002. }
  2003. if (dead){
  2004. c->next=fsocfl;
  2005. fsocfl=c;
  2006. c->header.state_type=FSO_FREE_CHUNK;
  2007. }
  2008. else if(flh.header.next!=NULL){
  2009. flt->header.next=gc_free474;
  2010. gc_free474=flh.header.next;
  2011. }
  2012. }
  2013. }
  2014.  
  2015.  
  2016. void gc_mark474(T474*o){
  2017. se_gc_check_id(o,474);
  2018. {((gc474*)o)->header.flag=FSOH_MARKED;
  2019.  
  2020. }}
  2021.  
  2022.  
  2023. void gc_align_mark474(fsoc*c,gc474*p){
  2024. gc474*b=(void*)(&(c->first_object));
  2025. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store474)))return;
  2026. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  2027. if(((char*)p)<((char*)b))return;
  2028. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  2029. if(p->header.flag==FSOH_UNMARKED){
  2030. T474*o=(void*)p;
  2031. ((gc474*)o)->header.flag=FSOH_MARKED;
  2032. }
  2033. }
  2034. }
  2035. fsoc H474={{FSOC_SIZE,FSO_STORE_CHUNK,
  2036. (void(*)(mch*,void*))gc_align_mark474,
  2037. (void(*)(mch*))gc_sweep474},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc474))-1)};
  2038.  
  2039.  
  2040. T474*new474(void){
  2041. gc474*n;
  2042. if(store_left474>1){
  2043. store_left474--;
  2044. n=store474++;
  2045. }
  2046. else if (gc_free474!=NULL){
  2047. n=gc_free474;
  2048. gc_free474=n->header.next;
  2049. }
  2050. else if(store_left474==1){
  2051. store_left474=0;
  2052. store_chunk474->header.state_type=FSO_USED_CHUNK;
  2053. n=store474++;
  2054. }
  2055. else if(fsocfl!=NULL) {
  2056. store_chunk474=fsocfl;
  2057. fsocfl=fsocfl->next;
  2058. *store_chunk474=H474;
  2059. store474=(void*)(&(store_chunk474->first_object));
  2060. store_left474=H474.count_minus_one;
  2061. n=store474++;
  2062. }
  2063. else if(fsoc_count_ceil>fsoc_count) {
  2064. store_chunk474=malloc(FSOC_SIZE);
  2065. fsoc_count++;
  2066. {mch**p;
  2067. if(gcmt_used==gcmt_max){
  2068. gcmt_max<<=1;
  2069. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  2070. }
  2071. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk474));p--)
  2072. *(p+1)=*p;
  2073. *(p+1)=(mch*)store_chunk474;
  2074. }
  2075. *store_chunk474=H474;
  2076. store474=(void*)(&(store_chunk474->first_object));
  2077. store_left474=H474.count_minus_one;
  2078. n=store474++;
  2079. }
  2080. else{
  2081. gc_start();
  2082. if(NULL!=gc_free474){
  2083. n=gc_free474;
  2084. gc_free474=n->header.next;
  2085. }
  2086. else{
  2087. store_chunk474=new_fsoc();
  2088. *store_chunk474=H474;
  2089. store474=(void*)(&(store_chunk474->first_object));
  2090. store_left474=H474.count_minus_one;
  2091. n=store474++;
  2092. }
  2093. }
  2094. n->header.flag=FSOH_UNMARKED;
  2095. n->object=M474;
  2096. return (void*)n;
  2097. }
  2098.  
  2099.  
  2100. void gc_sweep1405(fsoc*c){
  2101. gc1405*o1,*o2,*flt,flh;
  2102. o1=((void*)(&(c->first_object)));
  2103. if(c->header.state_type==FSO_STORE_CHUNK){
  2104. for(;o1<store1405;o1++){
  2105. if((o1->header.flag)==FSOH_MARKED){
  2106. o1->header.flag=FSOH_UNMARKED;
  2107. }
  2108. else{
  2109. o1->header.next=gc_free1405;
  2110. gc_free1405=o1;
  2111. }
  2112. }
  2113. }
  2114. else{
  2115. int dead=1;
  2116. flh.header.next=NULL;
  2117. flt=&flh;
  2118. o2=o1+c->count_minus_one;
  2119. for(;o1<=o2;o2--){
  2120. if((o2->header.flag)==FSOH_MARKED){
  2121. o2->header.flag=FSOH_UNMARKED;
  2122. dead=0;}
  2123. else{
  2124. flt->header.next=o2;
  2125. flt=o2;
  2126. }
  2127. }
  2128. if (dead){
  2129. c->next=fsocfl;
  2130. fsocfl=c;
  2131. c->header.state_type=FSO_FREE_CHUNK;
  2132. }
  2133. else if(flh.header.next!=NULL){
  2134. flt->header.next=gc_free1405;
  2135. gc_free1405=flh.header.next;
  2136. }
  2137. }
  2138. }
  2139.  
  2140.  
  2141. void gc_mark1405(T1405*o){
  2142. se_gc_check_id(o,1405);
  2143. {if(((gc1405*)o)->header.flag==FSOH_UNMARKED){
  2144. ((gc1405*)o)->header.flag=FSOH_MARKED;
  2145. if(NULL!=o->_name_list/*8*/)gc_mark1886((void*)(o->_name_list/*8*/));
  2146. if(NULL!=o->_path/*4*/)gc_mark7((void*)(o->_path/*4*/));
  2147. }
  2148. }}
  2149.  
  2150.  
  2151. void gc_align_mark1405(fsoc*c,gc1405*p){
  2152. gc1405*b=(void*)(&(c->first_object));
  2153. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store1405)))return;
  2154. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  2155. if(((char*)p)<((char*)b))return;
  2156. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  2157. if(p->header.flag==FSOH_UNMARKED){
  2158. T1405*o=(void*)p;
  2159. ((gc1405*)o)->header.flag=FSOH_MARKED;
  2160. if(NULL!=o->_name_list/*8*/)gc_mark1886((void*)(o->_name_list/*8*/));
  2161. if(NULL!=o->_path/*4*/)gc_mark7((void*)(o->_path/*4*/));
  2162. }
  2163. }
  2164. }
  2165. fsoc H1405={{FSOC_SIZE,FSO_STORE_CHUNK,
  2166. (void(*)(mch*,void*))gc_align_mark1405,
  2167. (void(*)(mch*))gc_sweep1405},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc1405))-1)};
  2168.  
  2169.  
  2170. T1405*new1405(void){
  2171. gc1405*n;
  2172. if(store_left1405>1){
  2173. store_left1405--;
  2174. n=store1405++;
  2175. }
  2176. else if (gc_free1405!=NULL){
  2177. n=gc_free1405;
  2178. gc_free1405=n->header.next;
  2179. }
  2180. else if(store_left1405==1){
  2181. store_left1405=0;
  2182. store_chunk1405->header.state_type=FSO_USED_CHUNK;
  2183. n=store1405++;
  2184. }
  2185. else if(fsocfl!=NULL) {
  2186. store_chunk1405=fsocfl;
  2187. fsocfl=fsocfl->next;
  2188. *store_chunk1405=H1405;
  2189. store1405=(void*)(&(store_chunk1405->first_object));
  2190. store_left1405=H1405.count_minus_one;
  2191. n=store1405++;
  2192. }
  2193. else if(fsoc_count_ceil>fsoc_count) {
  2194. store_chunk1405=malloc(FSOC_SIZE);
  2195. fsoc_count++;
  2196. {mch**p;
  2197. if(gcmt_used==gcmt_max){
  2198. gcmt_max<<=1;
  2199. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  2200. }
  2201. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk1405));p--)
  2202. *(p+1)=*p;
  2203. *(p+1)=(mch*)store_chunk1405;
  2204. }
  2205. *store_chunk1405=H1405;
  2206. store1405=(void*)(&(store_chunk1405->first_object));
  2207. store_left1405=H1405.count_minus_one;
  2208. n=store1405++;
  2209. }
  2210. else{
  2211. gc_start();
  2212. if(NULL!=gc_free1405){
  2213. n=gc_free1405;
  2214. gc_free1405=n->header.next;
  2215. }
  2216. else{
  2217. store_chunk1405=new_fsoc();
  2218. *store_chunk1405=H1405;
  2219. store1405=(void*)(&(store_chunk1405->first_object));
  2220. store_left1405=H1405.count_minus_one;
  2221. n=store1405++;
  2222. }
  2223. }
  2224. n->header.flag=FSOH_UNMARKED;
  2225. n->object=M1405;
  2226. return (void*)n;
  2227. }
  2228.  
  2229.  
  2230. void gc_sweep701(fsoc*c){
  2231. gc701*o1,*o2,*flt,flh;
  2232. o1=((void*)(&(c->first_object)));
  2233. if(c->header.state_type==FSO_STORE_CHUNK){
  2234. for(;o1<store701;o1++){
  2235. if((o1->header.flag)==FSOH_MARKED){
  2236. o1->header.flag=FSOH_UNMARKED;
  2237. }
  2238. else{
  2239. o1->header.next=gc_free701;
  2240. gc_free701=o1;
  2241. }
  2242. }
  2243. }
  2244. else{
  2245. int dead=1;
  2246. flh.header.next=NULL;
  2247. flt=&flh;
  2248. o2=o1+c->count_minus_one;
  2249. for(;o1<=o2;o2--){
  2250. if((o2->header.flag)==FSOH_MARKED){
  2251. o2->header.flag=FSOH_UNMARKED;
  2252. dead=0;}
  2253. else{
  2254. flt->header.next=o2;
  2255. flt=o2;
  2256. }
  2257. }
  2258. if (dead){
  2259. c->next=fsocfl;
  2260. fsocfl=c;
  2261. c->header.state_type=FSO_FREE_CHUNK;
  2262. }
  2263. else if(flh.header.next!=NULL){
  2264. flt->header.next=gc_free701;
  2265. gc_free701=flh.header.next;
  2266. }
  2267. }
  2268. }
  2269.  
  2270.  
  2271. void gc_mark701(T701*o){
  2272. se_gc_check_id(o,701);
  2273. {((gc701*)o)->header.flag=FSOH_MARKED;
  2274.  
  2275. }}
  2276.  
  2277.  
  2278. void gc_align_mark701(fsoc*c,gc701*p){
  2279. gc701*b=(void*)(&(c->first_object));
  2280. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store701)))return;
  2281. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  2282. if(((char*)p)<((char*)b))return;
  2283. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  2284. if(p->header.flag==FSOH_UNMARKED){
  2285. T701*o=(void*)p;
  2286. ((gc701*)o)->header.flag=FSOH_MARKED;
  2287. }
  2288. }
  2289. }
  2290. fsoc H701={{FSOC_SIZE,FSO_STORE_CHUNK,
  2291. (void(*)(mch*,void*))gc_align_mark701,
  2292. (void(*)(mch*))gc_sweep701},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc701))-1)};
  2293.  
  2294.  
  2295. T701*new701(void){
  2296. gc701*n;
  2297. if(store_left701>1){
  2298. store_left701--;
  2299. n=store701++;
  2300. }
  2301. else if (gc_free701!=NULL){
  2302. n=gc_free701;
  2303. gc_free701=n->header.next;
  2304. }
  2305. else if(store_left701==1){
  2306. store_left701=0;
  2307. store_chunk701->header.state_type=FSO_USED_CHUNK;
  2308. n=store701++;
  2309. }
  2310. else if(fsocfl!=NULL) {
  2311. store_chunk701=fsocfl;
  2312. fsocfl=fsocfl->next;
  2313. *store_chunk701=H701;
  2314. store701=(void*)(&(store_chunk701->first_object));
  2315. store_left701=H701.count_minus_one;
  2316. n=store701++;
  2317. }
  2318. else if(fsoc_count_ceil>fsoc_count) {
  2319. store_chunk701=malloc(FSOC_SIZE);
  2320. fsoc_count++;
  2321. {mch**p;
  2322. if(gcmt_used==gcmt_max){
  2323. gcmt_max<<=1;
  2324. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  2325. }
  2326. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk701));p--)
  2327. *(p+1)=*p;
  2328. *(p+1)=(mch*)store_chunk701;
  2329. }
  2330. *store_chunk701=H701;
  2331. store701=(void*)(&(store_chunk701->first_object));
  2332. store_left701=H701.count_minus_one;
  2333. n=store701++;
  2334. }
  2335. else{
  2336. gc_start();
  2337. if(NULL!=gc_free701){
  2338. n=gc_free701;
  2339. gc_free701=n->header.next;
  2340. }
  2341. else{
  2342. store_chunk701=new_fsoc();
  2343. *store_chunk701=H701;
  2344. store701=(void*)(&(store_chunk701->first_object));
  2345. store_left701=H701.count_minus_one;
  2346. n=store701++;
  2347. }
  2348. }
  2349. n->header.flag=FSOH_UNMARKED;
  2350. n->object=M701;
  2351. return (void*)n;
  2352. }
  2353.  
  2354.  
  2355. void gc_sweep1886(fsoc*c){
  2356. gc1886*o1,*o2,*flt,flh;
  2357. o1=((void*)(&(c->first_object)));
  2358. if(c->header.state_type==FSO_STORE_CHUNK){
  2359. for(;o1<store1886;o1++){
  2360. if((o1->header.flag)==FSOH_MARKED){
  2361. o1->header.flag=FSOH_UNMARKED;
  2362. }
  2363. else{
  2364. o1->header.next=gc_free1886;
  2365. gc_free1886=o1;
  2366. }
  2367. }
  2368. }
  2369. else{
  2370. int dead=1;
  2371. flh.header.next=NULL;
  2372. flt=&flh;
  2373. o2=o1+c->count_minus_one;
  2374. for(;o1<=o2;o2--){
  2375. if((o2->header.flag)==FSOH_MARKED){
  2376. o2->header.flag=FSOH_UNMARKED;
  2377. dead=0;}
  2378. else{
  2379. flt->header.next=o2;
  2380. flt=o2;
  2381. }
  2382. }
  2383. if (dead){
  2384. c->next=fsocfl;
  2385. fsocfl=c;
  2386. c->header.state_type=FSO_FREE_CHUNK;
  2387. }
  2388. else if(flh.header.next!=NULL){
  2389. flt->header.next=gc_free1886;
  2390. gc_free1886=flh.header.next;
  2391. }
  2392. }
  2393. }
  2394.  
  2395.  
  2396. void gc_mark1886(T1886*o){
  2397. se_gc_check_id(o,1886);
  2398. {if(((gc1886*)o)->header.flag==FSOH_UNMARKED){
  2399. ((gc1886*)o)->header.flag=FSOH_MARKED;
  2400. if(NULL!=o->_storage/*4*/)gc_mark2135((o->_storage/*4*/));
  2401. }
  2402. }}
  2403.  
  2404.  
  2405. void gc_align_mark1886(fsoc*c,gc1886*p){
  2406. gc1886*b=(void*)(&(c->first_object));
  2407. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store1886)))return;
  2408. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  2409. if(((char*)p)<((char*)b))return;
  2410. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  2411. if(p->header.flag==FSOH_UNMARKED){
  2412. T1886*o=(void*)p;
  2413. ((gc1886*)o)->header.flag=FSOH_MARKED;
  2414. if(NULL!=o->_storage/*4*/)gc_mark2135((o->_storage/*4*/));
  2415. }
  2416. }
  2417. }
  2418. fsoc H1886={{FSOC_SIZE,FSO_STORE_CHUNK,
  2419. (void(*)(mch*,void*))gc_align_mark1886,
  2420. (void(*)(mch*))gc_sweep1886},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc1886))-1)};
  2421.  
  2422.  
  2423. T1886*new1886(void){
  2424. gc1886*n;
  2425. if(store_left1886>1){
  2426. store_left1886--;
  2427. n=store1886++;
  2428. }
  2429. else if (gc_free1886!=NULL){
  2430. n=gc_free1886;
  2431. gc_free1886=n->header.next;
  2432. }
  2433. else if(store_left1886==1){
  2434. store_left1886=0;
  2435. store_chunk1886->header.state_type=FSO_USED_CHUNK;
  2436. n=store1886++;
  2437. }
  2438. else if(fsocfl!=NULL) {
  2439. store_chunk1886=fsocfl;
  2440. fsocfl=fsocfl->next;
  2441. *store_chunk1886=H1886;
  2442. store1886=(void*)(&(store_chunk1886->first_object));
  2443. store_left1886=H1886.count_minus_one;
  2444. n=store1886++;
  2445. }
  2446. else if(fsoc_count_ceil>fsoc_count) {
  2447. store_chunk1886=malloc(FSOC_SIZE);
  2448. fsoc_count++;
  2449. {mch**p;
  2450. if(gcmt_used==gcmt_max){
  2451. gcmt_max<<=1;
  2452. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  2453. }
  2454. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk1886));p--)
  2455. *(p+1)=*p;
  2456. *(p+1)=(mch*)store_chunk1886;
  2457. }
  2458. *store_chunk1886=H1886;
  2459. store1886=(void*)(&(store_chunk1886->first_object));
  2460. store_left1886=H1886.count_minus_one;
  2461. n=store1886++;
  2462. }
  2463. else{
  2464. gc_start();
  2465. if(NULL!=gc_free1886){
  2466. n=gc_free1886;
  2467. gc_free1886=n->header.next;
  2468. }
  2469. else{
  2470. store_chunk1886=new_fsoc();
  2471. *store_chunk1886=H1886;
  2472. store1886=(void*)(&(store_chunk1886->first_object));
  2473. store_left1886=H1886.count_minus_one;
  2474. n=store1886++;
  2475. }
  2476. }
  2477. n->header.flag=FSOH_UNMARKED;
  2478. n->object=M1886;
  2479. return (void*)n;
  2480. }
  2481.  
  2482.  
  2483. void gc_mark9(T9 o){
  2484. (((rsoh*)o)-1)->header.magic_flag=RSOH_MARKED;
  2485. }
  2486.  
  2487.  
  2488. T9 new9(int size){
  2489. size=(size*sizeof(T3))+sizeof(rsoh);
  2490. if((size%sizeof(double))!=0)size+=(sizeof(double)-(size%sizeof(double)));
  2491. if (size<=(na_env9.store_left)){
  2492. rsoh*r=na_env9.store;
  2493. na_env9.store_left-=size;
  2494. if(na_env9.store_left>sizeof(rsoh)){
  2495. r->header.size=size;
  2496. na_env9.store=((rsoh*)(((char*)(na_env9.store))+size));
  2497. }
  2498. else {
  2499. r->header.size=size+na_env9.store_left;
  2500. na_env9.store_left=0;
  2501. }
  2502. (r->header.magic_flag)=RSOH_UNMARKED;
  2503. ((void)memset((r+1),0,r->header.size-sizeof(rsoh)));
  2504. return (void*)(r+1);
  2505. }
  2506. return (void*)new_na(&na_env9,size);
  2507. }
  2508.  
  2509.  
  2510. void gc_sweep7(fsoc*c){
  2511. gc7*o1,*o2,*flt,flh;
  2512. o1=((void*)(&(c->first_object)));
  2513. if(c->header.state_type==FSO_STORE_CHUNK){
  2514. for(;o1<store7;o1++){
  2515. if((o1->header.flag)==FSOH_MARKED){
  2516. o1->header.flag=FSOH_UNMARKED;
  2517. }
  2518. else{
  2519. o1->header.next=gc_free7;
  2520. gc_free7=o1;
  2521. }
  2522. }
  2523. }
  2524. else{
  2525. int dead=1;
  2526. flh.header.next=NULL;
  2527. flt=&flh;
  2528. o2=o1+c->count_minus_one;
  2529. for(;o1<=o2;o2--){
  2530. if((o2->header.flag)==FSOH_MARKED){
  2531. o2->header.flag=FSOH_UNMARKED;
  2532. dead=0;}
  2533. else{
  2534. flt->header.next=o2;
  2535. flt=o2;
  2536. }
  2537. }
  2538. if (dead){
  2539. c->next=fsocfl;
  2540. fsocfl=c;
  2541. c->header.state_type=FSO_FREE_CHUNK;
  2542. }
  2543. else if(flh.header.next!=NULL){
  2544. flt->header.next=gc_free7;
  2545. gc_free7=flh.header.next;
  2546. }
  2547. }
  2548. }
  2549.  
  2550.  
  2551. void gc_mark7(T7*o){
  2552. se_gc_check_id(o,7);
  2553. {if(((gc7*)o)->header.flag==FSOH_UNMARKED){
  2554. ((gc7*)o)->header.flag=FSOH_MARKED;
  2555. if(NULL!=o->_storage/*4*/)gc_mark9((o->_storage/*4*/));
  2556. }
  2557. }}
  2558.  
  2559.  
  2560. void gc_align_mark7(fsoc*c,gc7*p){
  2561. gc7*b=(void*)(&(c->first_object));
  2562. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store7)))return;
  2563. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  2564. if(((char*)p)<((char*)b))return;
  2565. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  2566. if(p->header.flag==FSOH_UNMARKED){
  2567. T7*o=(void*)p;
  2568. ((gc7*)o)->header.flag=FSOH_MARKED;
  2569. if(NULL!=o->_storage/*4*/)gc_mark9((o->_storage/*4*/));
  2570. }
  2571. }
  2572. }
  2573. fsoc H7={{FSOC_SIZE,FSO_STORE_CHUNK,
  2574. (void(*)(mch*,void*))gc_align_mark7,
  2575. (void(*)(mch*))gc_sweep7},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc7))-1)};
  2576.  
  2577.  
  2578. T7*new7(void){
  2579. gc7*n;
  2580. if(store_left7>1){
  2581. store_left7--;
  2582. n=store7++;
  2583. }
  2584. else if (gc_free7!=NULL){
  2585. n=gc_free7;
  2586. gc_free7=n->header.next;
  2587. }
  2588. else if(store_left7==1){
  2589. store_left7=0;
  2590. store_chunk7->header.state_type=FSO_USED_CHUNK;
  2591. n=store7++;
  2592. }
  2593. else if(fsocfl!=NULL) {
  2594. store_chunk7=fsocfl;
  2595. fsocfl=fsocfl->next;
  2596. *store_chunk7=H7;
  2597. store7=(void*)(&(store_chunk7->first_object));
  2598. store_left7=H7.count_minus_one;
  2599. n=store7++;
  2600. }
  2601. else if(fsoc_count_ceil>fsoc_count) {
  2602. store_chunk7=malloc(FSOC_SIZE);
  2603. fsoc_count++;
  2604. {mch**p;
  2605. if(gcmt_used==gcmt_max){
  2606. gcmt_max<<=1;
  2607. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  2608. }
  2609. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk7));p--)
  2610. *(p+1)=*p;
  2611. *(p+1)=(mch*)store_chunk7;
  2612. }
  2613. *store_chunk7=H7;
  2614. store7=(void*)(&(store_chunk7->first_object));
  2615. store_left7=H7.count_minus_one;
  2616. n=store7++;
  2617. }
  2618. else{
  2619. gc_start();
  2620. if(NULL!=gc_free7){
  2621. n=gc_free7;
  2622. gc_free7=n->header.next;
  2623. }
  2624. else{
  2625. store_chunk7=new_fsoc();
  2626. *store_chunk7=H7;
  2627. store7=(void*)(&(store_chunk7->first_object));
  2628. store_left7=H7.count_minus_one;
  2629. n=store7++;
  2630. }
  2631. }
  2632. n->header.flag=FSOH_UNMARKED;
  2633. n->object=M7;
  2634. return (void*)n;
  2635. }
  2636.  
  2637.  
  2638. void gc_sweep878(fsoc*c){
  2639. gc878*o1,*o2,*flt,flh;
  2640. o1=((void*)(&(c->first_object)));
  2641. if(c->header.state_type==FSO_STORE_CHUNK){
  2642. for(;o1<store878;o1++){
  2643. if((o1->header.flag)==FSOH_MARKED){
  2644. o1->header.flag=FSOH_UNMARKED;
  2645. }
  2646. else{
  2647. o1->header.next=gc_free878;
  2648. gc_free878=o1;
  2649. }
  2650. }
  2651. }
  2652. else{
  2653. int dead=1;
  2654. flh.header.next=NULL;
  2655. flt=&flh;
  2656. o2=o1+c->count_minus_one;
  2657. for(;o1<=o2;o2--){
  2658. if((o2->header.flag)==FSOH_MARKED){
  2659. o2->header.flag=FSOH_UNMARKED;
  2660. dead=0;}
  2661. else{
  2662. flt->header.next=o2;
  2663. flt=o2;
  2664. }
  2665. }
  2666. if (dead){
  2667. c->next=fsocfl;
  2668. fsocfl=c;
  2669. c->header.state_type=FSO_FREE_CHUNK;
  2670. }
  2671. else if(flh.header.next!=NULL){
  2672. flt->header.next=gc_free878;
  2673. gc_free878=flh.header.next;
  2674. }
  2675. }
  2676. }
  2677.  
  2678.  
  2679. void gc_mark878(T878*o){
  2680. se_gc_check_id(o,878);
  2681. {((gc878*)o)->header.flag=FSOH_MARKED;
  2682.  
  2683. }}
  2684.  
  2685.  
  2686. void gc_align_mark878(fsoc*c,gc878*p){
  2687. gc878*b=(void*)(&(c->first_object));
  2688. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store878)))return;
  2689. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  2690. if(((char*)p)<((char*)b))return;
  2691. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  2692. if(p->header.flag==FSOH_UNMARKED){
  2693. T878*o=(void*)p;
  2694. ((gc878*)o)->header.flag=FSOH_MARKED;
  2695. }
  2696. }
  2697. }
  2698. fsoc H878={{FSOC_SIZE,FSO_STORE_CHUNK,
  2699. (void(*)(mch*,void*))gc_align_mark878,
  2700. (void(*)(mch*))gc_sweep878},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc878))-1)};
  2701.  
  2702.  
  2703. T878*new878(void){
  2704. gc878*n;
  2705. if(store_left878>1){
  2706. store_left878--;
  2707. n=store878++;
  2708. }
  2709. else if (gc_free878!=NULL){
  2710. n=gc_free878;
  2711. gc_free878=n->header.next;
  2712. }
  2713. else if(store_left878==1){
  2714. store_left878=0;
  2715. store_chunk878->header.state_type=FSO_USED_CHUNK;
  2716. n=store878++;
  2717. }
  2718. else if(fsocfl!=NULL) {
  2719. store_chunk878=fsocfl;
  2720. fsocfl=fsocfl->next;
  2721. *store_chunk878=H878;
  2722. store878=(void*)(&(store_chunk878->first_object));
  2723. store_left878=H878.count_minus_one;
  2724. n=store878++;
  2725. }
  2726. else if(fsoc_count_ceil>fsoc_count) {
  2727. store_chunk878=malloc(FSOC_SIZE);
  2728. fsoc_count++;
  2729. {mch**p;
  2730. if(gcmt_used==gcmt_max){
  2731. gcmt_max<<=1;
  2732. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  2733. }
  2734. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk878));p--)
  2735. *(p+1)=*p;
  2736. *(p+1)=(mch*)store_chunk878;
  2737. }
  2738. *store_chunk878=H878;
  2739. store878=(void*)(&(store_chunk878->first_object));
  2740. store_left878=H878.count_minus_one;
  2741. n=store878++;
  2742. }
  2743. else{
  2744. gc_start();
  2745. if(NULL!=gc_free878){
  2746. n=gc_free878;
  2747. gc_free878=n->header.next;
  2748. }
  2749. else{
  2750. store_chunk878=new_fsoc();
  2751. *store_chunk878=H878;
  2752. store878=(void*)(&(store_chunk878->first_object));
  2753. store_left878=H878.count_minus_one;
  2754. n=store878++;
  2755. }
  2756. }
  2757. n->header.flag=FSOH_UNMARKED;
  2758. n->object=M878;
  2759. return (void*)n;
  2760. }
  2761.  
  2762.  
  2763. void gc_sweep2074(fsoc*c){
  2764. gc2074*o1,*o2,*flt,flh;
  2765. o1=((void*)(&(c->first_object)));
  2766. if(c->header.state_type==FSO_STORE_CHUNK){
  2767. for(;o1<store2074;o1++){
  2768. if((o1->header.flag)==FSOH_MARKED){
  2769. o1->header.flag=FSOH_UNMARKED;
  2770. }
  2771. else{
  2772. o1->header.next=gc_free2074;
  2773. gc_free2074=o1;
  2774. }
  2775. }
  2776. }
  2777. else{
  2778. int dead=1;
  2779. flh.header.next=NULL;
  2780. flt=&flh;
  2781. o2=o1+c->count_minus_one;
  2782. for(;o1<=o2;o2--){
  2783. if((o2->header.flag)==FSOH_MARKED){
  2784. o2->header.flag=FSOH_UNMARKED;
  2785. dead=0;}
  2786. else{
  2787. flt->header.next=o2;
  2788. flt=o2;
  2789. }
  2790. }
  2791. if (dead){
  2792. c->next=fsocfl;
  2793. fsocfl=c;
  2794. c->header.state_type=FSO_FREE_CHUNK;
  2795. }
  2796. else if(flh.header.next!=NULL){
  2797. flt->header.next=gc_free2074;
  2798. gc_free2074=flh.header.next;
  2799. }
  2800. }
  2801. }
  2802.  
  2803.  
  2804. void gc_mark2074(T2074*o){
  2805. se_gc_check_id(o,2074);
  2806. {((gc2074*)o)->header.flag=FSOH_MARKED;
  2807.  
  2808. }}
  2809.  
  2810.  
  2811. void gc_align_mark2074(fsoc*c,gc2074*p){
  2812. gc2074*b=(void*)(&(c->first_object));
  2813. if((c->header.state_type==FSO_STORE_CHUNK)&&(((char*)p)>=((char*)store2074)))return;
  2814. if(((char*)p)>((char*)(b+(c->count_minus_one))))return;
  2815. if(((char*)p)<((char*)b))return;
  2816. if(((((char*)p)-((char*)b))%sizeof(*p))==0){
  2817. if(p->header.flag==FSOH_UNMARKED){
  2818. T2074*o=(void*)p;
  2819. ((gc2074*)o)->header.flag=FSOH_MARKED;
  2820. }
  2821. }
  2822. }
  2823. fsoc H2074={{FSOC_SIZE,FSO_STORE_CHUNK,
  2824. (void(*)(mch*,void*))gc_align_mark2074,
  2825. (void(*)(mch*))gc_sweep2074},NULL,(((FSOC_SIZE-sizeof(fsoc)+sizeof(double))/sizeof(gc2074))-1)};
  2826.  
  2827.  
  2828. T2074*new2074(void){
  2829. gc2074*n;
  2830. if(store_left2074>1){
  2831. store_left2074--;
  2832. n=store2074++;
  2833. }
  2834. else if (gc_free2074!=NULL){
  2835. n=gc_free2074;
  2836. gc_free2074=n->header.next;
  2837. }
  2838. else if(store_left2074==1){
  2839. store_left2074=0;
  2840. store_chunk2074->header.state_type=FSO_USED_CHUNK;
  2841. n=store2074++;
  2842. }
  2843. else if(fsocfl!=NULL) {
  2844. store_chunk2074=fsocfl;
  2845. fsocfl=fsocfl->next;
  2846. *store_chunk2074=H2074;
  2847. store2074=(void*)(&(store_chunk2074->first_object));
  2848. store_left2074=H2074.count_minus_one;
  2849. n=store2074++;
  2850. }
  2851. else if(fsoc_count_ceil>fsoc_count) {
  2852. store_chunk2074=malloc(FSOC_SIZE);
  2853. fsoc_count++;
  2854. {mch**p;
  2855. if(gcmt_used==gcmt_max){
  2856. gcmt_max<<=1;
  2857. gcmt=realloc(gcmt,(gcmt_max+1)*sizeof(void*));
  2858. }
  2859. for(p=gcmt+(gcmt_used++ -1);(p>=gcmt)&&(*p>((mch*)store_chunk2074));p--)
  2860. *(p+1)=*p;
  2861. *(p+1)=(mch*)store_chunk2074;
  2862. }
  2863. *store_chunk2074=H2074;
  2864. store2074=(void*)(&(store_chunk2074->first_object));
  2865. store_left2074=H2074.count_minus_one;
  2866. n=store2074++;
  2867. }
  2868. else{
  2869. gc_start();
  2870. if(NULL!=gc_free2074){
  2871. n=gc_free2074;
  2872. gc_free2074=n->header.next;
  2873. }
  2874. else{
  2875. store_chunk2074=new_fsoc();
  2876. *store_chunk2074=H2074;
  2877. store2074=(void*)(&(store_chunk2074->first_object));
  2878. store_left2074=H2074.count_minus_one;
  2879. n=store2074++;
  2880. }
  2881. }
  2882. n->header.flag=FSOH_UNMARKED;
  2883. n->object=M2074;
  2884. return (void*)n;
  2885. }
  2886.  
  2887.  
  2888. void gc_sweep714(fsoc*c){
  2889. gc714*o1,*o2,*flt,flh;
  2890. o1=((void*)(&(c->first_object)));
  2891. if(c->header.state_type==FSO_STORE_CHUNK){
  2892. for(;o1<store714;o1++){
  2893. if((o1->header.flag)==FSOH_MARKED){
  2894. o1->header.flag=FSOH_UNMARKED;
  2895. }
  2896. else{
  2897. o1->header.next=gc_free714;
  2898. gc_free714=o1;
  2899. }
  2900. }
  2901. }
  2902. else{
  2903. int dead=1;
  2904. flh.header.next=NULL;
  2905. flt=&flh;
  2906. o2=o1+c->count_minus_one;
  2907. for(;o1<=o2;o2--){
  2908. if((o2->header.flag)==FSOH_MARKED){
  2909. o2->header.flag=FSOH_UNMARKED;
  2910. dead=0;}
  2911. else{
  2912. flt->header.next=o2;
  2913. flt=o2;
  2914. }
  2915. }
  2916. if (dead){
  2917. c->next=fsocfl;
  2918. fsocfl=c;
  2919. c->header.state_type=FSO_FREE_CHUNK;
  2920. }
  2921. else if(flh.header.next!=NULL){
  2922. flt->header.next=gc_free714;
  2923. gc_free714=flh.header.next;
  2924. }
  2925. }
  2926. }
  2927.  
  2928.  
  2929. void gc_mark714(T714*o){
  2930. se_gc_check_id(o,714);
  2931. {((gc714*)o)->header.flag=FSOH_MARKED;
  2932.  
  2933. }}
  2934.  
  2935.