1 #ifndef AVOID_PRECOMPILED
2 /* C file produced by GAC */
3 #include "compiled.h"
4 #define FILE_CRC "-88497608"
5
6 /* global variables used in handlers */
7 static GVar G_NAME__FUNC;
8 static Obj GF_NAME__FUNC;
9 static GVar G_SetFilterObj;
10 static Obj GF_SetFilterObj;
11 static GVar G_ResetFilterObj;
12 static Obj GF_ResetFilterObj;
13 static GVar G_IS__REC;
14 static Obj GF_IS__REC;
15 static GVar G_IS__LIST;
16 static Obj GF_IS__LIST;
17 static GVar G_ADD__LIST;
18 static Obj GF_ADD__LIST;
19 static GVar G_Error;
20 static Obj GF_Error;
21 static GVar G_TYPE__OBJ;
22 static Obj GC_TYPE__OBJ;
23 static Obj GF_TYPE__OBJ;
24 static GVar G_FAMILY__OBJ;
25 static Obj GC_FAMILY__OBJ;
26 static GVar G_IMMUTABLE__COPY__OBJ;
27 static Obj GF_IMMUTABLE__COPY__OBJ;
28 static GVar G_IS__IDENTICAL__OBJ;
29 static Obj GF_IS__IDENTICAL__OBJ;
30 static GVar G_IS__COMOBJ;
31 static Obj GF_IS__COMOBJ;
32 static GVar G_SET__TYPE__COMOBJ;
33 static Obj GF_SET__TYPE__COMOBJ;
34 static GVar G_IS__POSOBJ;
35 static Obj GF_IS__POSOBJ;
36 static GVar G_SET__TYPE__POSOBJ;
37 static Obj GF_SET__TYPE__POSOBJ;
38 static GVar G_LEN__POSOBJ;
39 static Obj GF_LEN__POSOBJ;
40 static GVar G_IS__DATOBJ;
41 static Obj GF_IS__DATOBJ;
42 static GVar G_SET__TYPE__DATOBJ;
43 static Obj GF_SET__TYPE__DATOBJ;
44 static GVar G_FORCE__SWITCH__OBJ;
45 static Obj GF_FORCE__SWITCH__OBJ;
46 static GVar G_MakeImmutable;
47 static Obj GF_MakeImmutable;
48 static GVar G_IS__OBJECT;
49 static Obj GC_IS__OBJECT;
50 static GVar G_AND__FLAGS;
51 static Obj GF_AND__FLAGS;
52 static GVar G_SUB__FLAGS;
53 static Obj GF_SUB__FLAGS;
54 static GVar G_HASH__FLAGS;
55 static Obj GF_HASH__FLAGS;
56 static GVar G_IS__EQUAL__FLAGS;
57 static Obj GF_IS__EQUAL__FLAGS;
58 static GVar G_WITH__IMPS__FLAGS;
59 static Obj GF_WITH__IMPS__FLAGS;
60 static GVar G_IS__SUBSET__FLAGS;
61 static Obj GF_IS__SUBSET__FLAGS;
62 static GVar G_FLAG1__FILTER;
63 static Obj GF_FLAG1__FILTER;
64 static GVar G_FLAGS__FILTER;
65 static Obj GF_FLAGS__FILTER;
66 static GVar G_METHODS__OPERATION;
67 static Obj GF_METHODS__OPERATION;
68 static GVar G_SETTER__FUNCTION;
69 static Obj GF_SETTER__FUNCTION;
70 static GVar G_GETTER__FUNCTION;
71 static Obj GF_GETTER__FUNCTION;
72 static GVar G_IS__AND__FILTER;
73 static Obj GF_IS__AND__FILTER;
74 static GVar G_COMPACT__TYPE__IDS;
75 static Obj GF_COMPACT__TYPE__IDS;
76 static GVar G_fail;
77 static Obj GC_fail;
78 static GVar G_LEN__LIST;
79 static Obj GF_LEN__LIST;
80 static GVar G_GASMAN;
81 static Obj GF_GASMAN;
82 static GVar G_WRITE__LOCK;
83 static Obj GF_WRITE__LOCK;
84 static GVar G_READ__LOCK;
85 static Obj GF_READ__LOCK;
86 static GVar G_UNLOCK;
87 static Obj GF_UNLOCK;
88 static GVar G_MIGRATE__RAW;
89 static Obj GF_MIGRATE__RAW;
90 static GVar G_MakeReadOnlyObj;
91 static Obj GF_MakeReadOnlyObj;
92 static GVar G_MakeReadOnlySingleObj;
93 static Obj GF_MakeReadOnlySingleObj;
94 static GVar G_AtomicList;
95 static Obj GF_AtomicList;
96 static GVar G_FixedAtomicList;
97 static Obj GF_FixedAtomicList;
98 static GVar G_AtomicRecord;
99 static Obj GF_AtomicRecord;
100 static GVar G_IS__ATOMIC__RECORD;
101 static Obj GF_IS__ATOMIC__RECORD;
102 static GVar G_FromAtomicRecord;
103 static Obj GF_FromAtomicRecord;
104 static GVar G_MakeWriteOnceAtomic;
105 static Obj GF_MakeWriteOnceAtomic;
106 static GVar G_StrictBindOnce;
107 static Obj GF_StrictBindOnce;
108 static GVar G_InstallAttributeFunction;
109 static Obj GF_InstallAttributeFunction;
110 static GVar G_InstallOtherMethod;
111 static Obj GF_InstallOtherMethod;
112 static GVar G_IsAttributeStoringRep;
113 static Obj GC_IsAttributeStoringRep;
114 static GVar G_GETTER__FLAGS;
115 static Obj GC_GETTER__FLAGS;
116 static GVar G_LENGTH__SETTER__METHODS__2;
117 static Obj GC_LENGTH__SETTER__METHODS__2;
118 static GVar G_Subtype;
119 static Obj GF_Subtype;
120 static GVar G_DS__TYPE__CACHE;
121 static Obj GC_DS__TYPE__CACHE;
122 static GVar G_ShareSpecialObj;
123 static Obj GF_ShareSpecialObj;
124 static GVar G_BIND__GLOBAL;
125 static Obj GF_BIND__GLOBAL;
126 static GVar G_CATEGORIES__FAMILY;
127 static Obj GC_CATEGORIES__FAMILY;
128 static GVar G_EMPTY__FLAGS;
129 static Obj GC_EMPTY__FLAGS;
130 static GVar G_TypeOfFamilies;
131 static Obj GC_TypeOfFamilies;
132 static GVar G_NEW__FAMILY;
133 static Obj GF_NEW__FAMILY;
134 static GVar G_NEW__TYPE__CACHE__MISS;
135 static Obj GC_NEW__TYPE__CACHE__MISS;
136 static GVar G_NEW__TYPE__CACHE__HIT;
137 static Obj GC_NEW__TYPE__CACHE__HIT;
138 static GVar G_TypeOfTypes;
139 static Obj GC_TypeOfTypes;
140 static GVar G_NEW__TYPE__NEXT__ID;
141 static Obj GC_NEW__TYPE__NEXT__ID;
142 static GVar G_NEW__TYPE__ID__LIMIT;
143 static Obj GC_NEW__TYPE__ID__LIMIT;
144 static GVar G_FLUSH__ALL__METHOD__CACHES;
145 static Obj GF_FLUSH__ALL__METHOD__CACHES;
146 static GVar G_IsFamily;
147 static Obj GF_IsFamily;
148 static GVar G_NEW__TYPE;
149 static Obj GF_NEW__TYPE;
150 static GVar G_IsType;
151 static Obj GF_IsType;
152 static GVar G_FlagsType;
153 static Obj GF_FlagsType;
154 static GVar G_TypeObj;
155 static Obj GF_TypeObj;
156 static GVar G_DataType;
157 static Obj GF_DataType;
158 static GVar G_IsNonAtomicComponentObjectRep;
159 static Obj GC_IsNonAtomicComponentObjectRep;
160 static GVar G_IsAtomicPositionalObjectRep;
161 static Obj GC_IsAtomicPositionalObjectRep;
162 static GVar G_IsReadOnlyPositionalObjectRep;
163 static Obj GC_IsReadOnlyPositionalObjectRep;
164 static Obj GF_IsReadOnlyPositionalObjectRep;
165 static GVar G_IsAtomicPositionalObjectRepFlags;
166 static Obj GC_IsAtomicPositionalObjectRepFlags;
167 static GVar G_IsNonAtomicComponentObjectRepFlags;
168 static Obj GC_IsNonAtomicComponentObjectRepFlags;
169 static GVar G_IsNoImmediateMethodsObject;
170 static Obj GF_IsNoImmediateMethodsObject;
171 static GVar G_RunImmediateMethods;
172 static Obj GF_RunImmediateMethods;
173 static GVar G_ErrorNoReturn;
174 static Obj GF_ErrorNoReturn;
175 static GVar G_IGNORE__IMMEDIATE__METHODS;
176 static Obj GC_IGNORE__IMMEDIATE__METHODS;
177 static GVar G_SupType;
178 static Obj GF_SupType;
179 static GVar G_Ignore;
180 static Obj GC_Ignore;
181 static GVar G_MAKE__READ__WRITE__GLOBAL;
182 static Obj GF_MAKE__READ__WRITE__GLOBAL;
183 static GVar G_IsAttributeStoringRepFlags;
184 static Obj GC_IsAttributeStoringRepFlags;
185 static GVar G_INFO__OWA;
186 static Obj GF_INFO__OWA;
187 static GVar G_Objectify;
188 static Obj GF_Objectify;
189 static GVar G_Tester;
190 static Obj GF_Tester;
191 static GVar G_Setter;
192 static Obj GF_Setter;
193 static GVar G_FamilyType;
194 static Obj GF_FamilyType;
195
196 /* record names used in handlers */
197 static RNam R_TYPES__LIST__FAM;
198 static RNam R_NAME;
199 static RNam R_REQ__FLAGS;
200 static RNam R_IMP__FLAGS;
201 static RNam R_nTYPES;
202 static RNam R_HASH__SIZE;
203 static RNam R_TYPES;
204
205 /* information for the functions */
206 static Obj NameFunc[21];
207 static Obj FileName;
208
209 /* handler for function 2 */
HdlrFunc2(Obj self,Obj a_name,Obj a_filter,Obj a_getter,Obj a_setter,Obj a_tester,Obj a_mutflag)210 static Obj HdlrFunc2 (
211 Obj self,
212 Obj a_name,
213 Obj a_filter,
214 Obj a_getter,
215 Obj a_setter,
216 Obj a_tester,
217 Obj a_mutflag )
218 {
219 Obj t_1 = 0;
220 Obj t_2 = 0;
221 Obj t_3 = 0;
222 Obj t_4 = 0;
223 Obj t_5 = 0;
224 Obj t_6 = 0;
225 Obj t_7 = 0;
226 Bag oldFrame;
227
228 /* allocate new stack frame */
229 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
230
231 /* InstallOtherMethod( getter, "system getter", true, [ IsAttributeStoringRep and tester ], GETTER_FLAGS, GETTER_FUNCTION( name ) ); */
232 t_1 = GF_InstallOtherMethod;
233 t_2 = MakeString( "system getter" );
234 t_3 = True;
235 t_4 = NEW_PLIST( T_PLIST, 1 );
236 SET_LEN_PLIST( t_4, 1 );
237 t_6 = GC_IsAttributeStoringRep;
238 CHECK_BOUND( t_6, "IsAttributeStoringRep" );
239 if ( t_6 == False ) {
240 t_5 = t_6;
241 }
242 else if ( t_6 == True ) {
243 CHECK_BOOL( a_tester );
244 t_5 = a_tester;
245 }
246 else if (IS_FILTER( t_6 ) ) {
247 t_5 = NewAndFilter( t_6, a_tester );
248 }
249 else {
250 RequireArgumentEx(0, t_6, "<expr>",
251 "must be 'true' or 'false' or a filter" );
252 }
253 SET_ELM_PLIST( t_4, 1, t_5 );
254 CHANGED_BAG( t_4 );
255 t_5 = GC_GETTER__FLAGS;
256 CHECK_BOUND( t_5, "GETTER_FLAGS" );
257 t_7 = GF_GETTER__FUNCTION;
258 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
259 t_6 = CALL_1ARGS( t_7, a_name );
260 }
261 else {
262 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( a_name ) );
263 }
264 CHECK_FUNC_RESULT( t_6 );
265 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
266 CALL_6ARGS( t_1, a_getter, t_2, t_3, t_4, t_5, t_6 );
267 }
268 else {
269 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_getter, t_2, t_3, t_4, t_5, t_6 ) );
270 }
271
272 /* return; */
273 SWITCH_TO_OLD_FRAME(oldFrame);
274 return 0;
275
276 /* return; */
277 SWITCH_TO_OLD_FRAME(oldFrame);
278 return 0;
279 }
280
281 /* handler for function 4 */
HdlrFunc4(Obj self,Obj a_obj,Obj a_val)282 static Obj HdlrFunc4 (
283 Obj self,
284 Obj a_obj,
285 Obj a_val )
286 {
287 Obj t_1 = 0;
288 Obj t_2 = 0;
289 Bag oldFrame;
290
291 /* allocate new stack frame */
292 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
293
294 /* obj!.(name) := val; */
295 t_1 = OBJ_HVAR( (1 << 16) | 1 );
296 CHECK_BOUND( t_1, "name" );
297 AssComObj( a_obj, RNamObj(t_1), a_val );
298
299 /* SetFilterObj( obj, tester ); */
300 t_1 = GF_SetFilterObj;
301 t_2 = OBJ_HVAR( (1 << 16) | 2 );
302 CHECK_BOUND( t_2, "tester" );
303 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
304 CALL_2ARGS( t_1, a_obj, t_2 );
305 }
306 else {
307 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, t_2 ) );
308 }
309
310 /* return; */
311 SWITCH_TO_OLD_FRAME(oldFrame);
312 return 0;
313
314 /* return; */
315 SWITCH_TO_OLD_FRAME(oldFrame);
316 return 0;
317 }
318
319 /* handler for function 3 */
HdlrFunc3(Obj self,Obj a_name,Obj a_filter,Obj a_getter,Obj a_setter,Obj a_tester,Obj a_mutflag)320 static Obj HdlrFunc3 (
321 Obj self,
322 Obj a_name,
323 Obj a_filter,
324 Obj a_getter,
325 Obj a_setter,
326 Obj a_tester,
327 Obj a_mutflag )
328 {
329 Obj t_1 = 0;
330 Obj t_2 = 0;
331 Obj t_3 = 0;
332 Obj t_4 = 0;
333 Obj t_5 = 0;
334 Obj t_6 = 0;
335 Obj t_7 = 0;
336 Obj t_8 = 0;
337 Bag oldFrame;
338
339 /* allocate new stack frame */
340 SWITCH_TO_NEW_FRAME(self,2,0,oldFrame);
341 MakeHighVars(STATE(CurrLVars));
342 ASS_LVAR( 1, a_name );
343 ASS_LVAR( 2, a_tester );
344
345 /* if mutflag then */
346 CHECK_BOOL( a_mutflag );
347 t_1 = (Obj)(UInt)(a_mutflag != False);
348 if ( t_1 ) {
349
350 /* InstallOtherMethod( setter, "system mutable setter", true, [ IsAttributeStoringRep, IS_OBJECT ], 0, function ( obj, val )
351 obj!.(name) := val;
352 SetFilterObj( obj, tester );
353 return;
354 end ); */
355 t_1 = GF_InstallOtherMethod;
356 t_2 = MakeString( "system mutable setter" );
357 t_3 = True;
358 t_4 = NEW_PLIST( T_PLIST, 2 );
359 SET_LEN_PLIST( t_4, 2 );
360 t_5 = GC_IsAttributeStoringRep;
361 CHECK_BOUND( t_5, "IsAttributeStoringRep" );
362 SET_ELM_PLIST( t_4, 1, t_5 );
363 CHANGED_BAG( t_4 );
364 t_5 = GC_IS__OBJECT;
365 CHECK_BOUND( t_5, "IS_OBJECT" );
366 SET_ELM_PLIST( t_4, 2, t_5 );
367 CHANGED_BAG( t_4 );
368 t_5 = NewFunction( NameFunc[4], 2, ArgStringToList("obj,val"), HdlrFunc4 );
369 SET_ENVI_FUNC( t_5, STATE(CurrLVars) );
370 t_6 = NewFunctionBody();
371 SET_STARTLINE_BODY(t_6, 40);
372 SET_ENDLINE_BODY(t_6, 43);
373 SET_FILENAME_BODY(t_6, FileName);
374 SET_BODY_FUNC(t_5, t_6);
375 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
376 CALL_6ARGS( t_1, a_setter, t_2, t_3, t_4, INTOBJ_INT(0), t_5 );
377 }
378 else {
379 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_setter, t_2, t_3, t_4, INTOBJ_INT(0), t_5 ) );
380 }
381
382 }
383
384 /* else */
385 else {
386
387 /* InstallOtherMethod( setter, "system setter", true, [ IsAttributeStoringRep, IS_OBJECT ], 0, SETTER_FUNCTION( name, tester ) ); */
388 t_1 = GF_InstallOtherMethod;
389 t_2 = MakeString( "system setter" );
390 t_3 = True;
391 t_4 = NEW_PLIST( T_PLIST, 2 );
392 SET_LEN_PLIST( t_4, 2 );
393 t_5 = GC_IsAttributeStoringRep;
394 CHECK_BOUND( t_5, "IsAttributeStoringRep" );
395 SET_ELM_PLIST( t_4, 1, t_5 );
396 CHANGED_BAG( t_4 );
397 t_5 = GC_IS__OBJECT;
398 CHECK_BOUND( t_5, "IS_OBJECT" );
399 SET_ELM_PLIST( t_4, 2, t_5 );
400 CHANGED_BAG( t_4 );
401 t_6 = GF_SETTER__FUNCTION;
402 t_7 = OBJ_LVAR( 1 );
403 CHECK_BOUND( t_7, "name" );
404 t_8 = OBJ_LVAR( 2 );
405 CHECK_BOUND( t_8, "tester" );
406 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
407 t_5 = CALL_2ARGS( t_6, t_7, t_8 );
408 }
409 else {
410 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( t_7, t_8 ) );
411 }
412 CHECK_FUNC_RESULT( t_5 );
413 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
414 CALL_6ARGS( t_1, a_setter, t_2, t_3, t_4, INTOBJ_INT(0), t_5 );
415 }
416 else {
417 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_setter, t_2, t_3, t_4, INTOBJ_INT(0), t_5 ) );
418 }
419
420 }
421 /* fi */
422
423 /* return; */
424 SWITCH_TO_OLD_FRAME(oldFrame);
425 return 0;
426
427 /* return; */
428 SWITCH_TO_OLD_FRAME(oldFrame);
429 return 0;
430 }
431
432 /* handler for function 5 */
HdlrFunc5(Obj self,Obj a_typeOfFamilies,Obj a_name,Obj a_req__filter,Obj a_imp__filter)433 static Obj HdlrFunc5 (
434 Obj self,
435 Obj a_typeOfFamilies,
436 Obj a_name,
437 Obj a_req__filter,
438 Obj a_imp__filter )
439 {
440 Obj l_lock = 0;
441 Obj l_type = 0;
442 Obj l_pair = 0;
443 Obj l_family = 0;
444 Obj t_1 = 0;
445 Obj t_2 = 0;
446 Obj t_3 = 0;
447 Obj t_4 = 0;
448 Obj t_5 = 0;
449 Obj t_6 = 0;
450 Obj t_7 = 0;
451 Obj t_8 = 0;
452 (void)l_lock;
453 (void)l_type;
454 (void)l_pair;
455 (void)l_family;
456 Bag oldFrame;
457
458 /* allocate new stack frame */
459 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
460
461 /* imp_filter := WITH_IMPS_FLAGS( AND_FLAGS( imp_filter, req_filter ) ); */
462 t_2 = GF_WITH__IMPS__FLAGS;
463 t_4 = GF_AND__FLAGS;
464 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
465 t_3 = CALL_2ARGS( t_4, a_imp__filter, a_req__filter );
466 }
467 else {
468 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_imp__filter, a_req__filter ) );
469 }
470 CHECK_FUNC_RESULT( t_3 );
471 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
472 t_1 = CALL_1ARGS( t_2, t_3 );
473 }
474 else {
475 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
476 }
477 CHECK_FUNC_RESULT( t_1 );
478 a_imp__filter = t_1;
479
480 /* type := Subtype( typeOfFamilies, IsAttributeStoringRep ); */
481 t_2 = GF_Subtype;
482 t_3 = GC_IsAttributeStoringRep;
483 CHECK_BOUND( t_3, "IsAttributeStoringRep" );
484 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
485 t_1 = CALL_2ARGS( t_2, a_typeOfFamilies, t_3 );
486 }
487 else {
488 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( a_typeOfFamilies, t_3 ) );
489 }
490 CHECK_FUNC_RESULT( t_1 );
491 l_type = t_1;
492
493 /* lock := READ_LOCK( CATEGORIES_FAMILY ); */
494 t_2 = GF_READ__LOCK;
495 t_3 = GC_CATEGORIES__FAMILY;
496 CHECK_BOUND( t_3, "CATEGORIES_FAMILY" );
497 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
498 t_1 = CALL_1ARGS( t_2, t_3 );
499 }
500 else {
501 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
502 }
503 CHECK_FUNC_RESULT( t_1 );
504 l_lock = t_1;
505
506 /* for pair in CATEGORIES_FAMILY do */
507 t_4 = GC_CATEGORIES__FAMILY;
508 CHECK_BOUND( t_4, "CATEGORIES_FAMILY" );
509 if ( IS_SMALL_LIST(t_4) ) {
510 t_3 = (Obj)(UInt)1;
511 t_1 = INTOBJ_INT(1);
512 }
513 else {
514 t_3 = (Obj)(UInt)0;
515 t_1 = CALL_1ARGS( GF_ITERATOR, t_4 );
516 }
517 while ( 1 ) {
518 if ( t_3 ) {
519 if ( LEN_LIST(t_4) < INT_INTOBJ(t_1) ) break;
520 t_2 = ELMV0_LIST( t_4, INT_INTOBJ(t_1) );
521 t_1 = (Obj)(((UInt)t_1)+4);
522 if ( t_2 == 0 ) continue;
523 }
524 else {
525 if ( CALL_1ARGS( GF_IS_DONE_ITER, t_1 ) != False ) break;
526 t_2 = CALL_1ARGS( GF_NEXT_ITER, t_1 );
527 }
528 l_pair = t_2;
529
530 /* if IS_SUBSET_FLAGS( imp_filter, pair[1] ) then */
531 t_7 = GF_IS__SUBSET__FLAGS;
532 C_ELM_LIST_FPL( t_8, l_pair, INTOBJ_INT(1) )
533 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
534 t_6 = CALL_2ARGS( t_7, a_imp__filter, t_8 );
535 }
536 else {
537 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( a_imp__filter, t_8 ) );
538 }
539 CHECK_FUNC_RESULT( t_6 );
540 CHECK_BOOL( t_6 );
541 t_5 = (Obj)(UInt)(t_6 != False);
542 if ( t_5 ) {
543
544 /* type := Subtype( type, pair[2] ); */
545 t_6 = GF_Subtype;
546 C_ELM_LIST_FPL( t_7, l_pair, INTOBJ_INT(2) )
547 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
548 t_5 = CALL_2ARGS( t_6, l_type, t_7 );
549 }
550 else {
551 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( l_type, t_7 ) );
552 }
553 CHECK_FUNC_RESULT( t_5 );
554 l_type = t_5;
555
556 }
557 /* fi */
558
559 }
560 /* od */
561
562 /* UNLOCK( lock ); */
563 t_1 = GF_UNLOCK;
564 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
565 CALL_1ARGS( t_1, l_lock );
566 }
567 else {
568 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_lock ) );
569 }
570
571 /* family := AtomicRecord( ); */
572 t_2 = GF_AtomicRecord;
573 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
574 t_1 = CALL_0ARGS( t_2 );
575 }
576 else {
577 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( ) );
578 }
579 CHECK_FUNC_RESULT( t_1 );
580 l_family = t_1;
581
582 /* SET_TYPE_COMOBJ( family, type ); */
583 t_1 = GF_SET__TYPE__COMOBJ;
584 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
585 CALL_2ARGS( t_1, l_family, l_type );
586 }
587 else {
588 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_family, l_type ) );
589 }
590
591 /* family!.NAME := IMMUTABLE_COPY_OBJ( name ); */
592 t_2 = GF_IMMUTABLE__COPY__OBJ;
593 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
594 t_1 = CALL_1ARGS( t_2, a_name );
595 }
596 else {
597 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( a_name ) );
598 }
599 CHECK_FUNC_RESULT( t_1 );
600 AssComObj( l_family, R_NAME, t_1 );
601
602 /* family!.REQ_FLAGS := req_filter; */
603 AssComObj( l_family, R_REQ__FLAGS, a_req__filter );
604
605 /* family!.IMP_FLAGS := imp_filter; */
606 AssComObj( l_family, R_IMP__FLAGS, a_imp__filter );
607
608 /* family!.nTYPES := 0; */
609 AssComObj( l_family, R_nTYPES, INTOBJ_INT(0) );
610
611 /* family!.HASH_SIZE := 32; */
612 AssComObj( l_family, R_HASH__SIZE, INTOBJ_INT(32) );
613
614 /* lock := WRITE_LOCK( DS_TYPE_CACHE ); */
615 t_2 = GF_WRITE__LOCK;
616 t_3 = GC_DS__TYPE__CACHE;
617 CHECK_BOUND( t_3, "DS_TYPE_CACHE" );
618 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
619 t_1 = CALL_1ARGS( t_2, t_3 );
620 }
621 else {
622 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
623 }
624 CHECK_FUNC_RESULT( t_1 );
625 l_lock = t_1;
626
627 /* family!.TYPES := MIGRATE_RAW( [ ], DS_TYPE_CACHE ); */
628 t_2 = GF_MIGRATE__RAW;
629 t_3 = NEW_PLIST( T_PLIST, 0 );
630 SET_LEN_PLIST( t_3, 0 );
631 t_4 = GC_DS__TYPE__CACHE;
632 CHECK_BOUND( t_4, "DS_TYPE_CACHE" );
633 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
634 t_1 = CALL_2ARGS( t_2, t_3, t_4 );
635 }
636 else {
637 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3, t_4 ) );
638 }
639 CHECK_FUNC_RESULT( t_1 );
640 AssComObj( l_family, R_TYPES, t_1 );
641
642 /* UNLOCK( lock ); */
643 t_1 = GF_UNLOCK;
644 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
645 CALL_1ARGS( t_1, l_lock );
646 }
647 else {
648 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_lock ) );
649 }
650
651 /* family!.TYPES_LIST_FAM := MakeWriteOnceAtomic( AtomicList( 27 ) ); */
652 t_2 = GF_MakeWriteOnceAtomic;
653 t_4 = GF_AtomicList;
654 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
655 t_3 = CALL_1ARGS( t_4, INTOBJ_INT(27) );
656 }
657 else {
658 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( INTOBJ_INT(27) ) );
659 }
660 CHECK_FUNC_RESULT( t_3 );
661 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
662 t_1 = CALL_1ARGS( t_2, t_3 );
663 }
664 else {
665 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
666 }
667 CHECK_FUNC_RESULT( t_1 );
668 AssComObj( l_family, R_TYPES__LIST__FAM, t_1 );
669
670 /* return family; */
671 SWITCH_TO_OLD_FRAME(oldFrame);
672 return l_family;
673
674 /* return; */
675 SWITCH_TO_OLD_FRAME(oldFrame);
676 return 0;
677 }
678
679 /* handler for function 6 */
HdlrFunc6(Obj self,Obj a_arg)680 static Obj HdlrFunc6 (
681 Obj self,
682 Obj a_arg )
683 {
684 Obj l_typeOfFamilies = 0;
685 Obj l_name = 0;
686 Obj l_req = 0;
687 Obj l_imp = 0;
688 Obj l_filter = 0;
689 Obj t_1 = 0;
690 Obj t_2 = 0;
691 Obj t_3 = 0;
692 Obj t_4 = 0;
693 (void)l_typeOfFamilies;
694 (void)l_name;
695 (void)l_req;
696 (void)l_imp;
697 (void)l_filter;
698 Bag oldFrame;
699
700 /* allocate new stack frame */
701 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
702
703 /* if not LEN_LIST( arg ) in [ 1 .. 4 ] then */
704 t_4 = GF_LEN__LIST;
705 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
706 t_3 = CALL_1ARGS( t_4, a_arg );
707 }
708 else {
709 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_arg ) );
710 }
711 CHECK_FUNC_RESULT( t_3 );
712 t_4 = Range2Check( INTOBJ_INT(1), INTOBJ_INT(4) );
713 t_2 = (Obj)(UInt)(IN( t_3, t_4 ));
714 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
715 if ( t_1 ) {
716
717 /* Error( "usage: NewFamily( <name> [, <req> [, <imp> [, <famfilter> ] ] ] )" ); */
718 t_1 = GF_Error;
719 t_2 = MakeString( "usage: NewFamily( <name> [, <req> [, <imp> [, <famfilter> ] ] ] )" );
720 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
721 CALL_1ARGS( t_1, t_2 );
722 }
723 else {
724 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
725 }
726
727 }
728 /* fi */
729
730 /* name := arg[1]; */
731 C_ELM_LIST_FPL( t_1, a_arg, INTOBJ_INT(1) )
732 l_name = t_1;
733
734 /* if LEN_LIST( arg ) >= 2 then */
735 t_3 = GF_LEN__LIST;
736 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
737 t_2 = CALL_1ARGS( t_3, a_arg );
738 }
739 else {
740 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_arg ) );
741 }
742 CHECK_FUNC_RESULT( t_2 );
743 t_1 = (Obj)(UInt)(! LT( t_2, INTOBJ_INT(2) ));
744 if ( t_1 ) {
745
746 /* req := FLAGS_FILTER( arg[2] ); */
747 t_2 = GF_FLAGS__FILTER;
748 C_ELM_LIST_FPL( t_3, a_arg, INTOBJ_INT(2) )
749 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
750 t_1 = CALL_1ARGS( t_2, t_3 );
751 }
752 else {
753 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
754 }
755 CHECK_FUNC_RESULT( t_1 );
756 l_req = t_1;
757
758 }
759
760 /* else */
761 else {
762
763 /* req := EMPTY_FLAGS; */
764 t_1 = GC_EMPTY__FLAGS;
765 CHECK_BOUND( t_1, "EMPTY_FLAGS" );
766 l_req = t_1;
767
768 }
769 /* fi */
770
771 /* if LEN_LIST( arg ) >= 3 then */
772 t_3 = GF_LEN__LIST;
773 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
774 t_2 = CALL_1ARGS( t_3, a_arg );
775 }
776 else {
777 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_arg ) );
778 }
779 CHECK_FUNC_RESULT( t_2 );
780 t_1 = (Obj)(UInt)(! LT( t_2, INTOBJ_INT(3) ));
781 if ( t_1 ) {
782
783 /* imp := FLAGS_FILTER( arg[3] ); */
784 t_2 = GF_FLAGS__FILTER;
785 C_ELM_LIST_FPL( t_3, a_arg, INTOBJ_INT(3) )
786 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
787 t_1 = CALL_1ARGS( t_2, t_3 );
788 }
789 else {
790 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
791 }
792 CHECK_FUNC_RESULT( t_1 );
793 l_imp = t_1;
794
795 }
796
797 /* else */
798 else {
799
800 /* imp := EMPTY_FLAGS; */
801 t_1 = GC_EMPTY__FLAGS;
802 CHECK_BOUND( t_1, "EMPTY_FLAGS" );
803 l_imp = t_1;
804
805 }
806 /* fi */
807
808 /* if LEN_LIST( arg ) = 4 then */
809 t_3 = GF_LEN__LIST;
810 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
811 t_2 = CALL_1ARGS( t_3, a_arg );
812 }
813 else {
814 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_arg ) );
815 }
816 CHECK_FUNC_RESULT( t_2 );
817 t_1 = (Obj)(UInt)(EQ( t_2, INTOBJ_INT(4) ));
818 if ( t_1 ) {
819
820 /* typeOfFamilies := Subtype( TypeOfFamilies, arg[4] ); */
821 t_2 = GF_Subtype;
822 t_3 = GC_TypeOfFamilies;
823 CHECK_BOUND( t_3, "TypeOfFamilies" );
824 C_ELM_LIST_FPL( t_4, a_arg, INTOBJ_INT(4) )
825 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
826 t_1 = CALL_2ARGS( t_2, t_3, t_4 );
827 }
828 else {
829 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3, t_4 ) );
830 }
831 CHECK_FUNC_RESULT( t_1 );
832 l_typeOfFamilies = t_1;
833
834 }
835
836 /* else */
837 else {
838
839 /* typeOfFamilies := TypeOfFamilies; */
840 t_1 = GC_TypeOfFamilies;
841 CHECK_BOUND( t_1, "TypeOfFamilies" );
842 l_typeOfFamilies = t_1;
843
844 }
845 /* fi */
846
847 /* return NEW_FAMILY( typeOfFamilies, name, req, imp ); */
848 t_2 = GF_NEW__FAMILY;
849 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
850 t_1 = CALL_4ARGS( t_2, l_typeOfFamilies, l_name, l_req, l_imp );
851 }
852 else {
853 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( l_typeOfFamilies, l_name, l_req, l_imp ) );
854 }
855 CHECK_FUNC_RESULT( t_1 );
856 SWITCH_TO_OLD_FRAME(oldFrame);
857 return t_1;
858
859 /* return; */
860 SWITCH_TO_OLD_FRAME(oldFrame);
861 return 0;
862 }
863
864 /* handler for function 7 */
HdlrFunc7(Obj self,Obj a_family,Obj a_flags,Obj a_data,Obj a_parent)865 static Obj HdlrFunc7 (
866 Obj self,
867 Obj a_family,
868 Obj a_flags,
869 Obj a_data,
870 Obj a_parent )
871 {
872 Obj l_lock = 0;
873 Obj l_hash = 0;
874 Obj l_cache = 0;
875 Obj l_cached = 0;
876 Obj l_type = 0;
877 Obj l_ncache = 0;
878 Obj l_ncl = 0;
879 Obj l_t = 0;
880 Obj l_i = 0;
881 Obj l_match = 0;
882 Obj t_1 = 0;
883 Obj t_2 = 0;
884 Obj t_3 = 0;
885 Obj t_4 = 0;
886 Obj t_5 = 0;
887 Obj t_6 = 0;
888 Obj t_7 = 0;
889 Obj t_8 = 0;
890 Obj t_9 = 0;
891 Obj t_10 = 0;
892 (void)l_lock;
893 (void)l_hash;
894 (void)l_cache;
895 (void)l_cached;
896 (void)l_type;
897 (void)l_ncache;
898 (void)l_ncl;
899 (void)l_t;
900 (void)l_i;
901 (void)l_match;
902 Bag oldFrame;
903
904 /* allocate new stack frame */
905 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
906
907 /* lock := WRITE_LOCK( DS_TYPE_CACHE ); */
908 t_2 = GF_WRITE__LOCK;
909 t_3 = GC_DS__TYPE__CACHE;
910 CHECK_BOUND( t_3, "DS_TYPE_CACHE" );
911 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
912 t_1 = CALL_1ARGS( t_2, t_3 );
913 }
914 else {
915 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
916 }
917 CHECK_FUNC_RESULT( t_1 );
918 l_lock = t_1;
919
920 /* cache := family!.TYPES; */
921 t_1 = ElmComObj( a_family, R_TYPES );
922 l_cache = t_1;
923
924 /* hash := HASH_FLAGS( flags ) mod family!.HASH_SIZE + 1; */
925 t_4 = GF_HASH__FLAGS;
926 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
927 t_3 = CALL_1ARGS( t_4, a_flags );
928 }
929 else {
930 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_flags ) );
931 }
932 CHECK_FUNC_RESULT( t_3 );
933 t_4 = ElmComObj( a_family, R_HASH__SIZE );
934 t_2 = MOD( t_3, t_4 );
935 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
936 l_hash = t_1;
937
938 /* if IsBound( cache[hash] ) then */
939 CHECK_INT_POS( l_hash );
940 t_2 = C_ISB_LIST( l_cache, l_hash );
941 t_1 = (Obj)(UInt)(t_2 != False);
942 if ( t_1 ) {
943
944 /* cached := cache[hash]; */
945 C_ELM_LIST_FPL( t_1, l_cache, l_hash )
946 l_cached = t_1;
947
948 /* if IS_EQUAL_FLAGS( flags, cached![2] ) then */
949 t_3 = GF_IS__EQUAL__FLAGS;
950 t_4 = ElmPosObj( l_cached, 2 );
951 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
952 t_2 = CALL_2ARGS( t_3, a_flags, t_4 );
953 }
954 else {
955 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_flags, t_4 ) );
956 }
957 CHECK_FUNC_RESULT( t_2 );
958 CHECK_BOOL( t_2 );
959 t_1 = (Obj)(UInt)(t_2 != False);
960 if ( t_1 ) {
961
962 /* flags := cached![2]; */
963 t_1 = ElmPosObj( l_cached, 2 );
964 a_flags = t_1;
965
966 /* if IS_IDENTICAL_OBJ( data, cached![3] ) and IS_IDENTICAL_OBJ( TypeOfTypes, TYPE_OBJ( cached ) ) then */
967 t_4 = GF_IS__IDENTICAL__OBJ;
968 t_5 = ElmPosObj( l_cached, 3 );
969 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
970 t_3 = CALL_2ARGS( t_4, a_data, t_5 );
971 }
972 else {
973 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_data, t_5 ) );
974 }
975 CHECK_FUNC_RESULT( t_3 );
976 CHECK_BOOL( t_3 );
977 t_2 = (Obj)(UInt)(t_3 != False);
978 t_1 = t_2;
979 if ( t_1 ) {
980 t_5 = GF_IS__IDENTICAL__OBJ;
981 t_6 = GC_TypeOfTypes;
982 CHECK_BOUND( t_6, "TypeOfTypes" );
983 t_8 = GF_TYPE__OBJ;
984 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
985 t_7 = CALL_1ARGS( t_8, l_cached );
986 }
987 else {
988 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( l_cached ) );
989 }
990 CHECK_FUNC_RESULT( t_7 );
991 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
992 t_4 = CALL_2ARGS( t_5, t_6, t_7 );
993 }
994 else {
995 t_4 = DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( t_6, t_7 ) );
996 }
997 CHECK_FUNC_RESULT( t_4 );
998 CHECK_BOOL( t_4 );
999 t_3 = (Obj)(UInt)(t_4 != False);
1000 t_1 = t_3;
1001 }
1002 if ( t_1 ) {
1003
1004 /* if IS_IDENTICAL_OBJ( parent, fail ) then */
1005 t_3 = GF_IS__IDENTICAL__OBJ;
1006 t_4 = GC_fail;
1007 CHECK_BOUND( t_4, "fail" );
1008 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1009 t_2 = CALL_2ARGS( t_3, a_parent, t_4 );
1010 }
1011 else {
1012 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_parent, t_4 ) );
1013 }
1014 CHECK_FUNC_RESULT( t_2 );
1015 CHECK_BOOL( t_2 );
1016 t_1 = (Obj)(UInt)(t_2 != False);
1017 if ( t_1 ) {
1018
1019 /* match := true; */
1020 t_1 = True;
1021 l_match = t_1;
1022
1023 /* for i in [ 5 .. LEN_POSOBJ( cached ) ] do */
1024 t_3 = GF_LEN__POSOBJ;
1025 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1026 t_2 = CALL_1ARGS( t_3, l_cached );
1027 }
1028 else {
1029 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( l_cached ) );
1030 }
1031 CHECK_FUNC_RESULT( t_2 );
1032 CHECK_INT_SMALL( t_2 );
1033 for ( t_1 = INTOBJ_INT(5);
1034 ((Int)t_1) <= ((Int)t_2);
1035 t_1 = (Obj)(((UInt)t_1)+4) ) {
1036 l_i = t_1;
1037
1038 /* if IsBound( cached![i] ) then */
1039 t_4 = IsbPosObj( l_cached, INT_INTOBJ(l_i) ) ? True : False;
1040 t_3 = (Obj)(UInt)(t_4 != False);
1041 if ( t_3 ) {
1042
1043 /* match := false; */
1044 t_3 = False;
1045 l_match = t_3;
1046
1047 /* break; */
1048 break;
1049
1050 }
1051 /* fi */
1052
1053 }
1054 /* od */
1055
1056 /* if match then */
1057 t_1 = (Obj)(UInt)(l_match != False);
1058 if ( t_1 ) {
1059
1060 /* NEW_TYPE_CACHE_HIT := NEW_TYPE_CACHE_HIT + 1; */
1061 t_2 = GC_NEW__TYPE__CACHE__HIT;
1062 CHECK_BOUND( t_2, "NEW_TYPE_CACHE_HIT" );
1063 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
1064 AssGVar( G_NEW__TYPE__CACHE__HIT, t_1 );
1065
1066 /* UNLOCK( lock ); */
1067 t_1 = GF_UNLOCK;
1068 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1069 CALL_1ARGS( t_1, l_lock );
1070 }
1071 else {
1072 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_lock ) );
1073 }
1074
1075 /* return cached; */
1076 SWITCH_TO_OLD_FRAME(oldFrame);
1077 return l_cached;
1078
1079 }
1080 /* fi */
1081
1082 }
1083 /* fi */
1084
1085 /* if LEN_POSOBJ( parent ) = LEN_POSOBJ( cached ) then */
1086 t_3 = GF_LEN__POSOBJ;
1087 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1088 t_2 = CALL_1ARGS( t_3, a_parent );
1089 }
1090 else {
1091 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_parent ) );
1092 }
1093 CHECK_FUNC_RESULT( t_2 );
1094 t_4 = GF_LEN__POSOBJ;
1095 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1096 t_3 = CALL_1ARGS( t_4, l_cached );
1097 }
1098 else {
1099 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( l_cached ) );
1100 }
1101 CHECK_FUNC_RESULT( t_3 );
1102 t_1 = (Obj)(UInt)(EQ( t_2, t_3 ));
1103 if ( t_1 ) {
1104
1105 /* match := true; */
1106 t_1 = True;
1107 l_match = t_1;
1108
1109 /* for i in [ 5 .. LEN_POSOBJ( parent ) ] do */
1110 t_3 = GF_LEN__POSOBJ;
1111 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1112 t_2 = CALL_1ARGS( t_3, a_parent );
1113 }
1114 else {
1115 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_parent ) );
1116 }
1117 CHECK_FUNC_RESULT( t_2 );
1118 CHECK_INT_SMALL( t_2 );
1119 for ( t_1 = INTOBJ_INT(5);
1120 ((Int)t_1) <= ((Int)t_2);
1121 t_1 = (Obj)(((UInt)t_1)+4) ) {
1122 l_i = t_1;
1123
1124 /* if IsBound( parent![i] ) <> IsBound( cached![i] ) then */
1125 t_4 = IsbPosObj( a_parent, INT_INTOBJ(l_i) ) ? True : False;
1126 t_5 = IsbPosObj( l_cached, INT_INTOBJ(l_i) ) ? True : False;
1127 t_3 = (Obj)(UInt)( ! EQ( t_4, t_5 ));
1128 if ( t_3 ) {
1129
1130 /* match := false; */
1131 t_3 = False;
1132 l_match = t_3;
1133
1134 /* break; */
1135 break;
1136
1137 }
1138 /* fi */
1139
1140 /* if IsBound( parent![i] ) and IsBound( cached![i] ) and not IS_IDENTICAL_OBJ( parent![i], cached![i] ) then */
1141 t_6 = IsbPosObj( a_parent, INT_INTOBJ(l_i) ) ? True : False;
1142 t_5 = (Obj)(UInt)(t_6 != False);
1143 t_4 = t_5;
1144 if ( t_4 ) {
1145 t_7 = IsbPosObj( l_cached, INT_INTOBJ(l_i) ) ? True : False;
1146 t_6 = (Obj)(UInt)(t_7 != False);
1147 t_4 = t_6;
1148 }
1149 t_3 = t_4;
1150 if ( t_3 ) {
1151 t_8 = GF_IS__IDENTICAL__OBJ;
1152 t_9 = ElmPosObj( a_parent, INT_INTOBJ(l_i) );
1153 t_10 = ElmPosObj( l_cached, INT_INTOBJ(l_i) );
1154 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
1155 t_7 = CALL_2ARGS( t_8, t_9, t_10 );
1156 }
1157 else {
1158 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( t_9, t_10 ) );
1159 }
1160 CHECK_FUNC_RESULT( t_7 );
1161 CHECK_BOOL( t_7 );
1162 t_6 = (Obj)(UInt)(t_7 != False);
1163 t_5 = (Obj)(UInt)( ! ((Int)t_6) );
1164 t_3 = t_5;
1165 }
1166 if ( t_3 ) {
1167
1168 /* match := false; */
1169 t_3 = False;
1170 l_match = t_3;
1171
1172 /* break; */
1173 break;
1174
1175 }
1176 /* fi */
1177
1178 }
1179 /* od */
1180
1181 /* if match then */
1182 t_1 = (Obj)(UInt)(l_match != False);
1183 if ( t_1 ) {
1184
1185 /* NEW_TYPE_CACHE_HIT := NEW_TYPE_CACHE_HIT + 1; */
1186 t_2 = GC_NEW__TYPE__CACHE__HIT;
1187 CHECK_BOUND( t_2, "NEW_TYPE_CACHE_HIT" );
1188 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
1189 AssGVar( G_NEW__TYPE__CACHE__HIT, t_1 );
1190
1191 /* UNLOCK( lock ); */
1192 t_1 = GF_UNLOCK;
1193 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1194 CALL_1ARGS( t_1, l_lock );
1195 }
1196 else {
1197 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_lock ) );
1198 }
1199
1200 /* return cached; */
1201 SWITCH_TO_OLD_FRAME(oldFrame);
1202 return l_cached;
1203
1204 }
1205 /* fi */
1206
1207 }
1208 /* fi */
1209
1210 }
1211 /* fi */
1212
1213 }
1214 /* fi */
1215
1216 /* NEW_TYPE_CACHE_MISS := NEW_TYPE_CACHE_MISS + 1; */
1217 t_2 = GC_NEW__TYPE__CACHE__MISS;
1218 CHECK_BOUND( t_2, "NEW_TYPE_CACHE_MISS" );
1219 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
1220 AssGVar( G_NEW__TYPE__CACHE__MISS, t_1 );
1221
1222 }
1223 /* fi */
1224
1225 /* NEW_TYPE_NEXT_ID := NEW_TYPE_NEXT_ID + 1; */
1226 t_2 = GC_NEW__TYPE__NEXT__ID;
1227 CHECK_BOUND( t_2, "NEW_TYPE_NEXT_ID" );
1228 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
1229 AssGVar( G_NEW__TYPE__NEXT__ID, t_1 );
1230
1231 /* if NEW_TYPE_NEXT_ID >= NEW_TYPE_ID_LIMIT then */
1232 t_2 = GC_NEW__TYPE__NEXT__ID;
1233 CHECK_BOUND( t_2, "NEW_TYPE_NEXT_ID" );
1234 t_3 = GC_NEW__TYPE__ID__LIMIT;
1235 CHECK_BOUND( t_3, "NEW_TYPE_ID_LIMIT" );
1236 t_1 = (Obj)(UInt)(! LT( t_2, t_3 ));
1237 if ( t_1 ) {
1238
1239 /* GASMAN( "collect" ); */
1240 t_1 = GF_GASMAN;
1241 t_2 = MakeString( "collect" );
1242 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1243 CALL_1ARGS( t_1, t_2 );
1244 }
1245 else {
1246 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
1247 }
1248
1249 /* FLUSH_ALL_METHOD_CACHES( ); */
1250 t_1 = GF_FLUSH__ALL__METHOD__CACHES;
1251 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1252 CALL_0ARGS( t_1 );
1253 }
1254 else {
1255 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( ) );
1256 }
1257
1258 /* NEW_TYPE_NEXT_ID := COMPACT_TYPE_IDS( ); */
1259 t_2 = GF_COMPACT__TYPE__IDS;
1260 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
1261 t_1 = CALL_0ARGS( t_2 );
1262 }
1263 else {
1264 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( ) );
1265 }
1266 CHECK_FUNC_RESULT( t_1 );
1267 AssGVar( G_NEW__TYPE__NEXT__ID, t_1 );
1268
1269 }
1270 /* fi */
1271
1272 /* type := [ family, flags ]; */
1273 t_1 = NEW_PLIST( T_PLIST, 2 );
1274 SET_LEN_PLIST( t_1, 2 );
1275 SET_ELM_PLIST( t_1, 1, a_family );
1276 CHANGED_BAG( t_1 );
1277 SET_ELM_PLIST( t_1, 2, a_flags );
1278 CHANGED_BAG( t_1 );
1279 l_type = t_1;
1280
1281 /* data := MakeReadOnlyObj( data ); */
1282 t_2 = GF_MakeReadOnlyObj;
1283 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
1284 t_1 = CALL_1ARGS( t_2, a_data );
1285 }
1286 else {
1287 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( a_data ) );
1288 }
1289 CHECK_FUNC_RESULT( t_1 );
1290 a_data = t_1;
1291
1292 /* type[3] := data; */
1293 C_ASS_LIST_FPL( l_type, INTOBJ_INT(3), a_data )
1294
1295 /* type[4] := NEW_TYPE_NEXT_ID; */
1296 t_1 = GC_NEW__TYPE__NEXT__ID;
1297 CHECK_BOUND( t_1, "NEW_TYPE_NEXT_ID" );
1298 C_ASS_LIST_FPL( l_type, INTOBJ_INT(4), t_1 )
1299
1300 /* if not IS_IDENTICAL_OBJ( parent, fail ) then */
1301 t_4 = GF_IS__IDENTICAL__OBJ;
1302 t_5 = GC_fail;
1303 CHECK_BOUND( t_5, "fail" );
1304 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1305 t_3 = CALL_2ARGS( t_4, a_parent, t_5 );
1306 }
1307 else {
1308 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_parent, t_5 ) );
1309 }
1310 CHECK_FUNC_RESULT( t_3 );
1311 CHECK_BOOL( t_3 );
1312 t_2 = (Obj)(UInt)(t_3 != False);
1313 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
1314 if ( t_1 ) {
1315
1316 /* for i in [ 5 .. LEN_POSOBJ( parent ) ] do */
1317 t_3 = GF_LEN__POSOBJ;
1318 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1319 t_2 = CALL_1ARGS( t_3, a_parent );
1320 }
1321 else {
1322 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_parent ) );
1323 }
1324 CHECK_FUNC_RESULT( t_2 );
1325 CHECK_INT_SMALL( t_2 );
1326 for ( t_1 = INTOBJ_INT(5);
1327 ((Int)t_1) <= ((Int)t_2);
1328 t_1 = (Obj)(((UInt)t_1)+4) ) {
1329 l_i = t_1;
1330
1331 /* if IsBound( parent![i] ) and not IsBound( type[i] ) then */
1332 t_5 = IsbPosObj( a_parent, INT_INTOBJ(l_i) ) ? True : False;
1333 t_4 = (Obj)(UInt)(t_5 != False);
1334 t_3 = t_4;
1335 if ( t_3 ) {
1336 t_7 = C_ISB_LIST( l_type, l_i );
1337 t_6 = (Obj)(UInt)(t_7 != False);
1338 t_5 = (Obj)(UInt)( ! ((Int)t_6) );
1339 t_3 = t_5;
1340 }
1341 if ( t_3 ) {
1342
1343 /* type[i] := parent![i]; */
1344 t_3 = ElmPosObj( a_parent, INT_INTOBJ(l_i) );
1345 C_ASS_LIST_FPL( l_type, l_i, t_3 )
1346
1347 }
1348 /* fi */
1349
1350 }
1351 /* od */
1352
1353 }
1354 /* fi */
1355
1356 /* SET_TYPE_POSOBJ( type, TypeOfTypes ); */
1357 t_1 = GF_SET__TYPE__POSOBJ;
1358 t_2 = GC_TypeOfTypes;
1359 CHECK_BOUND( t_2, "TypeOfTypes" );
1360 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1361 CALL_2ARGS( t_1, l_type, t_2 );
1362 }
1363 else {
1364 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_type, t_2 ) );
1365 }
1366
1367 /* if 3 * family!.nTYPES > family!.HASH_SIZE then */
1368 t_3 = ElmComObj( a_family, R_nTYPES );
1369 C_PROD_FIA( t_2, INTOBJ_INT(3), t_3 )
1370 t_3 = ElmComObj( a_family, R_HASH__SIZE );
1371 t_1 = (Obj)(UInt)(LT( t_3, t_2 ));
1372 if ( t_1 ) {
1373
1374 /* ncache := [ ]; */
1375 t_1 = NEW_PLIST( T_PLIST, 0 );
1376 SET_LEN_PLIST( t_1, 0 );
1377 l_ncache = t_1;
1378
1379 /* MIGRATE_RAW( ncache, DS_TYPE_CACHE ); */
1380 t_1 = GF_MIGRATE__RAW;
1381 t_2 = GC_DS__TYPE__CACHE;
1382 CHECK_BOUND( t_2, "DS_TYPE_CACHE" );
1383 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1384 CALL_2ARGS( t_1, l_ncache, t_2 );
1385 }
1386 else {
1387 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_ncache, t_2 ) );
1388 }
1389
1390 /* ncl := 3 * family!.HASH_SIZE + 1; */
1391 t_3 = ElmComObj( a_family, R_HASH__SIZE );
1392 C_PROD_FIA( t_2, INTOBJ_INT(3), t_3 )
1393 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
1394 l_ncl = t_1;
1395
1396 /* for t in cache do */
1397 t_4 = l_cache;
1398 if ( IS_SMALL_LIST(t_4) ) {
1399 t_3 = (Obj)(UInt)1;
1400 t_1 = INTOBJ_INT(1);
1401 }
1402 else {
1403 t_3 = (Obj)(UInt)0;
1404 t_1 = CALL_1ARGS( GF_ITERATOR, t_4 );
1405 }
1406 while ( 1 ) {
1407 if ( t_3 ) {
1408 if ( LEN_LIST(t_4) < INT_INTOBJ(t_1) ) break;
1409 t_2 = ELMV0_LIST( t_4, INT_INTOBJ(t_1) );
1410 t_1 = (Obj)(((UInt)t_1)+4);
1411 if ( t_2 == 0 ) continue;
1412 }
1413 else {
1414 if ( CALL_1ARGS( GF_IS_DONE_ITER, t_1 ) != False ) break;
1415 t_2 = CALL_1ARGS( GF_NEXT_ITER, t_1 );
1416 }
1417 l_t = t_2;
1418
1419 /* ncache[HASH_FLAGS( t![2] ) mod ncl + 1] := t; */
1420 t_8 = GF_HASH__FLAGS;
1421 t_9 = ElmPosObj( l_t, 2 );
1422 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
1423 t_7 = CALL_1ARGS( t_8, t_9 );
1424 }
1425 else {
1426 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( t_9 ) );
1427 }
1428 CHECK_FUNC_RESULT( t_7 );
1429 t_6 = MOD( t_7, l_ncl );
1430 C_SUM_FIA( t_5, t_6, INTOBJ_INT(1) )
1431 CHECK_INT_POS( t_5 );
1432 C_ASS_LIST_FPL( l_ncache, t_5, l_t )
1433
1434 }
1435 /* od */
1436
1437 /* family!.HASH_SIZE := ncl; */
1438 AssComObj( a_family, R_HASH__SIZE, l_ncl );
1439
1440 /* family!.TYPES := ncache; */
1441 AssComObj( a_family, R_TYPES, l_ncache );
1442
1443 /* ncache[HASH_FLAGS( flags ) mod ncl + 1] := type; */
1444 t_4 = GF_HASH__FLAGS;
1445 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1446 t_3 = CALL_1ARGS( t_4, a_flags );
1447 }
1448 else {
1449 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_flags ) );
1450 }
1451 CHECK_FUNC_RESULT( t_3 );
1452 t_2 = MOD( t_3, l_ncl );
1453 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
1454 CHECK_INT_POS( t_1 );
1455 C_ASS_LIST_FPL( l_ncache, t_1, l_type )
1456
1457 }
1458
1459 /* else */
1460 else {
1461
1462 /* cache[hash] := type; */
1463 C_ASS_LIST_FPL( l_cache, l_hash, l_type )
1464
1465 }
1466 /* fi */
1467
1468 /* family!.nTYPES := family!.nTYPES + 1; */
1469 t_2 = ElmComObj( a_family, R_nTYPES );
1470 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
1471 AssComObj( a_family, R_nTYPES, t_1 );
1472
1473 /* MakeReadOnlySingleObj( type ); */
1474 t_1 = GF_MakeReadOnlySingleObj;
1475 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1476 CALL_1ARGS( t_1, l_type );
1477 }
1478 else {
1479 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_type ) );
1480 }
1481
1482 /* UNLOCK( lock ); */
1483 t_1 = GF_UNLOCK;
1484 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1485 CALL_1ARGS( t_1, l_lock );
1486 }
1487 else {
1488 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_lock ) );
1489 }
1490
1491 /* return type; */
1492 SWITCH_TO_OLD_FRAME(oldFrame);
1493 return l_type;
1494
1495 /* return; */
1496 SWITCH_TO_OLD_FRAME(oldFrame);
1497 return 0;
1498 }
1499
1500 /* handler for function 8 */
HdlrFunc8(Obj self,Obj args)1501 static Obj HdlrFunc8 (
1502 Obj self,
1503 Obj args )
1504 {
1505 Obj a_family;
1506 Obj a_filter;
1507 Obj a_data;
1508 Obj t_1 = 0;
1509 Obj t_2 = 0;
1510 Obj t_3 = 0;
1511 Obj t_4 = 0;
1512 Obj t_5 = 0;
1513 Obj t_6 = 0;
1514 Obj t_7 = 0;
1515 Obj t_8 = 0;
1516 Obj t_9 = 0;
1517 Bag oldFrame;
1518 CHECK_NR_AT_LEAST_ARGS( 3, args )
1519 a_family = ELM_PLIST( args, 1 );
1520 a_filter = ELM_PLIST( args, 2 );
1521 Obj x_temp_range = Range2Check(INTOBJ_INT(3), INTOBJ_INT(LEN_PLIST(args)));
1522 a_data = ELMS_LIST(args , x_temp_range);
1523
1524 /* allocate new stack frame */
1525 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1526
1527 /* if not IsFamily( family ) then */
1528 t_4 = GF_IsFamily;
1529 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1530 t_3 = CALL_1ARGS( t_4, a_family );
1531 }
1532 else {
1533 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_family ) );
1534 }
1535 CHECK_FUNC_RESULT( t_3 );
1536 CHECK_BOOL( t_3 );
1537 t_2 = (Obj)(UInt)(t_3 != False);
1538 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
1539 if ( t_1 ) {
1540
1541 /* Error( "<family> must be a family" ); */
1542 t_1 = GF_Error;
1543 t_2 = MakeString( "<family> must be a family" );
1544 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1545 CALL_1ARGS( t_1, t_2 );
1546 }
1547 else {
1548 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
1549 }
1550
1551 }
1552 /* fi */
1553
1554 /* if LEN_LIST( data ) = 0 then */
1555 t_3 = GF_LEN__LIST;
1556 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1557 t_2 = CALL_1ARGS( t_3, a_data );
1558 }
1559 else {
1560 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_data ) );
1561 }
1562 CHECK_FUNC_RESULT( t_2 );
1563 t_1 = (Obj)(UInt)(EQ( t_2, INTOBJ_INT(0) ));
1564 if ( t_1 ) {
1565
1566 /* data := fail; */
1567 t_1 = GC_fail;
1568 CHECK_BOUND( t_1, "fail" );
1569 a_data = t_1;
1570
1571 }
1572
1573 /* elif LEN_LIST( data ) = 1 then */
1574 else {
1575 t_3 = GF_LEN__LIST;
1576 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1577 t_2 = CALL_1ARGS( t_3, a_data );
1578 }
1579 else {
1580 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_data ) );
1581 }
1582 CHECK_FUNC_RESULT( t_2 );
1583 t_1 = (Obj)(UInt)(EQ( t_2, INTOBJ_INT(1) ));
1584 if ( t_1 ) {
1585
1586 /* data := data[1]; */
1587 C_ELM_LIST_FPL( t_1, a_data, INTOBJ_INT(1) )
1588 a_data = t_1;
1589
1590 }
1591
1592 /* else */
1593 else {
1594
1595 /* Error( "usage: NewType( <family>, <filter> [, <data> ] )" ); */
1596 t_1 = GF_Error;
1597 t_2 = MakeString( "usage: NewType( <family>, <filter> [, <data> ] )" );
1598 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1599 CALL_1ARGS( t_1, t_2 );
1600 }
1601 else {
1602 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
1603 }
1604
1605 }
1606 }
1607 /* fi */
1608
1609 /* return NEW_TYPE( family, WITH_IMPS_FLAGS( AND_FLAGS( family!.IMP_FLAGS, FLAGS_FILTER( filter ) ) ), data, fail ); */
1610 t_2 = GF_NEW__TYPE;
1611 t_4 = GF_WITH__IMPS__FLAGS;
1612 t_6 = GF_AND__FLAGS;
1613 t_7 = ElmComObj( a_family, R_IMP__FLAGS );
1614 t_9 = GF_FLAGS__FILTER;
1615 if ( TNUM_OBJ( t_9 ) == T_FUNCTION ) {
1616 t_8 = CALL_1ARGS( t_9, a_filter );
1617 }
1618 else {
1619 t_8 = DoOperation2Args( CallFuncListOper, t_9, NewPlistFromArgs( a_filter ) );
1620 }
1621 CHECK_FUNC_RESULT( t_8 );
1622 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
1623 t_5 = CALL_2ARGS( t_6, t_7, t_8 );
1624 }
1625 else {
1626 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( t_7, t_8 ) );
1627 }
1628 CHECK_FUNC_RESULT( t_5 );
1629 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1630 t_3 = CALL_1ARGS( t_4, t_5 );
1631 }
1632 else {
1633 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( t_5 ) );
1634 }
1635 CHECK_FUNC_RESULT( t_3 );
1636 t_4 = GC_fail;
1637 CHECK_BOUND( t_4, "fail" );
1638 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
1639 t_1 = CALL_4ARGS( t_2, a_family, t_3, a_data, t_4 );
1640 }
1641 else {
1642 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( a_family, t_3, a_data, t_4 ) );
1643 }
1644 CHECK_FUNC_RESULT( t_1 );
1645 SWITCH_TO_OLD_FRAME(oldFrame);
1646 return t_1;
1647
1648 /* return; */
1649 SWITCH_TO_OLD_FRAME(oldFrame);
1650 return 0;
1651 }
1652
1653 /* handler for function 9 */
HdlrFunc9(Obj self,Obj a_type,Obj a_filter)1654 static Obj HdlrFunc9 (
1655 Obj self,
1656 Obj a_type,
1657 Obj a_filter )
1658 {
1659 Obj t_1 = 0;
1660 Obj t_2 = 0;
1661 Obj t_3 = 0;
1662 Obj t_4 = 0;
1663 Obj t_5 = 0;
1664 Obj t_6 = 0;
1665 Obj t_7 = 0;
1666 Obj t_8 = 0;
1667 Obj t_9 = 0;
1668 Obj t_10 = 0;
1669 Bag oldFrame;
1670
1671 /* allocate new stack frame */
1672 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1673
1674 /* if not IsType( type ) then */
1675 t_4 = GF_IsType;
1676 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1677 t_3 = CALL_1ARGS( t_4, a_type );
1678 }
1679 else {
1680 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_type ) );
1681 }
1682 CHECK_FUNC_RESULT( t_3 );
1683 CHECK_BOOL( t_3 );
1684 t_2 = (Obj)(UInt)(t_3 != False);
1685 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
1686 if ( t_1 ) {
1687
1688 /* Error( "<type> must be a type" ); */
1689 t_1 = GF_Error;
1690 t_2 = MakeString( "<type> must be a type" );
1691 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1692 CALL_1ARGS( t_1, t_2 );
1693 }
1694 else {
1695 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
1696 }
1697
1698 }
1699 /* fi */
1700
1701 /* return NEW_TYPE( type![1], WITH_IMPS_FLAGS( AND_FLAGS( type![2], FLAGS_FILTER( filter ) ) ), type![3], type ); */
1702 t_2 = GF_NEW__TYPE;
1703 t_3 = ElmPosObj( a_type, 1 );
1704 t_5 = GF_WITH__IMPS__FLAGS;
1705 t_7 = GF_AND__FLAGS;
1706 t_8 = ElmPosObj( a_type, 2 );
1707 t_10 = GF_FLAGS__FILTER;
1708 if ( TNUM_OBJ( t_10 ) == T_FUNCTION ) {
1709 t_9 = CALL_1ARGS( t_10, a_filter );
1710 }
1711 else {
1712 t_9 = DoOperation2Args( CallFuncListOper, t_10, NewPlistFromArgs( a_filter ) );
1713 }
1714 CHECK_FUNC_RESULT( t_9 );
1715 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
1716 t_6 = CALL_2ARGS( t_7, t_8, t_9 );
1717 }
1718 else {
1719 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( t_8, t_9 ) );
1720 }
1721 CHECK_FUNC_RESULT( t_6 );
1722 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
1723 t_4 = CALL_1ARGS( t_5, t_6 );
1724 }
1725 else {
1726 t_4 = DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( t_6 ) );
1727 }
1728 CHECK_FUNC_RESULT( t_4 );
1729 t_5 = ElmPosObj( a_type, 3 );
1730 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
1731 t_1 = CALL_4ARGS( t_2, t_3, t_4, t_5, a_type );
1732 }
1733 else {
1734 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3, t_4, t_5, a_type ) );
1735 }
1736 CHECK_FUNC_RESULT( t_1 );
1737 SWITCH_TO_OLD_FRAME(oldFrame);
1738 return t_1;
1739
1740 /* return; */
1741 SWITCH_TO_OLD_FRAME(oldFrame);
1742 return 0;
1743 }
1744
1745 /* handler for function 10 */
HdlrFunc10(Obj self,Obj a_type,Obj a_filter)1746 static Obj HdlrFunc10 (
1747 Obj self,
1748 Obj a_type,
1749 Obj a_filter )
1750 {
1751 Obj t_1 = 0;
1752 Obj t_2 = 0;
1753 Obj t_3 = 0;
1754 Obj t_4 = 0;
1755 Obj t_5 = 0;
1756 Obj t_6 = 0;
1757 Obj t_7 = 0;
1758 Obj t_8 = 0;
1759 Bag oldFrame;
1760
1761 /* allocate new stack frame */
1762 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1763
1764 /* if not IsType( type ) then */
1765 t_4 = GF_IsType;
1766 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1767 t_3 = CALL_1ARGS( t_4, a_type );
1768 }
1769 else {
1770 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_type ) );
1771 }
1772 CHECK_FUNC_RESULT( t_3 );
1773 CHECK_BOOL( t_3 );
1774 t_2 = (Obj)(UInt)(t_3 != False);
1775 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
1776 if ( t_1 ) {
1777
1778 /* Error( "<type> must be a type" ); */
1779 t_1 = GF_Error;
1780 t_2 = MakeString( "<type> must be a type" );
1781 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1782 CALL_1ARGS( t_1, t_2 );
1783 }
1784 else {
1785 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
1786 }
1787
1788 }
1789 /* fi */
1790
1791 /* return NEW_TYPE( type![1], SUB_FLAGS( type![2], FLAGS_FILTER( filter ) ), type![3], type ); */
1792 t_2 = GF_NEW__TYPE;
1793 t_3 = ElmPosObj( a_type, 1 );
1794 t_5 = GF_SUB__FLAGS;
1795 t_6 = ElmPosObj( a_type, 2 );
1796 t_8 = GF_FLAGS__FILTER;
1797 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
1798 t_7 = CALL_1ARGS( t_8, a_filter );
1799 }
1800 else {
1801 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( a_filter ) );
1802 }
1803 CHECK_FUNC_RESULT( t_7 );
1804 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
1805 t_4 = CALL_2ARGS( t_5, t_6, t_7 );
1806 }
1807 else {
1808 t_4 = DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( t_6, t_7 ) );
1809 }
1810 CHECK_FUNC_RESULT( t_4 );
1811 t_5 = ElmPosObj( a_type, 3 );
1812 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
1813 t_1 = CALL_4ARGS( t_2, t_3, t_4, t_5, a_type );
1814 }
1815 else {
1816 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3, t_4, t_5, a_type ) );
1817 }
1818 CHECK_FUNC_RESULT( t_1 );
1819 SWITCH_TO_OLD_FRAME(oldFrame);
1820 return t_1;
1821
1822 /* return; */
1823 SWITCH_TO_OLD_FRAME(oldFrame);
1824 return 0;
1825 }
1826
1827 /* handler for function 11 */
HdlrFunc11(Obj self,Obj a_K)1828 static Obj HdlrFunc11 (
1829 Obj self,
1830 Obj a_K )
1831 {
1832 Obj t_1 = 0;
1833 Bag oldFrame;
1834
1835 /* allocate new stack frame */
1836 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1837
1838 /* return K![1]; */
1839 t_1 = ElmPosObj( a_K, 1 );
1840 SWITCH_TO_OLD_FRAME(oldFrame);
1841 return t_1;
1842
1843 /* return; */
1844 SWITCH_TO_OLD_FRAME(oldFrame);
1845 return 0;
1846 }
1847
1848 /* handler for function 12 */
HdlrFunc12(Obj self,Obj a_K)1849 static Obj HdlrFunc12 (
1850 Obj self,
1851 Obj a_K )
1852 {
1853 Obj t_1 = 0;
1854 Bag oldFrame;
1855
1856 /* allocate new stack frame */
1857 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1858
1859 /* return K![2]; */
1860 t_1 = ElmPosObj( a_K, 2 );
1861 SWITCH_TO_OLD_FRAME(oldFrame);
1862 return t_1;
1863
1864 /* return; */
1865 SWITCH_TO_OLD_FRAME(oldFrame);
1866 return 0;
1867 }
1868
1869 /* handler for function 13 */
HdlrFunc13(Obj self,Obj a_K)1870 static Obj HdlrFunc13 (
1871 Obj self,
1872 Obj a_K )
1873 {
1874 Obj t_1 = 0;
1875 Bag oldFrame;
1876
1877 /* allocate new stack frame */
1878 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1879
1880 /* return K![3]; */
1881 t_1 = ElmPosObj( a_K, 3 );
1882 SWITCH_TO_OLD_FRAME(oldFrame);
1883 return t_1;
1884
1885 /* return; */
1886 SWITCH_TO_OLD_FRAME(oldFrame);
1887 return 0;
1888 }
1889
1890 /* handler for function 14 */
HdlrFunc14(Obj self,Obj a_K,Obj a_data)1891 static Obj HdlrFunc14 (
1892 Obj self,
1893 Obj a_K,
1894 Obj a_data )
1895 {
1896 Obj t_1 = 0;
1897 Obj t_2 = 0;
1898 Obj t_3 = 0;
1899 Bag oldFrame;
1900
1901 /* allocate new stack frame */
1902 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1903
1904 /* StrictBindOnce( K, 3, MakeImmutable( data ) ); */
1905 t_1 = GF_StrictBindOnce;
1906 t_3 = GF_MakeImmutable;
1907 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
1908 t_2 = CALL_1ARGS( t_3, a_data );
1909 }
1910 else {
1911 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_data ) );
1912 }
1913 CHECK_FUNC_RESULT( t_2 );
1914 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
1915 CALL_3ARGS( t_1, a_K, INTOBJ_INT(3), t_2 );
1916 }
1917 else {
1918 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_K, INTOBJ_INT(3), t_2 ) );
1919 }
1920
1921 /* return; */
1922 SWITCH_TO_OLD_FRAME(oldFrame);
1923 return 0;
1924
1925 /* return; */
1926 SWITCH_TO_OLD_FRAME(oldFrame);
1927 return 0;
1928 }
1929
1930 /* handler for function 15 */
HdlrFunc15(Obj self,Obj a_obj)1931 static Obj HdlrFunc15 (
1932 Obj self,
1933 Obj a_obj )
1934 {
1935 Obj t_1 = 0;
1936 Obj t_2 = 0;
1937 Obj t_3 = 0;
1938 Obj t_4 = 0;
1939 Bag oldFrame;
1940
1941 /* allocate new stack frame */
1942 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1943
1944 /* return FlagsType( TypeObj( obj ) ); */
1945 t_2 = GF_FlagsType;
1946 t_4 = GF_TypeObj;
1947 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1948 t_3 = CALL_1ARGS( t_4, a_obj );
1949 }
1950 else {
1951 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_obj ) );
1952 }
1953 CHECK_FUNC_RESULT( t_3 );
1954 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
1955 t_1 = CALL_1ARGS( t_2, t_3 );
1956 }
1957 else {
1958 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
1959 }
1960 CHECK_FUNC_RESULT( t_1 );
1961 SWITCH_TO_OLD_FRAME(oldFrame);
1962 return t_1;
1963
1964 /* return; */
1965 SWITCH_TO_OLD_FRAME(oldFrame);
1966 return 0;
1967 }
1968
1969 /* handler for function 16 */
HdlrFunc16(Obj self,Obj a_obj)1970 static Obj HdlrFunc16 (
1971 Obj self,
1972 Obj a_obj )
1973 {
1974 Obj t_1 = 0;
1975 Obj t_2 = 0;
1976 Obj t_3 = 0;
1977 Obj t_4 = 0;
1978 Bag oldFrame;
1979
1980 /* allocate new stack frame */
1981 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
1982
1983 /* return DataType( TypeObj( obj ) ); */
1984 t_2 = GF_DataType;
1985 t_4 = GF_TypeObj;
1986 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
1987 t_3 = CALL_1ARGS( t_4, a_obj );
1988 }
1989 else {
1990 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_obj ) );
1991 }
1992 CHECK_FUNC_RESULT( t_3 );
1993 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
1994 t_1 = CALL_1ARGS( t_2, t_3 );
1995 }
1996 else {
1997 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
1998 }
1999 CHECK_FUNC_RESULT( t_1 );
2000 SWITCH_TO_OLD_FRAME(oldFrame);
2001 return t_1;
2002
2003 /* return; */
2004 SWITCH_TO_OLD_FRAME(oldFrame);
2005 return 0;
2006 }
2007
2008 /* handler for function 17 */
HdlrFunc17(Obj self,Obj a_type,Obj a_obj)2009 static Obj HdlrFunc17 (
2010 Obj self,
2011 Obj a_type,
2012 Obj a_obj )
2013 {
2014 Obj l_flags = 0;
2015 Obj t_1 = 0;
2016 Obj t_2 = 0;
2017 Obj t_3 = 0;
2018 Obj t_4 = 0;
2019 Obj t_5 = 0;
2020 (void)l_flags;
2021 Bag oldFrame;
2022
2023 /* allocate new stack frame */
2024 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
2025
2026 /* if not IsType( type ) then */
2027 t_4 = GF_IsType;
2028 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
2029 t_3 = CALL_1ARGS( t_4, a_type );
2030 }
2031 else {
2032 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_type ) );
2033 }
2034 CHECK_FUNC_RESULT( t_3 );
2035 CHECK_BOOL( t_3 );
2036 t_2 = (Obj)(UInt)(t_3 != False);
2037 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
2038 if ( t_1 ) {
2039
2040 /* Error( "<type> must be a type" ); */
2041 t_1 = GF_Error;
2042 t_2 = MakeString( "<type> must be a type" );
2043 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2044 CALL_1ARGS( t_1, t_2 );
2045 }
2046 else {
2047 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
2048 }
2049
2050 }
2051 /* fi */
2052
2053 /* flags := FlagsType( type ); */
2054 t_2 = GF_FlagsType;
2055 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
2056 t_1 = CALL_1ARGS( t_2, a_type );
2057 }
2058 else {
2059 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( a_type ) );
2060 }
2061 CHECK_FUNC_RESULT( t_1 );
2062 l_flags = t_1;
2063
2064 /* if IS_LIST( obj ) then */
2065 t_3 = GF_IS__LIST;
2066 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2067 t_2 = CALL_1ARGS( t_3, a_obj );
2068 }
2069 else {
2070 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2071 }
2072 CHECK_FUNC_RESULT( t_2 );
2073 CHECK_BOOL( t_2 );
2074 t_1 = (Obj)(UInt)(t_2 != False);
2075 if ( t_1 ) {
2076
2077 /* if IS_SUBSET_FLAGS( flags, IsAtomicPositionalObjectRepFlags ) then */
2078 t_3 = GF_IS__SUBSET__FLAGS;
2079 t_4 = GC_IsAtomicPositionalObjectRepFlags;
2080 CHECK_BOUND( t_4, "IsAtomicPositionalObjectRepFlags" );
2081 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2082 t_2 = CALL_2ARGS( t_3, l_flags, t_4 );
2083 }
2084 else {
2085 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( l_flags, t_4 ) );
2086 }
2087 CHECK_FUNC_RESULT( t_2 );
2088 CHECK_BOOL( t_2 );
2089 t_1 = (Obj)(UInt)(t_2 != False);
2090 if ( t_1 ) {
2091
2092 /* FORCE_SWITCH_OBJ( obj, FixedAtomicList( obj ) ); */
2093 t_1 = GF_FORCE__SWITCH__OBJ;
2094 t_3 = GF_FixedAtomicList;
2095 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2096 t_2 = CALL_1ARGS( t_3, a_obj );
2097 }
2098 else {
2099 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2100 }
2101 CHECK_FUNC_RESULT( t_2 );
2102 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2103 CALL_2ARGS( t_1, a_obj, t_2 );
2104 }
2105 else {
2106 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, t_2 ) );
2107 }
2108
2109 }
2110 /* fi */
2111
2112 }
2113
2114 /* elif IS_REC( obj ) then */
2115 else {
2116 t_3 = GF_IS__REC;
2117 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2118 t_2 = CALL_1ARGS( t_3, a_obj );
2119 }
2120 else {
2121 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2122 }
2123 CHECK_FUNC_RESULT( t_2 );
2124 CHECK_BOOL( t_2 );
2125 t_1 = (Obj)(UInt)(t_2 != False);
2126 if ( t_1 ) {
2127
2128 /* if IS_ATOMIC_RECORD( obj ) then */
2129 t_3 = GF_IS__ATOMIC__RECORD;
2130 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2131 t_2 = CALL_1ARGS( t_3, a_obj );
2132 }
2133 else {
2134 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2135 }
2136 CHECK_FUNC_RESULT( t_2 );
2137 CHECK_BOOL( t_2 );
2138 t_1 = (Obj)(UInt)(t_2 != False);
2139 if ( t_1 ) {
2140
2141 /* if IS_SUBSET_FLAGS( flags, IsNonAtomicComponentObjectRepFlags ) then */
2142 t_3 = GF_IS__SUBSET__FLAGS;
2143 t_4 = GC_IsNonAtomicComponentObjectRepFlags;
2144 CHECK_BOUND( t_4, "IsNonAtomicComponentObjectRepFlags" );
2145 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2146 t_2 = CALL_2ARGS( t_3, l_flags, t_4 );
2147 }
2148 else {
2149 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( l_flags, t_4 ) );
2150 }
2151 CHECK_FUNC_RESULT( t_2 );
2152 CHECK_BOOL( t_2 );
2153 t_1 = (Obj)(UInt)(t_2 != False);
2154 if ( t_1 ) {
2155
2156 /* FORCE_SWITCH_OBJ( obj, FromAtomicRecord( obj ) ); */
2157 t_1 = GF_FORCE__SWITCH__OBJ;
2158 t_3 = GF_FromAtomicRecord;
2159 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2160 t_2 = CALL_1ARGS( t_3, a_obj );
2161 }
2162 else {
2163 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2164 }
2165 CHECK_FUNC_RESULT( t_2 );
2166 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2167 CALL_2ARGS( t_1, a_obj, t_2 );
2168 }
2169 else {
2170 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, t_2 ) );
2171 }
2172
2173 }
2174 /* fi */
2175
2176 }
2177
2178 /* elif not IS_SUBSET_FLAGS( flags, IsNonAtomicComponentObjectRepFlags ) then */
2179 else {
2180 t_4 = GF_IS__SUBSET__FLAGS;
2181 t_5 = GC_IsNonAtomicComponentObjectRepFlags;
2182 CHECK_BOUND( t_5, "IsNonAtomicComponentObjectRepFlags" );
2183 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
2184 t_3 = CALL_2ARGS( t_4, l_flags, t_5 );
2185 }
2186 else {
2187 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( l_flags, t_5 ) );
2188 }
2189 CHECK_FUNC_RESULT( t_3 );
2190 CHECK_BOOL( t_3 );
2191 t_2 = (Obj)(UInt)(t_3 != False);
2192 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
2193 if ( t_1 ) {
2194
2195 /* FORCE_SWITCH_OBJ( obj, AtomicRecord( obj ) ); */
2196 t_1 = GF_FORCE__SWITCH__OBJ;
2197 t_3 = GF_AtomicRecord;
2198 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2199 t_2 = CALL_1ARGS( t_3, a_obj );
2200 }
2201 else {
2202 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2203 }
2204 CHECK_FUNC_RESULT( t_2 );
2205 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2206 CALL_2ARGS( t_1, a_obj, t_2 );
2207 }
2208 else {
2209 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, t_2 ) );
2210 }
2211
2212 }
2213 }
2214 /* fi */
2215
2216 }
2217 }
2218 /* fi */
2219
2220 /* if IS_LIST( obj ) then */
2221 t_3 = GF_IS__LIST;
2222 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2223 t_2 = CALL_1ARGS( t_3, a_obj );
2224 }
2225 else {
2226 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2227 }
2228 CHECK_FUNC_RESULT( t_2 );
2229 CHECK_BOOL( t_2 );
2230 t_1 = (Obj)(UInt)(t_2 != False);
2231 if ( t_1 ) {
2232
2233 /* SET_TYPE_POSOBJ( obj, type ); */
2234 t_1 = GF_SET__TYPE__POSOBJ;
2235 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2236 CALL_2ARGS( t_1, a_obj, a_type );
2237 }
2238 else {
2239 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, a_type ) );
2240 }
2241
2242 }
2243
2244 /* elif IS_REC( obj ) then */
2245 else {
2246 t_3 = GF_IS__REC;
2247 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2248 t_2 = CALL_1ARGS( t_3, a_obj );
2249 }
2250 else {
2251 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2252 }
2253 CHECK_FUNC_RESULT( t_2 );
2254 CHECK_BOOL( t_2 );
2255 t_1 = (Obj)(UInt)(t_2 != False);
2256 if ( t_1 ) {
2257
2258 /* SET_TYPE_COMOBJ( obj, type ); */
2259 t_1 = GF_SET__TYPE__COMOBJ;
2260 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2261 CALL_2ARGS( t_1, a_obj, a_type );
2262 }
2263 else {
2264 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, a_type ) );
2265 }
2266
2267 }
2268 }
2269 /* fi */
2270
2271 /* if not IsNoImmediateMethodsObject( obj ) then */
2272 t_4 = GF_IsNoImmediateMethodsObject;
2273 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
2274 t_3 = CALL_1ARGS( t_4, a_obj );
2275 }
2276 else {
2277 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_obj ) );
2278 }
2279 CHECK_FUNC_RESULT( t_3 );
2280 CHECK_BOOL( t_3 );
2281 t_2 = (Obj)(UInt)(t_3 != False);
2282 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
2283 if ( t_1 ) {
2284
2285 /* RunImmediateMethods( obj, type![2] ); */
2286 t_1 = GF_RunImmediateMethods;
2287 t_2 = ElmPosObj( a_type, 2 );
2288 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2289 CALL_2ARGS( t_1, a_obj, t_2 );
2290 }
2291 else {
2292 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, t_2 ) );
2293 }
2294
2295 }
2296 /* fi */
2297
2298 /* if IsReadOnlyPositionalObjectRep( obj ) then */
2299 t_3 = GF_IsReadOnlyPositionalObjectRep;
2300 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2301 t_2 = CALL_1ARGS( t_3, a_obj );
2302 }
2303 else {
2304 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2305 }
2306 CHECK_FUNC_RESULT( t_2 );
2307 CHECK_BOOL( t_2 );
2308 t_1 = (Obj)(UInt)(t_2 != False);
2309 if ( t_1 ) {
2310
2311 /* MakeReadOnlySingleObj( obj ); */
2312 t_1 = GF_MakeReadOnlySingleObj;
2313 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2314 CALL_1ARGS( t_1, a_obj );
2315 }
2316 else {
2317 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj ) );
2318 }
2319
2320 }
2321 /* fi */
2322
2323 /* return obj; */
2324 SWITCH_TO_OLD_FRAME(oldFrame);
2325 return a_obj;
2326
2327 /* return; */
2328 SWITCH_TO_OLD_FRAME(oldFrame);
2329 return 0;
2330 }
2331
2332 /* handler for function 18 */
HdlrFunc18(Obj self,Obj a_obj,Obj a_filter)2333 static Obj HdlrFunc18 (
2334 Obj self,
2335 Obj a_obj,
2336 Obj a_filter )
2337 {
2338 Obj l_type = 0;
2339 Obj l_newtype = 0;
2340 Obj t_1 = 0;
2341 Obj t_2 = 0;
2342 Obj t_3 = 0;
2343 Obj t_4 = 0;
2344 Obj t_5 = 0;
2345 Obj t_6 = 0;
2346 (void)l_type;
2347 (void)l_newtype;
2348 Bag oldFrame;
2349
2350 /* allocate new stack frame */
2351 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
2352
2353 /* type := TYPE_OBJ( obj ); */
2354 t_2 = GF_TYPE__OBJ;
2355 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
2356 t_1 = CALL_1ARGS( t_2, a_obj );
2357 }
2358 else {
2359 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( a_obj ) );
2360 }
2361 CHECK_FUNC_RESULT( t_1 );
2362 l_type = t_1;
2363
2364 /* newtype := Subtype( type, filter ); */
2365 t_2 = GF_Subtype;
2366 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
2367 t_1 = CALL_2ARGS( t_2, l_type, a_filter );
2368 }
2369 else {
2370 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( l_type, a_filter ) );
2371 }
2372 CHECK_FUNC_RESULT( t_1 );
2373 l_newtype = t_1;
2374
2375 /* if IS_POSOBJ( obj ) then */
2376 t_3 = GF_IS__POSOBJ;
2377 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2378 t_2 = CALL_1ARGS( t_3, a_obj );
2379 }
2380 else {
2381 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2382 }
2383 CHECK_FUNC_RESULT( t_2 );
2384 CHECK_BOOL( t_2 );
2385 t_1 = (Obj)(UInt)(t_2 != False);
2386 if ( t_1 ) {
2387
2388 /* SET_TYPE_POSOBJ( obj, newtype ); */
2389 t_1 = GF_SET__TYPE__POSOBJ;
2390 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2391 CALL_2ARGS( t_1, a_obj, l_newtype );
2392 }
2393 else {
2394 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, l_newtype ) );
2395 }
2396
2397 }
2398
2399 /* elif IS_COMOBJ( obj ) then */
2400 else {
2401 t_3 = GF_IS__COMOBJ;
2402 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2403 t_2 = CALL_1ARGS( t_3, a_obj );
2404 }
2405 else {
2406 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2407 }
2408 CHECK_FUNC_RESULT( t_2 );
2409 CHECK_BOOL( t_2 );
2410 t_1 = (Obj)(UInt)(t_2 != False);
2411 if ( t_1 ) {
2412
2413 /* SET_TYPE_COMOBJ( obj, newtype ); */
2414 t_1 = GF_SET__TYPE__COMOBJ;
2415 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2416 CALL_2ARGS( t_1, a_obj, l_newtype );
2417 }
2418 else {
2419 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, l_newtype ) );
2420 }
2421
2422 }
2423
2424 /* elif IS_DATOBJ( obj ) then */
2425 else {
2426 t_3 = GF_IS__DATOBJ;
2427 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2428 t_2 = CALL_1ARGS( t_3, a_obj );
2429 }
2430 else {
2431 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2432 }
2433 CHECK_FUNC_RESULT( t_2 );
2434 CHECK_BOOL( t_2 );
2435 t_1 = (Obj)(UInt)(t_2 != False);
2436 if ( t_1 ) {
2437
2438 /* SET_TYPE_DATOBJ( obj, newtype ); */
2439 t_1 = GF_SET__TYPE__DATOBJ;
2440 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2441 CALL_2ARGS( t_1, a_obj, l_newtype );
2442 }
2443 else {
2444 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, l_newtype ) );
2445 }
2446
2447 }
2448
2449 /* else */
2450 else {
2451
2452 /* ErrorNoReturn( "cannot set filter for internal object" ); */
2453 t_1 = GF_ErrorNoReturn;
2454 t_2 = MakeString( "cannot set filter for internal object" );
2455 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2456 CALL_1ARGS( t_1, t_2 );
2457 }
2458 else {
2459 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
2460 }
2461
2462 }
2463 }
2464 }
2465 /* fi */
2466
2467 /* if not (IGNORE_IMMEDIATE_METHODS or IsNoImmediateMethodsObject( obj )) then */
2468 t_4 = GC_IGNORE__IMMEDIATE__METHODS;
2469 CHECK_BOUND( t_4, "IGNORE_IMMEDIATE_METHODS" );
2470 CHECK_BOOL( t_4 );
2471 t_3 = (Obj)(UInt)(t_4 != False);
2472 t_2 = t_3;
2473 if ( ! t_2 ) {
2474 t_6 = GF_IsNoImmediateMethodsObject;
2475 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
2476 t_5 = CALL_1ARGS( t_6, a_obj );
2477 }
2478 else {
2479 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( a_obj ) );
2480 }
2481 CHECK_FUNC_RESULT( t_5 );
2482 CHECK_BOOL( t_5 );
2483 t_4 = (Obj)(UInt)(t_5 != False);
2484 t_2 = t_4;
2485 }
2486 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
2487 if ( t_1 ) {
2488
2489 /* RunImmediateMethods( obj, SUB_FLAGS( newtype![2], type![2] ) ); */
2490 t_1 = GF_RunImmediateMethods;
2491 t_3 = GF_SUB__FLAGS;
2492 t_4 = ElmPosObj( l_newtype, 2 );
2493 t_5 = ElmPosObj( l_type, 2 );
2494 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2495 t_2 = CALL_2ARGS( t_3, t_4, t_5 );
2496 }
2497 else {
2498 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( t_4, t_5 ) );
2499 }
2500 CHECK_FUNC_RESULT( t_2 );
2501 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2502 CALL_2ARGS( t_1, a_obj, t_2 );
2503 }
2504 else {
2505 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, t_2 ) );
2506 }
2507
2508 }
2509 /* fi */
2510
2511 /* return; */
2512 SWITCH_TO_OLD_FRAME(oldFrame);
2513 return 0;
2514
2515 /* return; */
2516 SWITCH_TO_OLD_FRAME(oldFrame);
2517 return 0;
2518 }
2519
2520 /* handler for function 19 */
HdlrFunc19(Obj self,Obj a_obj,Obj a_filter)2521 static Obj HdlrFunc19 (
2522 Obj self,
2523 Obj a_obj,
2524 Obj a_filter )
2525 {
2526 Obj l_type = 0;
2527 Obj l_newtype = 0;
2528 Obj t_1 = 0;
2529 Obj t_2 = 0;
2530 Obj t_3 = 0;
2531 (void)l_type;
2532 (void)l_newtype;
2533 Bag oldFrame;
2534
2535 /* allocate new stack frame */
2536 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
2537
2538 /* if IS_AND_FILTER( filter ) then */
2539 t_3 = GF_IS__AND__FILTER;
2540 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2541 t_2 = CALL_1ARGS( t_3, a_filter );
2542 }
2543 else {
2544 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_filter ) );
2545 }
2546 CHECK_FUNC_RESULT( t_2 );
2547 CHECK_BOOL( t_2 );
2548 t_1 = (Obj)(UInt)(t_2 != False);
2549 if ( t_1 ) {
2550
2551 /* Error( "You can't reset an \"and-filter\". Reset components individually." ); */
2552 t_1 = GF_Error;
2553 t_2 = MakeString( "You can't reset an \"and-filter\". Reset components individually." );
2554 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2555 CALL_1ARGS( t_1, t_2 );
2556 }
2557 else {
2558 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
2559 }
2560
2561 }
2562 /* fi */
2563
2564 /* type := TYPE_OBJ( obj ); */
2565 t_2 = GF_TYPE__OBJ;
2566 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
2567 t_1 = CALL_1ARGS( t_2, a_obj );
2568 }
2569 else {
2570 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( a_obj ) );
2571 }
2572 CHECK_FUNC_RESULT( t_1 );
2573 l_type = t_1;
2574
2575 /* newtype := SupType( type, filter ); */
2576 t_2 = GF_SupType;
2577 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
2578 t_1 = CALL_2ARGS( t_2, l_type, a_filter );
2579 }
2580 else {
2581 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( l_type, a_filter ) );
2582 }
2583 CHECK_FUNC_RESULT( t_1 );
2584 l_newtype = t_1;
2585
2586 /* if IS_POSOBJ( obj ) then */
2587 t_3 = GF_IS__POSOBJ;
2588 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2589 t_2 = CALL_1ARGS( t_3, a_obj );
2590 }
2591 else {
2592 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2593 }
2594 CHECK_FUNC_RESULT( t_2 );
2595 CHECK_BOOL( t_2 );
2596 t_1 = (Obj)(UInt)(t_2 != False);
2597 if ( t_1 ) {
2598
2599 /* SET_TYPE_POSOBJ( obj, newtype ); */
2600 t_1 = GF_SET__TYPE__POSOBJ;
2601 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2602 CALL_2ARGS( t_1, a_obj, l_newtype );
2603 }
2604 else {
2605 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, l_newtype ) );
2606 }
2607
2608 }
2609
2610 /* elif IS_COMOBJ( obj ) then */
2611 else {
2612 t_3 = GF_IS__COMOBJ;
2613 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2614 t_2 = CALL_1ARGS( t_3, a_obj );
2615 }
2616 else {
2617 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2618 }
2619 CHECK_FUNC_RESULT( t_2 );
2620 CHECK_BOOL( t_2 );
2621 t_1 = (Obj)(UInt)(t_2 != False);
2622 if ( t_1 ) {
2623
2624 /* SET_TYPE_COMOBJ( obj, newtype ); */
2625 t_1 = GF_SET__TYPE__COMOBJ;
2626 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2627 CALL_2ARGS( t_1, a_obj, l_newtype );
2628 }
2629 else {
2630 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, l_newtype ) );
2631 }
2632
2633 }
2634
2635 /* elif IS_DATOBJ( obj ) then */
2636 else {
2637 t_3 = GF_IS__DATOBJ;
2638 if ( TNUM_OBJ( t_3 ) == T_FUNCTION ) {
2639 t_2 = CALL_1ARGS( t_3, a_obj );
2640 }
2641 else {
2642 t_2 = DoOperation2Args( CallFuncListOper, t_3, NewPlistFromArgs( a_obj ) );
2643 }
2644 CHECK_FUNC_RESULT( t_2 );
2645 CHECK_BOOL( t_2 );
2646 t_1 = (Obj)(UInt)(t_2 != False);
2647 if ( t_1 ) {
2648
2649 /* SET_TYPE_DATOBJ( obj, newtype ); */
2650 t_1 = GF_SET__TYPE__DATOBJ;
2651 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2652 CALL_2ARGS( t_1, a_obj, l_newtype );
2653 }
2654 else {
2655 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( a_obj, l_newtype ) );
2656 }
2657
2658 }
2659
2660 /* else */
2661 else {
2662
2663 /* Error( "cannot reset filter for internal object" ); */
2664 t_1 = GF_Error;
2665 t_2 = MakeString( "cannot reset filter for internal object" );
2666 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2667 CALL_1ARGS( t_1, t_2 );
2668 }
2669 else {
2670 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
2671 }
2672
2673 }
2674 }
2675 }
2676 /* fi */
2677
2678 /* return; */
2679 SWITCH_TO_OLD_FRAME(oldFrame);
2680 return 0;
2681
2682 /* return; */
2683 SWITCH_TO_OLD_FRAME(oldFrame);
2684 return 0;
2685 }
2686
2687 /* handler for function 20 */
HdlrFunc20(Obj self,Obj a_arg)2688 static Obj HdlrFunc20 (
2689 Obj self,
2690 Obj a_arg )
2691 {
2692 Obj l_obj = 0;
2693 Obj l_type = 0;
2694 Obj l_flags = 0;
2695 Obj l_attr = 0;
2696 Obj l_val = 0;
2697 Obj l_i = 0;
2698 Obj l_extra = 0;
2699 Obj l_nflags = 0;
2700 Obj t_1 = 0;
2701 Obj t_2 = 0;
2702 Obj t_3 = 0;
2703 Obj t_4 = 0;
2704 Obj t_5 = 0;
2705 Obj t_6 = 0;
2706 Obj t_7 = 0;
2707 Obj t_8 = 0;
2708 Obj t_9 = 0;
2709 Obj t_10 = 0;
2710 Obj t_11 = 0;
2711 (void)l_obj;
2712 (void)l_type;
2713 (void)l_flags;
2714 (void)l_attr;
2715 (void)l_val;
2716 (void)l_i;
2717 (void)l_extra;
2718 (void)l_nflags;
2719 Bag oldFrame;
2720
2721 /* allocate new stack frame */
2722 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
2723
2724 /* obj := arg[1]; */
2725 C_ELM_LIST_FPL( t_1, a_arg, INTOBJ_INT(1) )
2726 l_obj = t_1;
2727
2728 /* type := arg[2]; */
2729 C_ELM_LIST_FPL( t_1, a_arg, INTOBJ_INT(2) )
2730 l_type = t_1;
2731
2732 /* flags := FlagsType( type ); */
2733 t_2 = GF_FlagsType;
2734 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
2735 t_1 = CALL_1ARGS( t_2, l_type );
2736 }
2737 else {
2738 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( l_type ) );
2739 }
2740 CHECK_FUNC_RESULT( t_1 );
2741 l_flags = t_1;
2742
2743 /* extra := [ ]; */
2744 t_1 = NEW_PLIST( T_PLIST, 0 );
2745 SET_LEN_PLIST( t_1, 0 );
2746 l_extra = t_1;
2747
2748 /* if not IS_SUBSET_FLAGS( flags, IsAttributeStoringRepFlags ) then */
2749 t_4 = GF_IS__SUBSET__FLAGS;
2750 t_5 = GC_IsAttributeStoringRepFlags;
2751 CHECK_BOUND( t_5, "IsAttributeStoringRepFlags" );
2752 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
2753 t_3 = CALL_2ARGS( t_4, l_flags, t_5 );
2754 }
2755 else {
2756 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( l_flags, t_5 ) );
2757 }
2758 CHECK_FUNC_RESULT( t_3 );
2759 CHECK_BOOL( t_3 );
2760 t_2 = (Obj)(UInt)(t_3 != False);
2761 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
2762 if ( t_1 ) {
2763
2764 /* extra := arg{[ 3 .. LEN_LIST( arg ) ]}; */
2765 t_4 = GF_LEN__LIST;
2766 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
2767 t_3 = CALL_1ARGS( t_4, a_arg );
2768 }
2769 else {
2770 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( a_arg ) );
2771 }
2772 CHECK_FUNC_RESULT( t_3 );
2773 t_2 = Range2Check( INTOBJ_INT(3), t_3 );
2774 t_1 = ElmsListCheck( a_arg, t_2 );
2775 l_extra = t_1;
2776
2777 /* INFO_OWA( "#W ObjectifyWithAttributes called ", "for non-attribute storing rep\n" ); */
2778 t_1 = GF_INFO__OWA;
2779 t_2 = MakeString( "#W ObjectifyWithAttributes called " );
2780 t_3 = MakeString( "for non-attribute storing rep\n" );
2781 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2782 CALL_2ARGS( t_1, t_2, t_3 );
2783 }
2784 else {
2785 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
2786 }
2787
2788 /* Objectify( type, obj ); */
2789 t_1 = GF_Objectify;
2790 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
2791 CALL_2ARGS( t_1, l_type, l_obj );
2792 }
2793 else {
2794 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_type, l_obj ) );
2795 }
2796
2797 }
2798
2799 /* else */
2800 else {
2801
2802 /* nflags := EMPTY_FLAGS; */
2803 t_1 = GC_EMPTY__FLAGS;
2804 CHECK_BOUND( t_1, "EMPTY_FLAGS" );
2805 l_nflags = t_1;
2806
2807 /* for i in [ 3, 5 .. LEN_LIST( arg ) - 1 ] do */
2808 t_7 = GF_LEN__LIST;
2809 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
2810 t_6 = CALL_1ARGS( t_7, a_arg );
2811 }
2812 else {
2813 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( a_arg ) );
2814 }
2815 CHECK_FUNC_RESULT( t_6 );
2816 C_DIFF_FIA( t_5, t_6, INTOBJ_INT(1) )
2817 t_4 = Range3Check( INTOBJ_INT(3), INTOBJ_INT(5), t_5 );
2818 if ( IS_SMALL_LIST(t_4) ) {
2819 t_3 = (Obj)(UInt)1;
2820 t_1 = INTOBJ_INT(1);
2821 }
2822 else {
2823 t_3 = (Obj)(UInt)0;
2824 t_1 = CALL_1ARGS( GF_ITERATOR, t_4 );
2825 }
2826 while ( 1 ) {
2827 if ( t_3 ) {
2828 if ( LEN_LIST(t_4) < INT_INTOBJ(t_1) ) break;
2829 t_2 = ELMV0_LIST( t_4, INT_INTOBJ(t_1) );
2830 t_1 = (Obj)(((UInt)t_1)+4);
2831 if ( t_2 == 0 ) continue;
2832 }
2833 else {
2834 if ( CALL_1ARGS( GF_IS_DONE_ITER, t_1 ) != False ) break;
2835 t_2 = CALL_1ARGS( GF_NEXT_ITER, t_1 );
2836 }
2837 l_i = t_2;
2838
2839 /* attr := arg[i]; */
2840 CHECK_INT_POS( l_i );
2841 C_ELM_LIST_FPL( t_5, a_arg, l_i )
2842 l_attr = t_5;
2843
2844 /* val := arg[i + 1]; */
2845 C_SUM_FIA( t_6, l_i, INTOBJ_INT(1) )
2846 CHECK_INT_POS( t_6 );
2847 C_ELM_LIST_FPL( t_5, a_arg, t_6 )
2848 l_val = t_5;
2849
2850 /* if 0 <> FLAG1_FILTER( attr ) then */
2851 t_7 = GF_FLAG1__FILTER;
2852 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
2853 t_6 = CALL_1ARGS( t_7, l_attr );
2854 }
2855 else {
2856 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( l_attr ) );
2857 }
2858 CHECK_FUNC_RESULT( t_6 );
2859 t_5 = (Obj)(UInt)( ! EQ( INTOBJ_INT(0), t_6 ));
2860 if ( t_5 ) {
2861
2862 /* if val then */
2863 CHECK_BOOL( l_val );
2864 t_5 = (Obj)(UInt)(l_val != False);
2865 if ( t_5 ) {
2866
2867 /* nflags := AND_FLAGS( nflags, FLAGS_FILTER( attr ) ); */
2868 t_6 = GF_AND__FLAGS;
2869 t_8 = GF_FLAGS__FILTER;
2870 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
2871 t_7 = CALL_1ARGS( t_8, l_attr );
2872 }
2873 else {
2874 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( l_attr ) );
2875 }
2876 CHECK_FUNC_RESULT( t_7 );
2877 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
2878 t_5 = CALL_2ARGS( t_6, l_nflags, t_7 );
2879 }
2880 else {
2881 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( l_nflags, t_7 ) );
2882 }
2883 CHECK_FUNC_RESULT( t_5 );
2884 l_nflags = t_5;
2885
2886 }
2887
2888 /* else */
2889 else {
2890
2891 /* nflags := AND_FLAGS( nflags, FLAGS_FILTER( Tester( attr ) ) ); */
2892 t_6 = GF_AND__FLAGS;
2893 t_8 = GF_FLAGS__FILTER;
2894 t_10 = GF_Tester;
2895 if ( TNUM_OBJ( t_10 ) == T_FUNCTION ) {
2896 t_9 = CALL_1ARGS( t_10, l_attr );
2897 }
2898 else {
2899 t_9 = DoOperation2Args( CallFuncListOper, t_10, NewPlistFromArgs( l_attr ) );
2900 }
2901 CHECK_FUNC_RESULT( t_9 );
2902 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
2903 t_7 = CALL_1ARGS( t_8, t_9 );
2904 }
2905 else {
2906 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( t_9 ) );
2907 }
2908 CHECK_FUNC_RESULT( t_7 );
2909 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
2910 t_5 = CALL_2ARGS( t_6, l_nflags, t_7 );
2911 }
2912 else {
2913 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( l_nflags, t_7 ) );
2914 }
2915 CHECK_FUNC_RESULT( t_5 );
2916 l_nflags = t_5;
2917
2918 }
2919 /* fi */
2920
2921 }
2922
2923 /* elif LEN_LIST( METHODS_OPERATION( Setter( attr ), 2 ) ) <> LENGTH_SETTER_METHODS_2 then */
2924 else {
2925 t_7 = GF_LEN__LIST;
2926 t_9 = GF_METHODS__OPERATION;
2927 t_11 = GF_Setter;
2928 if ( TNUM_OBJ( t_11 ) == T_FUNCTION ) {
2929 t_10 = CALL_1ARGS( t_11, l_attr );
2930 }
2931 else {
2932 t_10 = DoOperation2Args( CallFuncListOper, t_11, NewPlistFromArgs( l_attr ) );
2933 }
2934 CHECK_FUNC_RESULT( t_10 );
2935 if ( TNUM_OBJ( t_9 ) == T_FUNCTION ) {
2936 t_8 = CALL_2ARGS( t_9, t_10, INTOBJ_INT(2) );
2937 }
2938 else {
2939 t_8 = DoOperation2Args( CallFuncListOper, t_9, NewPlistFromArgs( t_10, INTOBJ_INT(2) ) );
2940 }
2941 CHECK_FUNC_RESULT( t_8 );
2942 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
2943 t_6 = CALL_1ARGS( t_7, t_8 );
2944 }
2945 else {
2946 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( t_8 ) );
2947 }
2948 CHECK_FUNC_RESULT( t_6 );
2949 t_7 = GC_LENGTH__SETTER__METHODS__2;
2950 CHECK_BOUND( t_7, "LENGTH_SETTER_METHODS_2" );
2951 t_5 = (Obj)(UInt)( ! EQ( t_6, t_7 ));
2952 if ( t_5 ) {
2953
2954 /* ADD_LIST( extra, attr ); */
2955 t_5 = GF_ADD__LIST;
2956 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
2957 CALL_2ARGS( t_5, l_extra, l_attr );
2958 }
2959 else {
2960 DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( l_extra, l_attr ) );
2961 }
2962
2963 /* ADD_LIST( extra, val ); */
2964 t_5 = GF_ADD__LIST;
2965 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
2966 CALL_2ARGS( t_5, l_extra, l_val );
2967 }
2968 else {
2969 DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( l_extra, l_val ) );
2970 }
2971
2972 }
2973
2974 /* else */
2975 else {
2976
2977 /* obj.(NAME_FUNC( attr )) := IMMUTABLE_COPY_OBJ( val ); */
2978 t_6 = GF_NAME__FUNC;
2979 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
2980 t_5 = CALL_1ARGS( t_6, l_attr );
2981 }
2982 else {
2983 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( l_attr ) );
2984 }
2985 CHECK_FUNC_RESULT( t_5 );
2986 t_7 = GF_IMMUTABLE__COPY__OBJ;
2987 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
2988 t_6 = CALL_1ARGS( t_7, l_val );
2989 }
2990 else {
2991 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( l_val ) );
2992 }
2993 CHECK_FUNC_RESULT( t_6 );
2994 ASS_REC( l_obj, RNamObj(t_5), t_6 );
2995
2996 /* nflags := AND_FLAGS( nflags, FLAGS_FILTER( Tester( attr ) ) ); */
2997 t_6 = GF_AND__FLAGS;
2998 t_8 = GF_FLAGS__FILTER;
2999 t_10 = GF_Tester;
3000 if ( TNUM_OBJ( t_10 ) == T_FUNCTION ) {
3001 t_9 = CALL_1ARGS( t_10, l_attr );
3002 }
3003 else {
3004 t_9 = DoOperation2Args( CallFuncListOper, t_10, NewPlistFromArgs( l_attr ) );
3005 }
3006 CHECK_FUNC_RESULT( t_9 );
3007 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
3008 t_7 = CALL_1ARGS( t_8, t_9 );
3009 }
3010 else {
3011 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( t_9 ) );
3012 }
3013 CHECK_FUNC_RESULT( t_7 );
3014 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
3015 t_5 = CALL_2ARGS( t_6, l_nflags, t_7 );
3016 }
3017 else {
3018 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( l_nflags, t_7 ) );
3019 }
3020 CHECK_FUNC_RESULT( t_5 );
3021 l_nflags = t_5;
3022
3023 }
3024 }
3025 /* fi */
3026
3027 }
3028 /* od */
3029
3030 /* if not IS_SUBSET_FLAGS( flags, nflags ) then */
3031 t_4 = GF_IS__SUBSET__FLAGS;
3032 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
3033 t_3 = CALL_2ARGS( t_4, l_flags, l_nflags );
3034 }
3035 else {
3036 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( l_flags, l_nflags ) );
3037 }
3038 CHECK_FUNC_RESULT( t_3 );
3039 CHECK_BOOL( t_3 );
3040 t_2 = (Obj)(UInt)(t_3 != False);
3041 t_1 = (Obj)(UInt)( ! ((Int)t_2) );
3042 if ( t_1 ) {
3043
3044 /* flags := WITH_IMPS_FLAGS( AND_FLAGS( flags, nflags ) ); */
3045 t_2 = GF_WITH__IMPS__FLAGS;
3046 t_4 = GF_AND__FLAGS;
3047 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
3048 t_3 = CALL_2ARGS( t_4, l_flags, l_nflags );
3049 }
3050 else {
3051 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( l_flags, l_nflags ) );
3052 }
3053 CHECK_FUNC_RESULT( t_3 );
3054 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
3055 t_1 = CALL_1ARGS( t_2, t_3 );
3056 }
3057 else {
3058 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
3059 }
3060 CHECK_FUNC_RESULT( t_1 );
3061 l_flags = t_1;
3062
3063 /* type := NEW_TYPE( FamilyType( type ), flags, DataType( type ), fail ); */
3064 t_2 = GF_NEW__TYPE;
3065 t_4 = GF_FamilyType;
3066 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
3067 t_3 = CALL_1ARGS( t_4, l_type );
3068 }
3069 else {
3070 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( l_type ) );
3071 }
3072 CHECK_FUNC_RESULT( t_3 );
3073 t_5 = GF_DataType;
3074 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
3075 t_4 = CALL_1ARGS( t_5, l_type );
3076 }
3077 else {
3078 t_4 = DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( l_type ) );
3079 }
3080 CHECK_FUNC_RESULT( t_4 );
3081 t_5 = GC_fail;
3082 CHECK_BOUND( t_5, "fail" );
3083 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
3084 t_1 = CALL_4ARGS( t_2, t_3, l_flags, t_4, t_5 );
3085 }
3086 else {
3087 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3, l_flags, t_4, t_5 ) );
3088 }
3089 CHECK_FUNC_RESULT( t_1 );
3090 l_type = t_1;
3091
3092 }
3093 /* fi */
3094
3095 /* Objectify( type, obj ); */
3096 t_1 = GF_Objectify;
3097 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3098 CALL_2ARGS( t_1, l_type, l_obj );
3099 }
3100 else {
3101 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( l_type, l_obj ) );
3102 }
3103
3104 }
3105 /* fi */
3106
3107 /* for i in [ 1, 3 .. LEN_LIST( extra ) - 1 ] do */
3108 t_7 = GF_LEN__LIST;
3109 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
3110 t_6 = CALL_1ARGS( t_7, l_extra );
3111 }
3112 else {
3113 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( l_extra ) );
3114 }
3115 CHECK_FUNC_RESULT( t_6 );
3116 C_DIFF_FIA( t_5, t_6, INTOBJ_INT(1) )
3117 t_4 = Range3Check( INTOBJ_INT(1), INTOBJ_INT(3), t_5 );
3118 if ( IS_SMALL_LIST(t_4) ) {
3119 t_3 = (Obj)(UInt)1;
3120 t_1 = INTOBJ_INT(1);
3121 }
3122 else {
3123 t_3 = (Obj)(UInt)0;
3124 t_1 = CALL_1ARGS( GF_ITERATOR, t_4 );
3125 }
3126 while ( 1 ) {
3127 if ( t_3 ) {
3128 if ( LEN_LIST(t_4) < INT_INTOBJ(t_1) ) break;
3129 t_2 = ELMV0_LIST( t_4, INT_INTOBJ(t_1) );
3130 t_1 = (Obj)(((UInt)t_1)+4);
3131 if ( t_2 == 0 ) continue;
3132 }
3133 else {
3134 if ( CALL_1ARGS( GF_IS_DONE_ITER, t_1 ) != False ) break;
3135 t_2 = CALL_1ARGS( GF_NEXT_ITER, t_1 );
3136 }
3137 l_i = t_2;
3138
3139 /* if Tester( extra[i] )( obj ) then */
3140 t_8 = GF_Tester;
3141 CHECK_INT_POS( l_i );
3142 C_ELM_LIST_FPL( t_9, l_extra, l_i )
3143 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
3144 t_7 = CALL_1ARGS( t_8, t_9 );
3145 }
3146 else {
3147 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( t_9 ) );
3148 }
3149 CHECK_FUNC_RESULT( t_7 );
3150 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
3151 t_6 = CALL_1ARGS( t_7, l_obj );
3152 }
3153 else {
3154 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( l_obj ) );
3155 }
3156 CHECK_FUNC_RESULT( t_6 );
3157 CHECK_BOOL( t_6 );
3158 t_5 = (Obj)(UInt)(t_6 != False);
3159 if ( t_5 ) {
3160
3161 /* INFO_OWA( "#W Supplied type has tester of ", NAME_FUNC( extra[i] ), "with non-standard setter\n" ); */
3162 t_5 = GF_INFO__OWA;
3163 t_6 = MakeString( "#W Supplied type has tester of " );
3164 t_8 = GF_NAME__FUNC;
3165 C_ELM_LIST_FPL( t_9, l_extra, l_i )
3166 if ( TNUM_OBJ( t_8 ) == T_FUNCTION ) {
3167 t_7 = CALL_1ARGS( t_8, t_9 );
3168 }
3169 else {
3170 t_7 = DoOperation2Args( CallFuncListOper, t_8, NewPlistFromArgs( t_9 ) );
3171 }
3172 CHECK_FUNC_RESULT( t_7 );
3173 t_8 = MakeString( "with non-standard setter\n" );
3174 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
3175 CALL_3ARGS( t_5, t_6, t_7, t_8 );
3176 }
3177 else {
3178 DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( t_6, t_7, t_8 ) );
3179 }
3180
3181 /* ResetFilterObj( obj, Tester( extra[i] ) ); */
3182 t_5 = GF_ResetFilterObj;
3183 t_7 = GF_Tester;
3184 C_ELM_LIST_FPL( t_8, l_extra, l_i )
3185 if ( TNUM_OBJ( t_7 ) == T_FUNCTION ) {
3186 t_6 = CALL_1ARGS( t_7, t_8 );
3187 }
3188 else {
3189 t_6 = DoOperation2Args( CallFuncListOper, t_7, NewPlistFromArgs( t_8 ) );
3190 }
3191 CHECK_FUNC_RESULT( t_6 );
3192 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
3193 CALL_2ARGS( t_5, l_obj, t_6 );
3194 }
3195 else {
3196 DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( l_obj, t_6 ) );
3197 }
3198
3199 }
3200 /* fi */
3201
3202 /* Setter( extra[i] )( obj, extra[i + 1] ); */
3203 t_6 = GF_Setter;
3204 C_ELM_LIST_FPL( t_7, l_extra, l_i )
3205 if ( TNUM_OBJ( t_6 ) == T_FUNCTION ) {
3206 t_5 = CALL_1ARGS( t_6, t_7 );
3207 }
3208 else {
3209 t_5 = DoOperation2Args( CallFuncListOper, t_6, NewPlistFromArgs( t_7 ) );
3210 }
3211 CHECK_FUNC_RESULT( t_5 );
3212 C_SUM_FIA( t_7, l_i, INTOBJ_INT(1) )
3213 CHECK_INT_POS( t_7 );
3214 C_ELM_LIST_FPL( t_6, l_extra, t_7 )
3215 if ( TNUM_OBJ( t_5 ) == T_FUNCTION ) {
3216 CALL_2ARGS( t_5, l_obj, t_6 );
3217 }
3218 else {
3219 DoOperation2Args( CallFuncListOper, t_5, NewPlistFromArgs( l_obj, t_6 ) );
3220 }
3221
3222 }
3223 /* od */
3224
3225 /* return obj; */
3226 SWITCH_TO_OLD_FRAME(oldFrame);
3227 return l_obj;
3228
3229 /* return; */
3230 SWITCH_TO_OLD_FRAME(oldFrame);
3231 return 0;
3232 }
3233
3234 /* handler for function 1 */
HdlrFunc1(Obj self)3235 static Obj HdlrFunc1 (
3236 Obj self )
3237 {
3238 Obj t_1 = 0;
3239 Obj t_2 = 0;
3240 Obj t_3 = 0;
3241 Obj t_4 = 0;
3242 Obj t_5 = 0;
3243 Bag oldFrame;
3244
3245 /* allocate new stack frame */
3246 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
3247
3248 /* InstallAttributeFunction( function ( name, filter, getter, setter, tester, mutflag )
3249 InstallOtherMethod( getter, "system getter", true, [ IsAttributeStoringRep and tester ], GETTER_FLAGS, GETTER_FUNCTION( name ) );
3250 return;
3251 end ); */
3252 t_1 = GF_InstallAttributeFunction;
3253 t_2 = NewFunction( NameFunc[2], 6, ArgStringToList("name,filter,getter,setter,tester,mutflag"), HdlrFunc2 );
3254 SET_ENVI_FUNC( t_2, STATE(CurrLVars) );
3255 t_3 = NewFunctionBody();
3256 SET_STARTLINE_BODY(t_3, 20);
3257 SET_ENDLINE_BODY(t_3, 27);
3258 SET_FILENAME_BODY(t_3, FileName);
3259 SET_BODY_FUNC(t_2, t_3);
3260 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3261 CALL_1ARGS( t_1, t_2 );
3262 }
3263 else {
3264 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
3265 }
3266
3267 /* LENGTH_SETTER_METHODS_2 := LENGTH_SETTER_METHODS_2 + (6 + 2); */
3268 t_2 = GC_LENGTH__SETTER__METHODS__2;
3269 CHECK_BOUND( t_2, "LENGTH_SETTER_METHODS_2" );
3270 C_SUM_INTOBJS( t_3, INTOBJ_INT(6), INTOBJ_INT(2) )
3271 C_SUM_FIA( t_1, t_2, t_3 )
3272 AssGVar( G_LENGTH__SETTER__METHODS__2, t_1 );
3273
3274 /* InstallAttributeFunction( function ( name, filter, getter, setter, tester, mutflag )
3275 if mutflag then
3276 InstallOtherMethod( setter, "system mutable setter", true, [ IsAttributeStoringRep, IS_OBJECT ], 0, function ( obj, val )
3277 obj!.(name) := val;
3278 SetFilterObj( obj, tester );
3279 return;
3280 end );
3281 else
3282 InstallOtherMethod( setter, "system setter", true, [ IsAttributeStoringRep, IS_OBJECT ], 0, SETTER_FUNCTION( name, tester ) );
3283 fi;
3284 return;
3285 end ); */
3286 t_1 = GF_InstallAttributeFunction;
3287 t_2 = NewFunction( NameFunc[3], 6, ArgStringToList("name,filter,getter,setter,tester,mutflag"), HdlrFunc3 );
3288 SET_ENVI_FUNC( t_2, STATE(CurrLVars) );
3289 t_3 = NewFunctionBody();
3290 SET_STARTLINE_BODY(t_3, 32);
3291 SET_ENDLINE_BODY(t_3, 53);
3292 SET_FILENAME_BODY(t_3, FileName);
3293 SET_BODY_FUNC(t_2, t_3);
3294 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3295 CALL_1ARGS( t_1, t_2 );
3296 }
3297 else {
3298 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
3299 }
3300
3301 /* Subtype := "defined below"; */
3302 t_1 = MakeString( "defined below" );
3303 AssGVar( G_Subtype, t_1 );
3304
3305 /* DS_TYPE_CACHE := ShareSpecialObj( [ ] ); */
3306 t_2 = GF_ShareSpecialObj;
3307 t_3 = NEW_PLIST( T_PLIST, 0 );
3308 SET_LEN_PLIST( t_3, 0 );
3309 if ( TNUM_OBJ( t_2 ) == T_FUNCTION ) {
3310 t_1 = CALL_1ARGS( t_2, t_3 );
3311 }
3312 else {
3313 t_1 = DoOperation2Args( CallFuncListOper, t_2, NewPlistFromArgs( t_3 ) );
3314 }
3315 CHECK_FUNC_RESULT( t_1 );
3316 AssGVar( G_DS__TYPE__CACHE, t_1 );
3317
3318 /* BIND_GLOBAL( "NEW_FAMILY", function ( typeOfFamilies, name, req_filter, imp_filter )
3319 local lock, type, pair, family;
3320 imp_filter := WITH_IMPS_FLAGS( AND_FLAGS( imp_filter, req_filter ) );
3321 type := Subtype( typeOfFamilies, IsAttributeStoringRep );
3322 lock := READ_LOCK( CATEGORIES_FAMILY );
3323 for pair in CATEGORIES_FAMILY do
3324 if IS_SUBSET_FLAGS( imp_filter, pair[1] ) then
3325 type := Subtype( type, pair[2] );
3326 fi;
3327 od;
3328 UNLOCK( lock );
3329 family := AtomicRecord( );
3330 SET_TYPE_COMOBJ( family, type );
3331 family!.NAME := IMMUTABLE_COPY_OBJ( name );
3332 family!.REQ_FLAGS := req_filter;
3333 family!.IMP_FLAGS := imp_filter;
3334 family!.nTYPES := 0;
3335 family!.HASH_SIZE := 32;
3336 lock := WRITE_LOCK( DS_TYPE_CACHE );
3337 family!.TYPES := MIGRATE_RAW( [ ], DS_TYPE_CACHE );
3338 UNLOCK( lock );
3339 family!.TYPES_LIST_FAM := MakeWriteOnceAtomic( AtomicList( 27 ) );
3340 return family;
3341 end ); */
3342 t_1 = GF_BIND__GLOBAL;
3343 t_2 = MakeString( "NEW_FAMILY" );
3344 t_3 = NewFunction( NameFunc[5], 4, ArgStringToList("typeOfFamilies,name,req_filter,imp_filter"), HdlrFunc5 );
3345 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3346 t_4 = NewFunctionBody();
3347 SET_STARTLINE_BODY(t_4, 92);
3348 SET_ENDLINE_BODY(t_4, 143);
3349 SET_FILENAME_BODY(t_4, FileName);
3350 SET_BODY_FUNC(t_3, t_4);
3351 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3352 CALL_2ARGS( t_1, t_2, t_3 );
3353 }
3354 else {
3355 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3356 }
3357
3358 /* BIND_GLOBAL( "NewFamily", function ( arg... )
3359 local typeOfFamilies, name, req, imp, filter;
3360 if not LEN_LIST( arg ) in [ 1 .. 4 ] then
3361 Error( "usage: NewFamily( <name> [, <req> [, <imp> [, <famfilter> ] ] ] )" );
3362 fi;
3363 name := arg[1];
3364 if LEN_LIST( arg ) >= 2 then
3365 req := FLAGS_FILTER( arg[2] );
3366 else
3367 req := EMPTY_FLAGS;
3368 fi;
3369 if LEN_LIST( arg ) >= 3 then
3370 imp := FLAGS_FILTER( arg[3] );
3371 else
3372 imp := EMPTY_FLAGS;
3373 fi;
3374 if LEN_LIST( arg ) = 4 then
3375 typeOfFamilies := Subtype( TypeOfFamilies, arg[4] );
3376 else
3377 typeOfFamilies := TypeOfFamilies;
3378 fi;
3379 return NEW_FAMILY( typeOfFamilies, name, req, imp );
3380 end ); */
3381 t_1 = GF_BIND__GLOBAL;
3382 t_2 = MakeString( "NewFamily" );
3383 t_3 = NewFunction( NameFunc[6], -1, ArgStringToList("arg"), HdlrFunc6 );
3384 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3385 t_4 = NewFunctionBody();
3386 SET_STARTLINE_BODY(t_4, 146);
3387 SET_ENDLINE_BODY(t_4, 175);
3388 SET_FILENAME_BODY(t_4, FileName);
3389 SET_BODY_FUNC(t_3, t_4);
3390 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3391 CALL_2ARGS( t_1, t_2, t_3 );
3392 }
3393 else {
3394 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3395 }
3396
3397 /* NEW_TYPE_CACHE_MISS := 0; */
3398 AssGVar( G_NEW__TYPE__CACHE__MISS, INTOBJ_INT(0) );
3399
3400 /* NEW_TYPE_CACHE_HIT := 0; */
3401 AssGVar( G_NEW__TYPE__CACHE__HIT, INTOBJ_INT(0) );
3402
3403 /* BIND_GLOBAL( "NEW_TYPE", function ( family, flags, data, parent )
3404 local lock, hash, cache, cached, type, ncache, ncl, t, i, match;
3405 lock := WRITE_LOCK( DS_TYPE_CACHE );
3406 cache := family!.TYPES;
3407 hash := HASH_FLAGS( flags ) mod family!.HASH_SIZE + 1;
3408 if IsBound( cache[hash] ) then
3409 cached := cache[hash];
3410 if IS_EQUAL_FLAGS( flags, cached![2] ) then
3411 flags := cached![2];
3412 if IS_IDENTICAL_OBJ( data, cached![3] ) and IS_IDENTICAL_OBJ( TypeOfTypes, TYPE_OBJ( cached ) ) then
3413 if IS_IDENTICAL_OBJ( parent, fail ) then
3414 match := true;
3415 for i in [ 5 .. LEN_POSOBJ( cached ) ] do
3416 if IsBound( cached![i] ) then
3417 match := false;
3418 break;
3419 fi;
3420 od;
3421 if match then
3422 NEW_TYPE_CACHE_HIT := NEW_TYPE_CACHE_HIT + 1;
3423 UNLOCK( lock );
3424 return cached;
3425 fi;
3426 fi;
3427 if LEN_POSOBJ( parent ) = LEN_POSOBJ( cached ) then
3428 match := true;
3429 for i in [ 5 .. LEN_POSOBJ( parent ) ] do
3430 if IsBound( parent![i] ) <> IsBound( cached![i] ) then
3431 match := false;
3432 break;
3433 fi;
3434 if IsBound( parent![i] ) and IsBound( cached![i] ) and not IS_IDENTICAL_OBJ( parent![i], cached![i] ) then
3435 match := false;
3436 break;
3437 fi;
3438 od;
3439 if match then
3440 NEW_TYPE_CACHE_HIT := NEW_TYPE_CACHE_HIT + 1;
3441 UNLOCK( lock );
3442 return cached;
3443 fi;
3444 fi;
3445 fi;
3446 fi;
3447 NEW_TYPE_CACHE_MISS := NEW_TYPE_CACHE_MISS + 1;
3448 fi;
3449 NEW_TYPE_NEXT_ID := NEW_TYPE_NEXT_ID + 1;
3450 if NEW_TYPE_NEXT_ID >= NEW_TYPE_ID_LIMIT then
3451 GASMAN( "collect" );
3452 FLUSH_ALL_METHOD_CACHES( );
3453 NEW_TYPE_NEXT_ID := COMPACT_TYPE_IDS( );
3454 fi;
3455 type := [ family, flags ];
3456 data := MakeReadOnlyObj( data );
3457 type[3] := data;
3458 type[4] := NEW_TYPE_NEXT_ID;
3459 if not IS_IDENTICAL_OBJ( parent, fail ) then
3460 for i in [ 5 .. LEN_POSOBJ( parent ) ] do
3461 if IsBound( parent![i] ) and not IsBound( type[i] ) then
3462 type[i] := parent![i];
3463 fi;
3464 od;
3465 fi;
3466 SET_TYPE_POSOBJ( type, TypeOfTypes );
3467 if 3 * family!.nTYPES > family!.HASH_SIZE then
3468 ncache := [ ];
3469 MIGRATE_RAW( ncache, DS_TYPE_CACHE );
3470 ncl := 3 * family!.HASH_SIZE + 1;
3471 for t in cache do
3472 ncache[HASH_FLAGS( t![2] ) mod ncl + 1] := t;
3473 od;
3474 family!.HASH_SIZE := ncl;
3475 family!.TYPES := ncache;
3476 ncache[HASH_FLAGS( flags ) mod ncl + 1] := type;
3477 else
3478 cache[hash] := type;
3479 fi;
3480 family!.nTYPES := family!.nTYPES + 1;
3481 MakeReadOnlySingleObj( type );
3482 UNLOCK( lock );
3483 return type;
3484 end ); */
3485 t_1 = GF_BIND__GLOBAL;
3486 t_2 = MakeString( "NEW_TYPE" );
3487 t_3 = NewFunction( NameFunc[7], 4, ArgStringToList("family,flags,data,parent"), HdlrFunc7 );
3488 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3489 t_4 = NewFunctionBody();
3490 SET_STARTLINE_BODY(t_4, 203);
3491 SET_ENDLINE_BODY(t_4, 320);
3492 SET_FILENAME_BODY(t_4, FileName);
3493 SET_BODY_FUNC(t_3, t_4);
3494 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3495 CALL_2ARGS( t_1, t_2, t_3 );
3496 }
3497 else {
3498 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3499 }
3500
3501 /* BIND_GLOBAL( "NewType", function ( family, filter, data... )
3502 if not IsFamily( family ) then
3503 Error( "<family> must be a family" );
3504 fi;
3505 if LEN_LIST( data ) = 0 then
3506 data := fail;
3507 elif LEN_LIST( data ) = 1 then
3508 data := data[1];
3509 else
3510 Error( "usage: NewType( <family>, <filter> [, <data> ] )" );
3511 fi;
3512 return NEW_TYPE( family, WITH_IMPS_FLAGS( AND_FLAGS( family!.IMP_FLAGS, FLAGS_FILTER( filter ) ) ), data, fail );
3513 end ); */
3514 t_1 = GF_BIND__GLOBAL;
3515 t_2 = MakeString( "NewType" );
3516 t_3 = NewFunction( NameFunc[8], -3, ArgStringToList("family,filter,data"), HdlrFunc8 );
3517 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3518 t_4 = NewFunctionBody();
3519 SET_STARTLINE_BODY(t_4, 323);
3520 SET_ENDLINE_BODY(t_4, 350);
3521 SET_FILENAME_BODY(t_4, FileName);
3522 SET_BODY_FUNC(t_3, t_4);
3523 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3524 CALL_2ARGS( t_1, t_2, t_3 );
3525 }
3526 else {
3527 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3528 }
3529
3530 /* Unbind( Subtype ); */
3531 AssGVar( G_Subtype, 0 );
3532
3533 /* BIND_GLOBAL( "Subtype", function ( type, filter )
3534 if not IsType( type ) then
3535 Error( "<type> must be a type" );
3536 fi;
3537 return NEW_TYPE( type![1], WITH_IMPS_FLAGS( AND_FLAGS( type![2], FLAGS_FILTER( filter ) ) ), type![3], type );
3538 end ); */
3539 t_1 = GF_BIND__GLOBAL;
3540 t_2 = MakeString( "Subtype" );
3541 t_3 = NewFunction( NameFunc[9], 2, ArgStringToList("type,filter"), HdlrFunc9 );
3542 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3543 t_4 = NewFunctionBody();
3544 SET_STARTLINE_BODY(t_4, 364);
3545 SET_ENDLINE_BODY(t_4, 377);
3546 SET_FILENAME_BODY(t_4, FileName);
3547 SET_BODY_FUNC(t_3, t_4);
3548 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3549 CALL_2ARGS( t_1, t_2, t_3 );
3550 }
3551 else {
3552 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3553 }
3554
3555 /* BIND_GLOBAL( "SupType", function ( type, filter )
3556 if not IsType( type ) then
3557 Error( "<type> must be a type" );
3558 fi;
3559 return NEW_TYPE( type![1], SUB_FLAGS( type![2], FLAGS_FILTER( filter ) ), type![3], type );
3560 end ); */
3561 t_1 = GF_BIND__GLOBAL;
3562 t_2 = MakeString( "SupType" );
3563 t_3 = NewFunction( NameFunc[10], 2, ArgStringToList("type,filter"), HdlrFunc10 );
3564 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3565 t_4 = NewFunctionBody();
3566 SET_STARTLINE_BODY(t_4, 391);
3567 SET_ENDLINE_BODY(t_4, 404);
3568 SET_FILENAME_BODY(t_4, FileName);
3569 SET_BODY_FUNC(t_3, t_4);
3570 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3571 CALL_2ARGS( t_1, t_2, t_3 );
3572 }
3573 else {
3574 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3575 }
3576
3577 /* BIND_GLOBAL( "FamilyType", function ( K )
3578 return K![1];
3579 end ); */
3580 t_1 = GF_BIND__GLOBAL;
3581 t_2 = MakeString( "FamilyType" );
3582 t_3 = NewFunction( NameFunc[11], 1, ArgStringToList("K"), HdlrFunc11 );
3583 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3584 t_4 = NewFunctionBody();
3585 SET_STARTLINE_BODY(t_4, 418);
3586 SET_ENDLINE_BODY(t_4, 418);
3587 SET_FILENAME_BODY(t_4, FileName);
3588 SET_BODY_FUNC(t_3, t_4);
3589 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3590 CALL_2ARGS( t_1, t_2, t_3 );
3591 }
3592 else {
3593 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3594 }
3595
3596 /* BIND_GLOBAL( "FlagsType", function ( K )
3597 return K![2];
3598 end ); */
3599 t_1 = GF_BIND__GLOBAL;
3600 t_2 = MakeString( "FlagsType" );
3601 t_3 = NewFunction( NameFunc[12], 1, ArgStringToList("K"), HdlrFunc12 );
3602 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3603 t_4 = NewFunctionBody();
3604 SET_STARTLINE_BODY(t_4, 432);
3605 SET_ENDLINE_BODY(t_4, 432);
3606 SET_FILENAME_BODY(t_4, FileName);
3607 SET_BODY_FUNC(t_3, t_4);
3608 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3609 CALL_2ARGS( t_1, t_2, t_3 );
3610 }
3611 else {
3612 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3613 }
3614
3615 /* BIND_GLOBAL( "DataType", function ( K )
3616 return K![3];
3617 end ); */
3618 t_1 = GF_BIND__GLOBAL;
3619 t_2 = MakeString( "DataType" );
3620 t_3 = NewFunction( NameFunc[13], 1, ArgStringToList("K"), HdlrFunc13 );
3621 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3622 t_4 = NewFunctionBody();
3623 SET_STARTLINE_BODY(t_4, 448);
3624 SET_ENDLINE_BODY(t_4, 448);
3625 SET_FILENAME_BODY(t_4, FileName);
3626 SET_BODY_FUNC(t_3, t_4);
3627 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3628 CALL_2ARGS( t_1, t_2, t_3 );
3629 }
3630 else {
3631 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3632 }
3633
3634 /* BIND_GLOBAL( "SetDataType", function ( K, data )
3635 StrictBindOnce( K, 3, MakeImmutable( data ) );
3636 return;
3637 end ); */
3638 t_1 = GF_BIND__GLOBAL;
3639 t_2 = MakeString( "SetDataType" );
3640 t_3 = NewFunction( NameFunc[14], 2, ArgStringToList("K,data"), HdlrFunc14 );
3641 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3642 t_4 = NewFunctionBody();
3643 SET_STARTLINE_BODY(t_4, 450);
3644 SET_ENDLINE_BODY(t_4, 456);
3645 SET_FILENAME_BODY(t_4, FileName);
3646 SET_BODY_FUNC(t_3, t_4);
3647 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3648 CALL_2ARGS( t_1, t_2, t_3 );
3649 }
3650 else {
3651 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3652 }
3653
3654 /* BIND_GLOBAL( "TypeObj", TYPE_OBJ ); */
3655 t_1 = GF_BIND__GLOBAL;
3656 t_2 = MakeString( "TypeObj" );
3657 t_3 = GC_TYPE__OBJ;
3658 CHECK_BOUND( t_3, "TYPE_OBJ" );
3659 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3660 CALL_2ARGS( t_1, t_2, t_3 );
3661 }
3662 else {
3663 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3664 }
3665
3666 /* BIND_GLOBAL( "FamilyObj", FAMILY_OBJ ); */
3667 t_1 = GF_BIND__GLOBAL;
3668 t_2 = MakeString( "FamilyObj" );
3669 t_3 = GC_FAMILY__OBJ;
3670 CHECK_BOUND( t_3, "FAMILY_OBJ" );
3671 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3672 CALL_2ARGS( t_1, t_2, t_3 );
3673 }
3674 else {
3675 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3676 }
3677
3678 /* BIND_GLOBAL( "FlagsObj", function ( obj )
3679 return FlagsType( TypeObj( obj ) );
3680 end ); */
3681 t_1 = GF_BIND__GLOBAL;
3682 t_2 = MakeString( "FlagsObj" );
3683 t_3 = NewFunction( NameFunc[15], 1, ArgStringToList("obj"), HdlrFunc15 );
3684 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3685 t_4 = NewFunctionBody();
3686 SET_STARTLINE_BODY(t_4, 555);
3687 SET_ENDLINE_BODY(t_4, 555);
3688 SET_FILENAME_BODY(t_4, FileName);
3689 SET_BODY_FUNC(t_3, t_4);
3690 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3691 CALL_2ARGS( t_1, t_2, t_3 );
3692 }
3693 else {
3694 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3695 }
3696
3697 /* BIND_GLOBAL( "DataObj", function ( obj )
3698 return DataType( TypeObj( obj ) );
3699 end ); */
3700 t_1 = GF_BIND__GLOBAL;
3701 t_2 = MakeString( "DataObj" );
3702 t_3 = NewFunction( NameFunc[16], 1, ArgStringToList("obj"), HdlrFunc16 );
3703 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3704 t_4 = NewFunctionBody();
3705 SET_STARTLINE_BODY(t_4, 569);
3706 SET_ENDLINE_BODY(t_4, 569);
3707 SET_FILENAME_BODY(t_4, FileName);
3708 SET_BODY_FUNC(t_3, t_4);
3709 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3710 CALL_2ARGS( t_1, t_2, t_3 );
3711 }
3712 else {
3713 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3714 }
3715
3716 /* BIND_GLOBAL( "IsNonAtomicComponentObjectRepFlags", FLAGS_FILTER( IsNonAtomicComponentObjectRep ) ); */
3717 t_1 = GF_BIND__GLOBAL;
3718 t_2 = MakeString( "IsNonAtomicComponentObjectRepFlags" );
3719 t_4 = GF_FLAGS__FILTER;
3720 t_5 = GC_IsNonAtomicComponentObjectRep;
3721 CHECK_BOUND( t_5, "IsNonAtomicComponentObjectRep" );
3722 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
3723 t_3 = CALL_1ARGS( t_4, t_5 );
3724 }
3725 else {
3726 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( t_5 ) );
3727 }
3728 CHECK_FUNC_RESULT( t_3 );
3729 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3730 CALL_2ARGS( t_1, t_2, t_3 );
3731 }
3732 else {
3733 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3734 }
3735
3736 /* BIND_GLOBAL( "IsAtomicPositionalObjectRepFlags", FLAGS_FILTER( IsAtomicPositionalObjectRep ) ); */
3737 t_1 = GF_BIND__GLOBAL;
3738 t_2 = MakeString( "IsAtomicPositionalObjectRepFlags" );
3739 t_4 = GF_FLAGS__FILTER;
3740 t_5 = GC_IsAtomicPositionalObjectRep;
3741 CHECK_BOUND( t_5, "IsAtomicPositionalObjectRep" );
3742 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
3743 t_3 = CALL_1ARGS( t_4, t_5 );
3744 }
3745 else {
3746 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( t_5 ) );
3747 }
3748 CHECK_FUNC_RESULT( t_3 );
3749 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3750 CALL_2ARGS( t_1, t_2, t_3 );
3751 }
3752 else {
3753 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3754 }
3755
3756 /* BIND_GLOBAL( "IsReadOnlyPositionalObjectRepFlags", FLAGS_FILTER( IsReadOnlyPositionalObjectRep ) ); */
3757 t_1 = GF_BIND__GLOBAL;
3758 t_2 = MakeString( "IsReadOnlyPositionalObjectRepFlags" );
3759 t_4 = GF_FLAGS__FILTER;
3760 t_5 = GC_IsReadOnlyPositionalObjectRep;
3761 CHECK_BOUND( t_5, "IsReadOnlyPositionalObjectRep" );
3762 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
3763 t_3 = CALL_1ARGS( t_4, t_5 );
3764 }
3765 else {
3766 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( t_5 ) );
3767 }
3768 CHECK_FUNC_RESULT( t_3 );
3769 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3770 CALL_2ARGS( t_1, t_2, t_3 );
3771 }
3772 else {
3773 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3774 }
3775
3776 /* BIND_GLOBAL( "Objectify", function ( type, obj )
3777 local flags;
3778 if not IsType( type ) then
3779 Error( "<type> must be a type" );
3780 fi;
3781 flags := FlagsType( type );
3782 if IS_LIST( obj ) then
3783 if IS_SUBSET_FLAGS( flags, IsAtomicPositionalObjectRepFlags ) then
3784 FORCE_SWITCH_OBJ( obj, FixedAtomicList( obj ) );
3785 fi;
3786 elif IS_REC( obj ) then
3787 if IS_ATOMIC_RECORD( obj ) then
3788 if IS_SUBSET_FLAGS( flags, IsNonAtomicComponentObjectRepFlags ) then
3789 FORCE_SWITCH_OBJ( obj, FromAtomicRecord( obj ) );
3790 fi;
3791 elif not IS_SUBSET_FLAGS( flags, IsNonAtomicComponentObjectRepFlags ) then
3792 FORCE_SWITCH_OBJ( obj, AtomicRecord( obj ) );
3793 fi;
3794 fi;
3795 if IS_LIST( obj ) then
3796 SET_TYPE_POSOBJ( obj, type );
3797 elif IS_REC( obj ) then
3798 SET_TYPE_COMOBJ( obj, type );
3799 fi;
3800 if not IsNoImmediateMethodsObject( obj ) then
3801 RunImmediateMethods( obj, type![2] );
3802 fi;
3803 if IsReadOnlyPositionalObjectRep( obj ) then
3804 MakeReadOnlySingleObj( obj );
3805 fi;
3806 return obj;
3807 end ); */
3808 t_1 = GF_BIND__GLOBAL;
3809 t_2 = MakeString( "Objectify" );
3810 t_3 = NewFunction( NameFunc[17], 2, ArgStringToList("type,obj"), HdlrFunc17 );
3811 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3812 t_4 = NewFunctionBody();
3813 SET_STARTLINE_BODY(t_4, 590);
3814 SET_ENDLINE_BODY(t_4, 625);
3815 SET_FILENAME_BODY(t_4, FileName);
3816 SET_BODY_FUNC(t_3, t_4);
3817 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3818 CALL_2ARGS( t_1, t_2, t_3 );
3819 }
3820 else {
3821 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3822 }
3823
3824 /* Unbind( SetFilterObj ); */
3825 AssGVar( G_SetFilterObj, 0 );
3826
3827 /* BIND_GLOBAL( "SetFilterObj", function ( obj, filter )
3828 local type, newtype;
3829 type := TYPE_OBJ( obj );
3830 newtype := Subtype( type, filter );
3831 if IS_POSOBJ( obj ) then
3832 SET_TYPE_POSOBJ( obj, newtype );
3833 elif IS_COMOBJ( obj ) then
3834 SET_TYPE_COMOBJ( obj, newtype );
3835 elif IS_DATOBJ( obj ) then
3836 SET_TYPE_DATOBJ( obj, newtype );
3837 else
3838 ErrorNoReturn( "cannot set filter for internal object" );
3839 fi;
3840 if not (IGNORE_IMMEDIATE_METHODS or IsNoImmediateMethodsObject( obj )) then
3841 RunImmediateMethods( obj, SUB_FLAGS( newtype![2], type![2] ) );
3842 fi;
3843 return;
3844 end ); */
3845 t_1 = GF_BIND__GLOBAL;
3846 t_2 = MakeString( "SetFilterObj" );
3847 t_3 = NewFunction( NameFunc[18], 2, ArgStringToList("obj,filter"), HdlrFunc18 );
3848 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3849 t_4 = NewFunctionBody();
3850 SET_STARTLINE_BODY(t_4, 647);
3851 SET_ENDLINE_BODY(t_4, 667);
3852 SET_FILENAME_BODY(t_4, FileName);
3853 SET_BODY_FUNC(t_3, t_4);
3854 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3855 CALL_2ARGS( t_1, t_2, t_3 );
3856 }
3857 else {
3858 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3859 }
3860
3861 /* BIND_GLOBAL( "ResetFilterObj", function ( obj, filter )
3862 local type, newtype;
3863 if IS_AND_FILTER( filter ) then
3864 Error( "You can't reset an \"and-filter\". Reset components individually." );
3865 fi;
3866 type := TYPE_OBJ( obj );
3867 newtype := SupType( type, filter );
3868 if IS_POSOBJ( obj ) then
3869 SET_TYPE_POSOBJ( obj, newtype );
3870 elif IS_COMOBJ( obj ) then
3871 SET_TYPE_COMOBJ( obj, newtype );
3872 elif IS_DATOBJ( obj ) then
3873 SET_TYPE_DATOBJ( obj, newtype );
3874 else
3875 Error( "cannot reset filter for internal object" );
3876 fi;
3877 return;
3878 end ); */
3879 t_1 = GF_BIND__GLOBAL;
3880 t_2 = MakeString( "ResetFilterObj" );
3881 t_3 = NewFunction( NameFunc[19], 2, ArgStringToList("obj,filter"), HdlrFunc19 );
3882 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3883 t_4 = NewFunctionBody();
3884 SET_STARTLINE_BODY(t_4, 687);
3885 SET_ENDLINE_BODY(t_4, 705);
3886 SET_FILENAME_BODY(t_4, FileName);
3887 SET_BODY_FUNC(t_3, t_4);
3888 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3889 CALL_2ARGS( t_1, t_2, t_3 );
3890 }
3891 else {
3892 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3893 }
3894
3895 /* BIND_GLOBAL( "IsAttributeStoringRepFlags", FLAGS_FILTER( IsAttributeStoringRep ) ); */
3896 t_1 = GF_BIND__GLOBAL;
3897 t_2 = MakeString( "IsAttributeStoringRepFlags" );
3898 t_4 = GF_FLAGS__FILTER;
3899 t_5 = GC_IsAttributeStoringRep;
3900 CHECK_BOUND( t_5, "IsAttributeStoringRep" );
3901 if ( TNUM_OBJ( t_4 ) == T_FUNCTION ) {
3902 t_3 = CALL_1ARGS( t_4, t_5 );
3903 }
3904 else {
3905 t_3 = DoOperation2Args( CallFuncListOper, t_4, NewPlistFromArgs( t_5 ) );
3906 }
3907 CHECK_FUNC_RESULT( t_3 );
3908 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3909 CALL_2ARGS( t_1, t_2, t_3 );
3910 }
3911 else {
3912 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3913 }
3914
3915 /* BIND_GLOBAL( "INFO_OWA", Ignore ); */
3916 t_1 = GF_BIND__GLOBAL;
3917 t_2 = MakeString( "INFO_OWA" );
3918 t_3 = GC_Ignore;
3919 CHECK_BOUND( t_3, "Ignore" );
3920 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3921 CALL_2ARGS( t_1, t_2, t_3 );
3922 }
3923 else {
3924 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3925 }
3926
3927 /* MAKE_READ_WRITE_GLOBAL( "INFO_OWA" ); */
3928 t_1 = GF_MAKE__READ__WRITE__GLOBAL;
3929 t_2 = MakeString( "INFO_OWA" );
3930 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3931 CALL_1ARGS( t_1, t_2 );
3932 }
3933 else {
3934 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2 ) );
3935 }
3936
3937 /* BIND_GLOBAL( "ObjectifyWithAttributes", function ( arg... )
3938 local obj, type, flags, attr, val, i, extra, nflags;
3939 obj := arg[1];
3940 type := arg[2];
3941 flags := FlagsType( type );
3942 extra := [ ];
3943 if not IS_SUBSET_FLAGS( flags, IsAttributeStoringRepFlags ) then
3944 extra := arg{[ 3 .. LEN_LIST( arg ) ]};
3945 INFO_OWA( "#W ObjectifyWithAttributes called ", "for non-attribute storing rep\n" );
3946 Objectify( type, obj );
3947 else
3948 nflags := EMPTY_FLAGS;
3949 for i in [ 3, 5 .. LEN_LIST( arg ) - 1 ] do
3950 attr := arg[i];
3951 val := arg[i + 1];
3952 if 0 <> FLAG1_FILTER( attr ) then
3953 if val then
3954 nflags := AND_FLAGS( nflags, FLAGS_FILTER( attr ) );
3955 else
3956 nflags := AND_FLAGS( nflags, FLAGS_FILTER( Tester( attr ) ) );
3957 fi;
3958 elif LEN_LIST( METHODS_OPERATION( Setter( attr ), 2 ) ) <> LENGTH_SETTER_METHODS_2 then
3959 ADD_LIST( extra, attr );
3960 ADD_LIST( extra, val );
3961 else
3962 obj.(NAME_FUNC( attr )) := IMMUTABLE_COPY_OBJ( val );
3963 nflags := AND_FLAGS( nflags, FLAGS_FILTER( Tester( attr ) ) );
3964 fi;
3965 od;
3966 if not IS_SUBSET_FLAGS( flags, nflags ) then
3967 flags := WITH_IMPS_FLAGS( AND_FLAGS( flags, nflags ) );
3968 type := NEW_TYPE( FamilyType( type ), flags, DataType( type ), fail );
3969 fi;
3970 Objectify( type, obj );
3971 fi;
3972 for i in [ 1, 3 .. LEN_LIST( extra ) - 1 ] do
3973 if Tester( extra[i] )( obj ) then
3974 INFO_OWA( "#W Supplied type has tester of ", NAME_FUNC( extra[i] ), "with non-standard setter\n" );
3975 ResetFilterObj( obj, Tester( extra[i] ) );
3976 fi;
3977 Setter( extra[i] )( obj, extra[i + 1] );
3978 od;
3979 return obj;
3980 end ); */
3981 t_1 = GF_BIND__GLOBAL;
3982 t_2 = MakeString( "ObjectifyWithAttributes" );
3983 t_3 = NewFunction( NameFunc[20], -1, ArgStringToList("arg"), HdlrFunc20 );
3984 SET_ENVI_FUNC( t_3, STATE(CurrLVars) );
3985 t_4 = NewFunctionBody();
3986 SET_STARTLINE_BODY(t_4, 753);
3987 SET_ENDLINE_BODY(t_4, 815);
3988 SET_FILENAME_BODY(t_4, FileName);
3989 SET_BODY_FUNC(t_3, t_4);
3990 if ( TNUM_OBJ( t_1 ) == T_FUNCTION ) {
3991 CALL_2ARGS( t_1, t_2, t_3 );
3992 }
3993 else {
3994 DoOperation2Args( CallFuncListOper, t_1, NewPlistFromArgs( t_2, t_3 ) );
3995 }
3996
3997 /* return; */
3998 SWITCH_TO_OLD_FRAME(oldFrame);
3999 return 0;
4000
4001 /* return; */
4002 SWITCH_TO_OLD_FRAME(oldFrame);
4003 return 0;
4004 }
4005
4006 /* 'PostRestore' restore gvars, rnams, functions */
PostRestore(StructInitInfo * module)4007 static Int PostRestore ( StructInitInfo * module )
4008 {
4009
4010 /* global variables used in handlers */
4011 G_NAME__FUNC = GVarName( "NAME_FUNC" );
4012 G_SetFilterObj = GVarName( "SetFilterObj" );
4013 G_ResetFilterObj = GVarName( "ResetFilterObj" );
4014 G_IS__REC = GVarName( "IS_REC" );
4015 G_IS__LIST = GVarName( "IS_LIST" );
4016 G_ADD__LIST = GVarName( "ADD_LIST" );
4017 G_Error = GVarName( "Error" );
4018 G_TYPE__OBJ = GVarName( "TYPE_OBJ" );
4019 G_FAMILY__OBJ = GVarName( "FAMILY_OBJ" );
4020 G_IMMUTABLE__COPY__OBJ = GVarName( "IMMUTABLE_COPY_OBJ" );
4021 G_IS__IDENTICAL__OBJ = GVarName( "IS_IDENTICAL_OBJ" );
4022 G_IS__COMOBJ = GVarName( "IS_COMOBJ" );
4023 G_SET__TYPE__COMOBJ = GVarName( "SET_TYPE_COMOBJ" );
4024 G_IS__POSOBJ = GVarName( "IS_POSOBJ" );
4025 G_SET__TYPE__POSOBJ = GVarName( "SET_TYPE_POSOBJ" );
4026 G_LEN__POSOBJ = GVarName( "LEN_POSOBJ" );
4027 G_IS__DATOBJ = GVarName( "IS_DATOBJ" );
4028 G_SET__TYPE__DATOBJ = GVarName( "SET_TYPE_DATOBJ" );
4029 G_FORCE__SWITCH__OBJ = GVarName( "FORCE_SWITCH_OBJ" );
4030 G_MakeImmutable = GVarName( "MakeImmutable" );
4031 G_IS__OBJECT = GVarName( "IS_OBJECT" );
4032 G_AND__FLAGS = GVarName( "AND_FLAGS" );
4033 G_SUB__FLAGS = GVarName( "SUB_FLAGS" );
4034 G_HASH__FLAGS = GVarName( "HASH_FLAGS" );
4035 G_IS__EQUAL__FLAGS = GVarName( "IS_EQUAL_FLAGS" );
4036 G_WITH__IMPS__FLAGS = GVarName( "WITH_IMPS_FLAGS" );
4037 G_IS__SUBSET__FLAGS = GVarName( "IS_SUBSET_FLAGS" );
4038 G_FLAG1__FILTER = GVarName( "FLAG1_FILTER" );
4039 G_FLAGS__FILTER = GVarName( "FLAGS_FILTER" );
4040 G_METHODS__OPERATION = GVarName( "METHODS_OPERATION" );
4041 G_SETTER__FUNCTION = GVarName( "SETTER_FUNCTION" );
4042 G_GETTER__FUNCTION = GVarName( "GETTER_FUNCTION" );
4043 G_IS__AND__FILTER = GVarName( "IS_AND_FILTER" );
4044 G_COMPACT__TYPE__IDS = GVarName( "COMPACT_TYPE_IDS" );
4045 G_fail = GVarName( "fail" );
4046 G_LEN__LIST = GVarName( "LEN_LIST" );
4047 G_GASMAN = GVarName( "GASMAN" );
4048 G_WRITE__LOCK = GVarName( "WRITE_LOCK" );
4049 G_READ__LOCK = GVarName( "READ_LOCK" );
4050 G_UNLOCK = GVarName( "UNLOCK" );
4051 G_MIGRATE__RAW = GVarName( "MIGRATE_RAW" );
4052 G_MakeReadOnlyObj = GVarName( "MakeReadOnlyObj" );
4053 G_MakeReadOnlySingleObj = GVarName( "MakeReadOnlySingleObj" );
4054 G_AtomicList = GVarName( "AtomicList" );
4055 G_FixedAtomicList = GVarName( "FixedAtomicList" );
4056 G_AtomicRecord = GVarName( "AtomicRecord" );
4057 G_IS__ATOMIC__RECORD = GVarName( "IS_ATOMIC_RECORD" );
4058 G_FromAtomicRecord = GVarName( "FromAtomicRecord" );
4059 G_MakeWriteOnceAtomic = GVarName( "MakeWriteOnceAtomic" );
4060 G_StrictBindOnce = GVarName( "StrictBindOnce" );
4061 G_InstallAttributeFunction = GVarName( "InstallAttributeFunction" );
4062 G_InstallOtherMethod = GVarName( "InstallOtherMethod" );
4063 G_IsAttributeStoringRep = GVarName( "IsAttributeStoringRep" );
4064 G_GETTER__FLAGS = GVarName( "GETTER_FLAGS" );
4065 G_LENGTH__SETTER__METHODS__2 = GVarName( "LENGTH_SETTER_METHODS_2" );
4066 G_Subtype = GVarName( "Subtype" );
4067 G_DS__TYPE__CACHE = GVarName( "DS_TYPE_CACHE" );
4068 G_ShareSpecialObj = GVarName( "ShareSpecialObj" );
4069 G_BIND__GLOBAL = GVarName( "BIND_GLOBAL" );
4070 G_CATEGORIES__FAMILY = GVarName( "CATEGORIES_FAMILY" );
4071 G_EMPTY__FLAGS = GVarName( "EMPTY_FLAGS" );
4072 G_TypeOfFamilies = GVarName( "TypeOfFamilies" );
4073 G_NEW__FAMILY = GVarName( "NEW_FAMILY" );
4074 G_NEW__TYPE__CACHE__MISS = GVarName( "NEW_TYPE_CACHE_MISS" );
4075 G_NEW__TYPE__CACHE__HIT = GVarName( "NEW_TYPE_CACHE_HIT" );
4076 G_TypeOfTypes = GVarName( "TypeOfTypes" );
4077 G_NEW__TYPE__NEXT__ID = GVarName( "NEW_TYPE_NEXT_ID" );
4078 G_NEW__TYPE__ID__LIMIT = GVarName( "NEW_TYPE_ID_LIMIT" );
4079 G_FLUSH__ALL__METHOD__CACHES = GVarName( "FLUSH_ALL_METHOD_CACHES" );
4080 G_IsFamily = GVarName( "IsFamily" );
4081 G_NEW__TYPE = GVarName( "NEW_TYPE" );
4082 G_IsType = GVarName( "IsType" );
4083 G_FlagsType = GVarName( "FlagsType" );
4084 G_TypeObj = GVarName( "TypeObj" );
4085 G_DataType = GVarName( "DataType" );
4086 G_IsNonAtomicComponentObjectRep = GVarName( "IsNonAtomicComponentObjectRep" );
4087 G_IsAtomicPositionalObjectRep = GVarName( "IsAtomicPositionalObjectRep" );
4088 G_IsReadOnlyPositionalObjectRep = GVarName( "IsReadOnlyPositionalObjectRep" );
4089 G_IsAtomicPositionalObjectRepFlags = GVarName( "IsAtomicPositionalObjectRepFlags" );
4090 G_IsNonAtomicComponentObjectRepFlags = GVarName( "IsNonAtomicComponentObjectRepFlags" );
4091 G_IsNoImmediateMethodsObject = GVarName( "IsNoImmediateMethodsObject" );
4092 G_RunImmediateMethods = GVarName( "RunImmediateMethods" );
4093 G_ErrorNoReturn = GVarName( "ErrorNoReturn" );
4094 G_IGNORE__IMMEDIATE__METHODS = GVarName( "IGNORE_IMMEDIATE_METHODS" );
4095 G_SupType = GVarName( "SupType" );
4096 G_Ignore = GVarName( "Ignore" );
4097 G_MAKE__READ__WRITE__GLOBAL = GVarName( "MAKE_READ_WRITE_GLOBAL" );
4098 G_IsAttributeStoringRepFlags = GVarName( "IsAttributeStoringRepFlags" );
4099 G_INFO__OWA = GVarName( "INFO_OWA" );
4100 G_Objectify = GVarName( "Objectify" );
4101 G_Tester = GVarName( "Tester" );
4102 G_Setter = GVarName( "Setter" );
4103 G_FamilyType = GVarName( "FamilyType" );
4104
4105 /* record names used in handlers */
4106 R_TYPES__LIST__FAM = RNamName( "TYPES_LIST_FAM" );
4107 R_NAME = RNamName( "NAME" );
4108 R_REQ__FLAGS = RNamName( "REQ_FLAGS" );
4109 R_IMP__FLAGS = RNamName( "IMP_FLAGS" );
4110 R_nTYPES = RNamName( "nTYPES" );
4111 R_HASH__SIZE = RNamName( "HASH_SIZE" );
4112 R_TYPES = RNamName( "TYPES" );
4113
4114 /* information for the functions */
4115 NameFunc[1] = 0;
4116 NameFunc[2] = 0;
4117 NameFunc[3] = 0;
4118 NameFunc[4] = 0;
4119 NameFunc[5] = 0;
4120 NameFunc[6] = 0;
4121 NameFunc[7] = 0;
4122 NameFunc[8] = 0;
4123 NameFunc[9] = 0;
4124 NameFunc[10] = 0;
4125 NameFunc[11] = 0;
4126 NameFunc[12] = 0;
4127 NameFunc[13] = 0;
4128 NameFunc[14] = 0;
4129 NameFunc[15] = 0;
4130 NameFunc[16] = 0;
4131 NameFunc[17] = 0;
4132 NameFunc[18] = 0;
4133 NameFunc[19] = 0;
4134 NameFunc[20] = 0;
4135
4136 /* return success */
4137 return 0;
4138
4139 }
4140
4141
4142 /* 'InitKernel' sets up data structures, fopies, copies, handlers */
InitKernel(StructInitInfo * module)4143 static Int InitKernel ( StructInitInfo * module )
4144 {
4145
4146 /* global variables used in handlers */
4147 InitFopyGVar( "NAME_FUNC", &GF_NAME__FUNC );
4148 InitFopyGVar( "SetFilterObj", &GF_SetFilterObj );
4149 InitFopyGVar( "ResetFilterObj", &GF_ResetFilterObj );
4150 InitFopyGVar( "IS_REC", &GF_IS__REC );
4151 InitFopyGVar( "IS_LIST", &GF_IS__LIST );
4152 InitFopyGVar( "ADD_LIST", &GF_ADD__LIST );
4153 InitFopyGVar( "Error", &GF_Error );
4154 InitCopyGVar( "TYPE_OBJ", &GC_TYPE__OBJ );
4155 InitFopyGVar( "TYPE_OBJ", &GF_TYPE__OBJ );
4156 InitCopyGVar( "FAMILY_OBJ", &GC_FAMILY__OBJ );
4157 InitFopyGVar( "IMMUTABLE_COPY_OBJ", &GF_IMMUTABLE__COPY__OBJ );
4158 InitFopyGVar( "IS_IDENTICAL_OBJ", &GF_IS__IDENTICAL__OBJ );
4159 InitFopyGVar( "IS_COMOBJ", &GF_IS__COMOBJ );
4160 InitFopyGVar( "SET_TYPE_COMOBJ", &GF_SET__TYPE__COMOBJ );
4161 InitFopyGVar( "IS_POSOBJ", &GF_IS__POSOBJ );
4162 InitFopyGVar( "SET_TYPE_POSOBJ", &GF_SET__TYPE__POSOBJ );
4163 InitFopyGVar( "LEN_POSOBJ", &GF_LEN__POSOBJ );
4164 InitFopyGVar( "IS_DATOBJ", &GF_IS__DATOBJ );
4165 InitFopyGVar( "SET_TYPE_DATOBJ", &GF_SET__TYPE__DATOBJ );
4166 InitFopyGVar( "FORCE_SWITCH_OBJ", &GF_FORCE__SWITCH__OBJ );
4167 InitFopyGVar( "MakeImmutable", &GF_MakeImmutable );
4168 InitCopyGVar( "IS_OBJECT", &GC_IS__OBJECT );
4169 InitFopyGVar( "AND_FLAGS", &GF_AND__FLAGS );
4170 InitFopyGVar( "SUB_FLAGS", &GF_SUB__FLAGS );
4171 InitFopyGVar( "HASH_FLAGS", &GF_HASH__FLAGS );
4172 InitFopyGVar( "IS_EQUAL_FLAGS", &GF_IS__EQUAL__FLAGS );
4173 InitFopyGVar( "WITH_IMPS_FLAGS", &GF_WITH__IMPS__FLAGS );
4174 InitFopyGVar( "IS_SUBSET_FLAGS", &GF_IS__SUBSET__FLAGS );
4175 InitFopyGVar( "FLAG1_FILTER", &GF_FLAG1__FILTER );
4176 InitFopyGVar( "FLAGS_FILTER", &GF_FLAGS__FILTER );
4177 InitFopyGVar( "METHODS_OPERATION", &GF_METHODS__OPERATION );
4178 InitFopyGVar( "SETTER_FUNCTION", &GF_SETTER__FUNCTION );
4179 InitFopyGVar( "GETTER_FUNCTION", &GF_GETTER__FUNCTION );
4180 InitFopyGVar( "IS_AND_FILTER", &GF_IS__AND__FILTER );
4181 InitFopyGVar( "COMPACT_TYPE_IDS", &GF_COMPACT__TYPE__IDS );
4182 InitCopyGVar( "fail", &GC_fail );
4183 InitFopyGVar( "LEN_LIST", &GF_LEN__LIST );
4184 InitFopyGVar( "GASMAN", &GF_GASMAN );
4185 InitFopyGVar( "WRITE_LOCK", &GF_WRITE__LOCK );
4186 InitFopyGVar( "READ_LOCK", &GF_READ__LOCK );
4187 InitFopyGVar( "UNLOCK", &GF_UNLOCK );
4188 InitFopyGVar( "MIGRATE_RAW", &GF_MIGRATE__RAW );
4189 InitFopyGVar( "MakeReadOnlyObj", &GF_MakeReadOnlyObj );
4190 InitFopyGVar( "MakeReadOnlySingleObj", &GF_MakeReadOnlySingleObj );
4191 InitFopyGVar( "AtomicList", &GF_AtomicList );
4192 InitFopyGVar( "FixedAtomicList", &GF_FixedAtomicList );
4193 InitFopyGVar( "AtomicRecord", &GF_AtomicRecord );
4194 InitFopyGVar( "IS_ATOMIC_RECORD", &GF_IS__ATOMIC__RECORD );
4195 InitFopyGVar( "FromAtomicRecord", &GF_FromAtomicRecord );
4196 InitFopyGVar( "MakeWriteOnceAtomic", &GF_MakeWriteOnceAtomic );
4197 InitFopyGVar( "StrictBindOnce", &GF_StrictBindOnce );
4198 InitFopyGVar( "InstallAttributeFunction", &GF_InstallAttributeFunction );
4199 InitFopyGVar( "InstallOtherMethod", &GF_InstallOtherMethod );
4200 InitCopyGVar( "IsAttributeStoringRep", &GC_IsAttributeStoringRep );
4201 InitCopyGVar( "GETTER_FLAGS", &GC_GETTER__FLAGS );
4202 InitCopyGVar( "LENGTH_SETTER_METHODS_2", &GC_LENGTH__SETTER__METHODS__2 );
4203 InitFopyGVar( "Subtype", &GF_Subtype );
4204 InitCopyGVar( "DS_TYPE_CACHE", &GC_DS__TYPE__CACHE );
4205 InitFopyGVar( "ShareSpecialObj", &GF_ShareSpecialObj );
4206 InitFopyGVar( "BIND_GLOBAL", &GF_BIND__GLOBAL );
4207 InitCopyGVar( "CATEGORIES_FAMILY", &GC_CATEGORIES__FAMILY );
4208 InitCopyGVar( "EMPTY_FLAGS", &GC_EMPTY__FLAGS );
4209 InitCopyGVar( "TypeOfFamilies", &GC_TypeOfFamilies );
4210 InitFopyGVar( "NEW_FAMILY", &GF_NEW__FAMILY );
4211 InitCopyGVar( "NEW_TYPE_CACHE_MISS", &GC_NEW__TYPE__CACHE__MISS );
4212 InitCopyGVar( "NEW_TYPE_CACHE_HIT", &GC_NEW__TYPE__CACHE__HIT );
4213 InitCopyGVar( "TypeOfTypes", &GC_TypeOfTypes );
4214 InitCopyGVar( "NEW_TYPE_NEXT_ID", &GC_NEW__TYPE__NEXT__ID );
4215 InitCopyGVar( "NEW_TYPE_ID_LIMIT", &GC_NEW__TYPE__ID__LIMIT );
4216 InitFopyGVar( "FLUSH_ALL_METHOD_CACHES", &GF_FLUSH__ALL__METHOD__CACHES );
4217 InitFopyGVar( "IsFamily", &GF_IsFamily );
4218 InitFopyGVar( "NEW_TYPE", &GF_NEW__TYPE );
4219 InitFopyGVar( "IsType", &GF_IsType );
4220 InitFopyGVar( "FlagsType", &GF_FlagsType );
4221 InitFopyGVar( "TypeObj", &GF_TypeObj );
4222 InitFopyGVar( "DataType", &GF_DataType );
4223 InitCopyGVar( "IsNonAtomicComponentObjectRep", &GC_IsNonAtomicComponentObjectRep );
4224 InitCopyGVar( "IsAtomicPositionalObjectRep", &GC_IsAtomicPositionalObjectRep );
4225 InitCopyGVar( "IsReadOnlyPositionalObjectRep", &GC_IsReadOnlyPositionalObjectRep );
4226 InitFopyGVar( "IsReadOnlyPositionalObjectRep", &GF_IsReadOnlyPositionalObjectRep );
4227 InitCopyGVar( "IsAtomicPositionalObjectRepFlags", &GC_IsAtomicPositionalObjectRepFlags );
4228 InitCopyGVar( "IsNonAtomicComponentObjectRepFlags", &GC_IsNonAtomicComponentObjectRepFlags );
4229 InitFopyGVar( "IsNoImmediateMethodsObject", &GF_IsNoImmediateMethodsObject );
4230 InitFopyGVar( "RunImmediateMethods", &GF_RunImmediateMethods );
4231 InitFopyGVar( "ErrorNoReturn", &GF_ErrorNoReturn );
4232 InitCopyGVar( "IGNORE_IMMEDIATE_METHODS", &GC_IGNORE__IMMEDIATE__METHODS );
4233 InitFopyGVar( "SupType", &GF_SupType );
4234 InitCopyGVar( "Ignore", &GC_Ignore );
4235 InitFopyGVar( "MAKE_READ_WRITE_GLOBAL", &GF_MAKE__READ__WRITE__GLOBAL );
4236 InitCopyGVar( "IsAttributeStoringRepFlags", &GC_IsAttributeStoringRepFlags );
4237 InitFopyGVar( "INFO_OWA", &GF_INFO__OWA );
4238 InitFopyGVar( "Objectify", &GF_Objectify );
4239 InitFopyGVar( "Tester", &GF_Tester );
4240 InitFopyGVar( "Setter", &GF_Setter );
4241 InitFopyGVar( "FamilyType", &GF_FamilyType );
4242
4243 /* information for the functions */
4244 InitGlobalBag( &FileName, "GAPROOT/lib/type1.g:FileName("FILE_CRC")" );
4245 InitHandlerFunc( HdlrFunc1, "GAPROOT/lib/type1.g:HdlrFunc1("FILE_CRC")" );
4246 InitGlobalBag( &(NameFunc[1]), "GAPROOT/lib/type1.g:NameFunc[1]("FILE_CRC")" );
4247 InitHandlerFunc( HdlrFunc2, "GAPROOT/lib/type1.g:HdlrFunc2("FILE_CRC")" );
4248 InitGlobalBag( &(NameFunc[2]), "GAPROOT/lib/type1.g:NameFunc[2]("FILE_CRC")" );
4249 InitHandlerFunc( HdlrFunc3, "GAPROOT/lib/type1.g:HdlrFunc3("FILE_CRC")" );
4250 InitGlobalBag( &(NameFunc[3]), "GAPROOT/lib/type1.g:NameFunc[3]("FILE_CRC")" );
4251 InitHandlerFunc( HdlrFunc4, "GAPROOT/lib/type1.g:HdlrFunc4("FILE_CRC")" );
4252 InitGlobalBag( &(NameFunc[4]), "GAPROOT/lib/type1.g:NameFunc[4]("FILE_CRC")" );
4253 InitHandlerFunc( HdlrFunc5, "GAPROOT/lib/type1.g:HdlrFunc5("FILE_CRC")" );
4254 InitGlobalBag( &(NameFunc[5]), "GAPROOT/lib/type1.g:NameFunc[5]("FILE_CRC")" );
4255 InitHandlerFunc( HdlrFunc6, "GAPROOT/lib/type1.g:HdlrFunc6("FILE_CRC")" );
4256 InitGlobalBag( &(NameFunc[6]), "GAPROOT/lib/type1.g:NameFunc[6]("FILE_CRC")" );
4257 InitHandlerFunc( HdlrFunc7, "GAPROOT/lib/type1.g:HdlrFunc7("FILE_CRC")" );
4258 InitGlobalBag( &(NameFunc[7]), "GAPROOT/lib/type1.g:NameFunc[7]("FILE_CRC")" );
4259 InitHandlerFunc( HdlrFunc8, "GAPROOT/lib/type1.g:HdlrFunc8("FILE_CRC")" );
4260 InitGlobalBag( &(NameFunc[8]), "GAPROOT/lib/type1.g:NameFunc[8]("FILE_CRC")" );
4261 InitHandlerFunc( HdlrFunc9, "GAPROOT/lib/type1.g:HdlrFunc9("FILE_CRC")" );
4262 InitGlobalBag( &(NameFunc[9]), "GAPROOT/lib/type1.g:NameFunc[9]("FILE_CRC")" );
4263 InitHandlerFunc( HdlrFunc10, "GAPROOT/lib/type1.g:HdlrFunc10("FILE_CRC")" );
4264 InitGlobalBag( &(NameFunc[10]), "GAPROOT/lib/type1.g:NameFunc[10]("FILE_CRC")" );
4265 InitHandlerFunc( HdlrFunc11, "GAPROOT/lib/type1.g:HdlrFunc11("FILE_CRC")" );
4266 InitGlobalBag( &(NameFunc[11]), "GAPROOT/lib/type1.g:NameFunc[11]("FILE_CRC")" );
4267 InitHandlerFunc( HdlrFunc12, "GAPROOT/lib/type1.g:HdlrFunc12("FILE_CRC")" );
4268 InitGlobalBag( &(NameFunc[12]), "GAPROOT/lib/type1.g:NameFunc[12]("FILE_CRC")" );
4269 InitHandlerFunc( HdlrFunc13, "GAPROOT/lib/type1.g:HdlrFunc13("FILE_CRC")" );
4270 InitGlobalBag( &(NameFunc[13]), "GAPROOT/lib/type1.g:NameFunc[13]("FILE_CRC")" );
4271 InitHandlerFunc( HdlrFunc14, "GAPROOT/lib/type1.g:HdlrFunc14("FILE_CRC")" );
4272 InitGlobalBag( &(NameFunc[14]), "GAPROOT/lib/type1.g:NameFunc[14]("FILE_CRC")" );
4273 InitHandlerFunc( HdlrFunc15, "GAPROOT/lib/type1.g:HdlrFunc15("FILE_CRC")" );
4274 InitGlobalBag( &(NameFunc[15]), "GAPROOT/lib/type1.g:NameFunc[15]("FILE_CRC")" );
4275 InitHandlerFunc( HdlrFunc16, "GAPROOT/lib/type1.g:HdlrFunc16("FILE_CRC")" );
4276 InitGlobalBag( &(NameFunc[16]), "GAPROOT/lib/type1.g:NameFunc[16]("FILE_CRC")" );
4277 InitHandlerFunc( HdlrFunc17, "GAPROOT/lib/type1.g:HdlrFunc17("FILE_CRC")" );
4278 InitGlobalBag( &(NameFunc[17]), "GAPROOT/lib/type1.g:NameFunc[17]("FILE_CRC")" );
4279 InitHandlerFunc( HdlrFunc18, "GAPROOT/lib/type1.g:HdlrFunc18("FILE_CRC")" );
4280 InitGlobalBag( &(NameFunc[18]), "GAPROOT/lib/type1.g:NameFunc[18]("FILE_CRC")" );
4281 InitHandlerFunc( HdlrFunc19, "GAPROOT/lib/type1.g:HdlrFunc19("FILE_CRC")" );
4282 InitGlobalBag( &(NameFunc[19]), "GAPROOT/lib/type1.g:NameFunc[19]("FILE_CRC")" );
4283 InitHandlerFunc( HdlrFunc20, "GAPROOT/lib/type1.g:HdlrFunc20("FILE_CRC")" );
4284 InitGlobalBag( &(NameFunc[20]), "GAPROOT/lib/type1.g:NameFunc[20]("FILE_CRC")" );
4285
4286 /* return success */
4287 return 0;
4288
4289 }
4290
4291 /* 'InitLibrary' sets up gvars, rnams, functions */
InitLibrary(StructInitInfo * module)4292 static Int InitLibrary ( StructInitInfo * module )
4293 {
4294 Obj func1;
4295 Obj body1;
4296
4297 /* Complete Copy/Fopy registration */
4298 UpdateCopyFopyInfo();
4299 FileName = MakeImmString( "GAPROOT/lib/type1.g" );
4300 PostRestore(module);
4301
4302 /* create all the functions defined in this module */
4303 func1 = NewFunction(NameFunc[1],0,0,HdlrFunc1);
4304 SET_ENVI_FUNC( func1, STATE(CurrLVars) );
4305 body1 = NewFunctionBody();
4306 SET_BODY_FUNC( func1, body1 );
4307 CHANGED_BAG( func1 );
4308 CALL_0ARGS( func1 );
4309
4310 /* return success */
4311 return 0;
4312
4313 }
4314
4315 /* <name> returns the description of this module */
4316 static StructInitInfo module = {
4317 .type = MODULE_STATIC,
4318 .name = "GAPROOT/lib/type1.g",
4319 .crc = -88497608,
4320 .initKernel = InitKernel,
4321 .initLibrary = InitLibrary,
4322 .postRestore = PostRestore,
4323 };
4324
Init__type1(void)4325 StructInitInfo * Init__type1 ( void )
4326 {
4327 return &module;
4328 }
4329
4330 /* compiled code ends here */
4331 #endif
4332