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