CoCalc -- c_filt1.c

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place.

GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it
Project: cocalc-sagemath-dev-slelievre
Views: ⁴¹⁸³⁴⁶
1
#ifndef AVOID_PRECOMPILED
2
/* C file produced by GAC */
3
#include "src/compiled.h"
4

5
/* global variables used in handlers */
6
static GVar G_IS__FUNCTION;
7
static Obj  GF_IS__FUNCTION;
8
static GVar G_ADD__LIST;
9
static Obj  GF_ADD__LIST;
10
static GVar G_Error;
11
static Obj  GF_Error;
12
static GVar G_IS__IDENTICAL__OBJ;
13
static Obj  GF_IS__IDENTICAL__OBJ;
14
static GVar G_AND__FLAGS;
15
static Obj  GF_AND__FLAGS;
16
static GVar G_HASH__FLAGS;
17
static Obj  GF_HASH__FLAGS;
18
static GVar G_WITH__HIDDEN__IMPS__FLAGS;
19
static Obj  GF_WITH__HIDDEN__IMPS__FLAGS;
20
static GVar G_IS__SUBSET__FLAGS;
21
static Obj  GF_IS__SUBSET__FLAGS;
22
static GVar G_TRUES__FLAGS;
23
static Obj  GF_TRUES__FLAGS;
24
static GVar G_FLAGS__FILTER;
25
static Obj  GF_FLAGS__FILTER;
26
static GVar G_WITH__HIDDEN__IMPS__FLAGS__COUNT;
27
static GVar G_WITH__HIDDEN__IMPS__FLAGS__CACHE__MISS;
28
static GVar G_WITH__HIDDEN__IMPS__FLAGS__CACHE__HIT;
29
static GVar G_IMPLICATIONS;
30
static Obj  GC_IMPLICATIONS;
31
static GVar G_WITH__IMPS__FLAGS__CACHE;
32
static Obj  GC_WITH__IMPS__FLAGS__CACHE;
33
static GVar G_WITH__IMPS__FLAGS__COUNT;
34
static Obj  GC_WITH__IMPS__FLAGS__COUNT;
35
static GVar G_WITH__IMPS__FLAGS__CACHE__HIT;
36
static Obj  GC_WITH__IMPS__FLAGS__CACHE__HIT;
37
static GVar G_WITH__IMPS__FLAGS__CACHE__MISS;
38
static Obj  GC_WITH__IMPS__FLAGS__CACHE__MISS;
39
static GVar G_CLEAR__IMP__CACHE;
40
static GVar G_BIND__GLOBAL;
41
static Obj  GF_BIND__GLOBAL;
42
static GVar G_UNBIND__GLOBAL;
43
static Obj  GF_UNBIND__GLOBAL;
44
static GVar G_RANK__FILTERS;
45
static Obj  GC_RANK__FILTERS;
46
static GVar G_RankFilter;
47
static GVar G_RANK__FILTER;
48
static Obj  GC_RANK__FILTER;
49
static Obj  GF_RANK__FILTER;
50
static GVar G_RANK__FILTER__LIST__CURRENT;
51
static Obj  GC_RANK__FILTER__LIST__CURRENT;
52
static GVar G_RANK__FILTER__LIST;
53
static Obj  GC_RANK__FILTER__LIST;
54
static GVar G_RANK__FILTER__COUNT;
55
static Obj  GC_RANK__FILTER__COUNT;
56

57
/* record names used in handlers */
58

59
/* information for the functions */
60
static Obj  NameFunc[7];
61
static Obj  NamsFunc[7];
62
static Int  NargFunc[7];
63
static Obj  DefaultName;
64
static Obj FileName;
65

66
/* handler for function 2 */
67
static Obj  HdlrFunc2 (
68
 Obj  self )
69
{
70
 Obj t_1 = 0;
71
 Bag oldFrame;
72
 OLD_BRK_CURR_STAT
73
 
74
 /* allocate new stack frame */
75
 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
76
 REM_BRK_CURR_STAT();
77
 SET_BRK_CURR_STAT(0);
78
 
79
 /* WITH_IMPS_FLAGS_CACHE := [  ]; */
80
 t_1 = NEW_PLIST( T_PLIST, 0 );
81
 SET_LEN_PLIST( t_1, 0 );
82
 AssGVar( G_WITH__IMPS__FLAGS__CACHE, t_1 );
83
 
84
 /* return; */
85
 RES_BRK_CURR_STAT();
86
 SWITCH_TO_OLD_FRAME(oldFrame);
87
 return 0;
88
 
89
 /* return; */
90
 RES_BRK_CURR_STAT();
91
 SWITCH_TO_OLD_FRAME(oldFrame);
92
 return 0;
93
}
94

95
/* handler for function 3 */
96
static Obj  HdlrFunc3 (
97
 Obj  self,
98
 Obj  a_flags )
99
{
100
 Obj l_with = 0;
101
 Obj l_changed = 0;
102
 Obj l_imp = 0;
103
 Obj l_hash = 0;
104
 Obj l_hash2 = 0;
105
 Obj l_i = 0;
106
 Obj t_1 = 0;
107
 Obj t_2 = 0;
108
 Obj t_3 = 0;
109
 Obj t_4 = 0;
110
 Obj t_5 = 0;
111
 Obj t_6 = 0;
112
 Obj t_7 = 0;
113
 Obj t_8 = 0;
114
 Obj t_9 = 0;
115
 Obj t_10 = 0;
116
 Obj t_11 = 0;
117
 Bag oldFrame;
118
 OLD_BRK_CURR_STAT
119
 
120
 /* allocate new stack frame */
121
 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
122
 REM_BRK_CURR_STAT();
123
 SET_BRK_CURR_STAT(0);
124
 
125
 /* hash := HASH_FLAGS( flags ) mod 11001; */
126
 t_3 = GF_HASH__FLAGS;
127
 t_2 = CALL_1ARGS( t_3, a_flags );
128
 CHECK_FUNC_RESULT( t_2 )
129
 t_1 = MOD( t_2, INTOBJ_INT(11001) );
130
 l_hash = t_1;
131
 
132
 /* for i in [ 0 .. 3 ] do */
133
 for ( t_1 = INTOBJ_INT(0);
134
       ((Int)t_1) <= ((Int)INTOBJ_INT(3));
135
       t_1 = (Obj)(((UInt)t_1)+4) ) {
136
  l_i = t_1;
137
  
138
  /* hash2 := 2 * ((hash + 31 * i) mod 11001) + 1; */
139
  C_PROD_INTOBJS( t_6, INTOBJ_INT(31), l_i )
140
  C_SUM_FIA( t_5, l_hash, t_6 )
141
  t_4 = MOD( t_5, INTOBJ_INT(11001) );
142
  C_PROD_FIA( t_3, INTOBJ_INT(2), t_4 )
143
  C_SUM_FIA( t_2, t_3, INTOBJ_INT(1) )
144
  l_hash2 = t_2;
145
  
146
  /* if IsBound( WITH_IMPS_FLAGS_CACHE[hash2] ) then */
147
  t_4 = GC_WITH__IMPS__FLAGS__CACHE;
148
  CHECK_BOUND( t_4, "WITH_IMPS_FLAGS_CACHE" )
149
  CHECK_INT_POS( l_hash2 )
150
  t_3 = C_ISB_LIST( t_4, l_hash2 );
151
  t_2 = (Obj)(UInt)(t_3 != False);
152
  if ( t_2 ) {
153
   
154
   /* if IS_IDENTICAL_OBJ( WITH_IMPS_FLAGS_CACHE[hash2], flags ) then */
155
   t_4 = GF_IS__IDENTICAL__OBJ;
156
   t_6 = GC_WITH__IMPS__FLAGS__CACHE;
157
   CHECK_BOUND( t_6, "WITH_IMPS_FLAGS_CACHE" )
158
   C_ELM_LIST_FPL( t_5, t_6, l_hash2 )
159
   t_3 = CALL_2ARGS( t_4, t_5, a_flags );
160
   CHECK_FUNC_RESULT( t_3 )
161
   CHECK_BOOL( t_3 )
162
   t_2 = (Obj)(UInt)(t_3 != False);
163
   if ( t_2 ) {
164
    
165
    /* WITH_IMPS_FLAGS_CACHE_HIT := WITH_IMPS_FLAGS_CACHE_HIT + 1; */
166
    t_3 = GC_WITH__IMPS__FLAGS__CACHE__HIT;
167
    CHECK_BOUND( t_3, "WITH_IMPS_FLAGS_CACHE_HIT" )
168
    C_SUM_FIA( t_2, t_3, INTOBJ_INT(1) )
169
    AssGVar( G_WITH__IMPS__FLAGS__CACHE__HIT, t_2 );
170
    
171
    /* return WITH_IMPS_FLAGS_CACHE[hash2 + 1]; */
172
    t_3 = GC_WITH__IMPS__FLAGS__CACHE;
173
    CHECK_BOUND( t_3, "WITH_IMPS_FLAGS_CACHE" )
174
    C_SUM_FIA( t_4, l_hash2, INTOBJ_INT(1) )
175
    CHECK_INT_POS( t_4 )
176
    C_ELM_LIST_FPL( t_2, t_3, t_4 )
177
    RES_BRK_CURR_STAT();
178
    SWITCH_TO_OLD_FRAME(oldFrame);
179
    return t_2;
180
    
181
   }
182
   /* fi */
183
   
184
  }
185
  
186
  /* else */
187
  else {
188
   
189
   /* break; */
190
   break;
191
   
192
  }
193
  /* fi */
194
  
195
 }
196
 /* od */
197
 
198
 /* if i = 3 then */
199
 t_1 = (Obj)(UInt)(((Int)l_i) == ((Int)INTOBJ_INT(3)));
200
 if ( t_1 ) {
201
  
202
  /* WITH_IMPS_FLAGS_COUNT := (WITH_IMPS_FLAGS_COUNT + 1) mod 4; */
203
  t_3 = GC_WITH__IMPS__FLAGS__COUNT;
204
  CHECK_BOUND( t_3, "WITH_IMPS_FLAGS_COUNT" )
205
  C_SUM_FIA( t_2, t_3, INTOBJ_INT(1) )
206
  t_1 = MOD( t_2, INTOBJ_INT(4) );
207
  AssGVar( G_WITH__IMPS__FLAGS__COUNT, t_1 );
208
  
209
  /* i := WITH_IMPS_FLAGS_COUNT; */
210
  t_1 = GC_WITH__IMPS__FLAGS__COUNT;
211
  CHECK_BOUND( t_1, "WITH_IMPS_FLAGS_COUNT" )
212
  l_i = t_1;
213
  
214
  /* hash2 := 2 * ((hash + 31 * i) mod 11001) + 1; */
215
  C_PROD_FIA( t_5, INTOBJ_INT(31), l_i )
216
  C_SUM_FIA( t_4, l_hash, t_5 )
217
  t_3 = MOD( t_4, INTOBJ_INT(11001) );
218
  C_PROD_FIA( t_2, INTOBJ_INT(2), t_3 )
219
  C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
220
  l_hash2 = t_1;
221
  
222
 }
223
 /* fi */
224
 
225
 /* WITH_IMPS_FLAGS_CACHE_MISS := WITH_IMPS_FLAGS_CACHE_MISS + 1; */
226
 t_2 = GC_WITH__IMPS__FLAGS__CACHE__MISS;
227
 CHECK_BOUND( t_2, "WITH_IMPS_FLAGS_CACHE_MISS" )
228
 C_SUM_FIA( t_1, t_2, INTOBJ_INT(1) )
229
 AssGVar( G_WITH__IMPS__FLAGS__CACHE__MISS, t_1 );
230
 
231
 /* with := flags; */
232
 l_with = a_flags;
233
 
234
 /* changed := true; */
235
 t_1 = True;
236
 l_changed = t_1;
237
 
238
 /* while changed od */
239
 while ( 1 ) {
240
  t_1 = (Obj)(UInt)(l_changed != False);
241
  if ( ! t_1 ) break;
242
  
243
  /* changed := false; */
244
  t_1 = False;
245
  l_changed = t_1;
246
  
247
  /* for imp in IMPLICATIONS do */
248
  t_4 = GC_IMPLICATIONS;
249
  CHECK_BOUND( t_4, "IMPLICATIONS" )
250
  if ( IS_SMALL_LIST(t_4) ) {
251
   t_3 = (Obj)(UInt)1;
252
   t_1 = INTOBJ_INT(1);
253
  }
254
  else {
255
   t_3 = (Obj)(UInt)0;
256
   t_1 = CALL_1ARGS( GF_ITERATOR, t_4 );
257
  }
258
  while ( 1 ) {
259
   if ( t_3 ) {
260
    if ( LEN_LIST(t_4) < INT_INTOBJ(t_1) )  break;
261
    t_2 = ELMV0_LIST( t_4, INT_INTOBJ(t_1) );
262
    t_1 = (Obj)(((UInt)t_1)+4);
263
    if ( t_2 == 0 )  continue;
264
   }
265
   else {
266
    if ( CALL_1ARGS( GF_IS_DONE_ITER, t_1 ) != False )  break;
267
    t_2 = CALL_1ARGS( GF_NEXT_ITER, t_1 );
268
   }
269
   l_imp = t_2;
270
   
271
   /* if IS_SUBSET_FLAGS( with, imp[2] ) and not IS_SUBSET_FLAGS( with, imp[1] ) then */
272
   t_8 = GF_IS__SUBSET__FLAGS;
273
   C_ELM_LIST_FPL( t_9, l_imp, INTOBJ_INT(2) )
274
   t_7 = CALL_2ARGS( t_8, l_with, t_9 );
275
   CHECK_FUNC_RESULT( t_7 )
276
   CHECK_BOOL( t_7 )
277
   t_6 = (Obj)(UInt)(t_7 != False);
278
   t_5 = t_6;
279
   if ( t_5 ) {
280
    t_10 = GF_IS__SUBSET__FLAGS;
281
    C_ELM_LIST_FPL( t_11, l_imp, INTOBJ_INT(1) )
282
    t_9 = CALL_2ARGS( t_10, l_with, t_11 );
283
    CHECK_FUNC_RESULT( t_9 )
284
    CHECK_BOOL( t_9 )
285
    t_8 = (Obj)(UInt)(t_9 != False);
286
    t_7 = (Obj)(UInt)( ! ((Int)t_8) );
287
    t_5 = t_7;
288
   }
289
   if ( t_5 ) {
290
    
291
    /* with := AND_FLAGS( with, imp[1] ); */
292
    t_6 = GF_AND__FLAGS;
293
    C_ELM_LIST_FPL( t_7, l_imp, INTOBJ_INT(1) )
294
    t_5 = CALL_2ARGS( t_6, l_with, t_7 );
295
    CHECK_FUNC_RESULT( t_5 )
296
    l_with = t_5;
297
    
298
    /* changed := true; */
299
    t_5 = True;
300
    l_changed = t_5;
301
    
302
   }
303
   /* fi */
304
   
305
  }
306
  /* od */
307
  
308
 }
309
 /* od */
310
 
311
 /* WITH_IMPS_FLAGS_CACHE[hash2] := flags; */
312
 t_1 = GC_WITH__IMPS__FLAGS__CACHE;
313
 CHECK_BOUND( t_1, "WITH_IMPS_FLAGS_CACHE" )
314
 CHECK_INT_POS( l_hash2 )
315
 C_ASS_LIST_FPL( t_1, l_hash2, a_flags )
316
 
317
 /* WITH_IMPS_FLAGS_CACHE[hash2 + 1] := with; */
318
 t_1 = GC_WITH__IMPS__FLAGS__CACHE;
319
 CHECK_BOUND( t_1, "WITH_IMPS_FLAGS_CACHE" )
320
 C_SUM_FIA( t_2, l_hash2, INTOBJ_INT(1) )
321
 CHECK_INT_POS( t_2 )
322
 C_ASS_LIST_FPL( t_1, t_2, l_with )
323
 
324
 /* return with; */
325
 RES_BRK_CURR_STAT();
326
 SWITCH_TO_OLD_FRAME(oldFrame);
327
 return l_with;
328
 
329
 /* return; */
330
 RES_BRK_CURR_STAT();
331
 SWITCH_TO_OLD_FRAME(oldFrame);
332
 return 0;
333
}
334

335
/* handler for function 4 */
336
static Obj  HdlrFunc4 (
337
 Obj  self,
338
 Obj  a_filter )
339
{
340
 Obj l_rank = 0;
341
 Obj l_flags = 0;
342
 Obj l_i = 0;
343
 Obj t_1 = 0;
344
 Obj t_2 = 0;
345
 Obj t_3 = 0;
346
 Obj t_4 = 0;
347
 Obj t_5 = 0;
348
 Obj t_6 = 0;
349
 Obj t_7 = 0;
350
 Bag oldFrame;
351
 OLD_BRK_CURR_STAT
352
 
353
 /* allocate new stack frame */
354
 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
355
 REM_BRK_CURR_STAT();
356
 SET_BRK_CURR_STAT(0);
357
 
358
 /* rank := 0; */
359
 l_rank = INTOBJ_INT(0);
360
 
361
 /* if IS_FUNCTION( filter ) then */
362
 t_3 = GF_IS__FUNCTION;
363
 t_2 = CALL_1ARGS( t_3, a_filter );
364
 CHECK_FUNC_RESULT( t_2 )
365
 CHECK_BOOL( t_2 )
366
 t_1 = (Obj)(UInt)(t_2 != False);
367
 if ( t_1 ) {
368
  
369
  /* flags := FLAGS_FILTER( filter ); */
370
  t_2 = GF_FLAGS__FILTER;
371
  t_1 = CALL_1ARGS( t_2, a_filter );
372
  CHECK_FUNC_RESULT( t_1 )
373
  l_flags = t_1;
374
  
375
 }
376
 
377
 /* else */
378
 else {
379
  
380
  /* flags := filter; */
381
  l_flags = a_filter;
382
  
383
 }
384
 /* fi */
385
 
386
 /* for i in TRUES_FLAGS( WITH_HIDDEN_IMPS_FLAGS( flags ) ) do */
387
 t_5 = GF_TRUES__FLAGS;
388
 t_7 = GF_WITH__HIDDEN__IMPS__FLAGS;
389
 t_6 = CALL_1ARGS( t_7, l_flags );
390
 CHECK_FUNC_RESULT( t_6 )
391
 t_4 = CALL_1ARGS( t_5, t_6 );
392
 CHECK_FUNC_RESULT( t_4 )
393
 if ( IS_SMALL_LIST(t_4) ) {
394
  t_3 = (Obj)(UInt)1;
395
  t_1 = INTOBJ_INT(1);
396
 }
397
 else {
398
  t_3 = (Obj)(UInt)0;
399
  t_1 = CALL_1ARGS( GF_ITERATOR, t_4 );
400
 }
401
 while ( 1 ) {
402
  if ( t_3 ) {
403
   if ( LEN_LIST(t_4) < INT_INTOBJ(t_1) )  break;
404
   t_2 = ELMV0_LIST( t_4, INT_INTOBJ(t_1) );
405
   t_1 = (Obj)(((UInt)t_1)+4);
406
   if ( t_2 == 0 )  continue;
407
  }
408
  else {
409
   if ( CALL_1ARGS( GF_IS_DONE_ITER, t_1 ) != False )  break;
410
   t_2 = CALL_1ARGS( GF_NEXT_ITER, t_1 );
411
  }
412
  l_i = t_2;
413
  
414
  /* if IsBound( RANK_FILTERS[i] ) then */
415
  t_7 = GC_RANK__FILTERS;
416
  CHECK_BOUND( t_7, "RANK_FILTERS" )
417
  CHECK_INT_POS( l_i )
418
  t_6 = C_ISB_LIST( t_7, l_i );
419
  t_5 = (Obj)(UInt)(t_6 != False);
420
  if ( t_5 ) {
421
   
422
   /* rank := rank + RANK_FILTERS[i]; */
423
   t_7 = GC_RANK__FILTERS;
424
   CHECK_BOUND( t_7, "RANK_FILTERS" )
425
   C_ELM_LIST_FPL( t_6, t_7, l_i )
426
   C_SUM_FIA( t_5, l_rank, t_6 )
427
   l_rank = t_5;
428
   
429
  }
430
  
431
  /* else */
432
  else {
433
   
434
   /* rank := rank + 1; */
435
   C_SUM_FIA( t_5, l_rank, INTOBJ_INT(1) )
436
   l_rank = t_5;
437
   
438
  }
439
  /* fi */
440
  
441
 }
442
 /* od */
443
 
444
 /* return rank; */
445
 RES_BRK_CURR_STAT();
446
 SWITCH_TO_OLD_FRAME(oldFrame);
447
 return l_rank;
448
 
449
 /* return; */
450
 RES_BRK_CURR_STAT();
451
 SWITCH_TO_OLD_FRAME(oldFrame);
452
 return 0;
453
}
454

455
/* handler for function 5 */
456
static Obj  HdlrFunc5 (
457
 Obj  self,
458
 Obj  a_filter )
459
{
460
 Obj l_hash = 0;
461
 Obj l_rank = 0;
462
 Obj l_flags = 0;
463
 Obj t_1 = 0;
464
 Obj t_2 = 0;
465
 Obj t_3 = 0;
466
 Bag oldFrame;
467
 OLD_BRK_CURR_STAT
468
 
469
 /* allocate new stack frame */
470
 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
471
 REM_BRK_CURR_STAT();
472
 SET_BRK_CURR_STAT(0);
473
 
474
 /* if IS_FUNCTION( filter ) then */
475
 t_3 = GF_IS__FUNCTION;
476
 t_2 = CALL_1ARGS( t_3, a_filter );
477
 CHECK_FUNC_RESULT( t_2 )
478
 CHECK_BOOL( t_2 )
479
 t_1 = (Obj)(UInt)(t_2 != False);
480
 if ( t_1 ) {
481
  
482
  /* flags := FLAGS_FILTER( filter ); */
483
  t_2 = GF_FLAGS__FILTER;
484
  t_1 = CALL_1ARGS( t_2, a_filter );
485
  CHECK_FUNC_RESULT( t_1 )
486
  l_flags = t_1;
487
  
488
 }
489
 
490
 /* else */
491
 else {
492
  
493
  /* flags := filter; */
494
  l_flags = a_filter;
495
  
496
 }
497
 /* fi */
498
 
499
 /* hash := HASH_FLAGS( flags ); */
500
 t_2 = GF_HASH__FLAGS;
501
 t_1 = CALL_1ARGS( t_2, l_flags );
502
 CHECK_FUNC_RESULT( t_1 )
503
 l_hash = t_1;
504
 
505
 /* rank := RANK_FILTER( flags ); */
506
 t_2 = GF_RANK__FILTER;
507
 t_1 = CALL_1ARGS( t_2, l_flags );
508
 CHECK_FUNC_RESULT( t_1 )
509
 l_rank = t_1;
510
 
511
 /* ADD_LIST( RANK_FILTER_LIST_CURRENT, hash ); */
512
 t_1 = GF_ADD__LIST;
513
 t_2 = GC_RANK__FILTER__LIST__CURRENT;
514
 CHECK_BOUND( t_2, "RANK_FILTER_LIST_CURRENT" )
515
 CALL_2ARGS( t_1, t_2, l_hash );
516
 
517
 /* ADD_LIST( RANK_FILTER_LIST_CURRENT, rank ); */
518
 t_1 = GF_ADD__LIST;
519
 t_2 = GC_RANK__FILTER__LIST__CURRENT;
520
 CHECK_BOUND( t_2, "RANK_FILTER_LIST_CURRENT" )
521
 CALL_2ARGS( t_1, t_2, l_rank );
522
 
523
 /* return rank; */
524
 RES_BRK_CURR_STAT();
525
 SWITCH_TO_OLD_FRAME(oldFrame);
526
 return l_rank;
527
 
528
 /* return; */
529
 RES_BRK_CURR_STAT();
530
 SWITCH_TO_OLD_FRAME(oldFrame);
531
 return 0;
532
}
533

534
/* handler for function 6 */
535
static Obj  HdlrFunc6 (
536
 Obj  self,
537
 Obj  a_filter )
538
{
539
 Obj l_hash = 0;
540
 Obj l_flags = 0;
541
 Obj t_1 = 0;
542
 Obj t_2 = 0;
543
 Obj t_3 = 0;
544
 Obj t_4 = 0;
545
 Bag oldFrame;
546
 OLD_BRK_CURR_STAT
547
 
548
 /* allocate new stack frame */
549
 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
550
 REM_BRK_CURR_STAT();
551
 SET_BRK_CURR_STAT(0);
552
 
553
 /* if IS_FUNCTION( filter ) then */
554
 t_3 = GF_IS__FUNCTION;
555
 t_2 = CALL_1ARGS( t_3, a_filter );
556
 CHECK_FUNC_RESULT( t_2 )
557
 CHECK_BOOL( t_2 )
558
 t_1 = (Obj)(UInt)(t_2 != False);
559
 if ( t_1 ) {
560
  
561
  /* flags := FLAGS_FILTER( filter ); */
562
  t_2 = GF_FLAGS__FILTER;
563
  t_1 = CALL_1ARGS( t_2, a_filter );
564
  CHECK_FUNC_RESULT( t_1 )
565
  l_flags = t_1;
566
  
567
 }
568
 
569
 /* else */
570
 else {
571
  
572
  /* flags := filter; */
573
  l_flags = a_filter;
574
  
575
 }
576
 /* fi */
577
 
578
 /* hash := HASH_FLAGS( flags ); */
579
 t_2 = GF_HASH__FLAGS;
580
 t_1 = CALL_1ARGS( t_2, l_flags );
581
 CHECK_FUNC_RESULT( t_1 )
582
 l_hash = t_1;
583
 
584
 /* if hash <> RANK_FILTER_LIST[RANK_FILTER_COUNT] then */
585
 t_3 = GC_RANK__FILTER__LIST;
586
 CHECK_BOUND( t_3, "RANK_FILTER_LIST" )
587
 t_4 = GC_RANK__FILTER__COUNT;
588
 CHECK_BOUND( t_4, "RANK_FILTER_COUNT" )
589
 CHECK_INT_POS( t_4 )
590
 C_ELM_LIST_FPL( t_2, t_3, t_4 )
591
 t_1 = (Obj)(UInt)( ! EQ( l_hash, t_2 ));
592
 if ( t_1 ) {
593
  
594
  /* Error( "corrupted completion file" ); */
595
  t_1 = GF_Error;
596
  C_NEW_STRING( t_2, 25, "corrupted completion file" );
597
  CALL_1ARGS( t_1, t_2 );
598
  
599
 }
600
 /* fi */
601
 
602
 /* RANK_FILTER_COUNT := RANK_FILTER_COUNT + 2; */
603
 t_2 = GC_RANK__FILTER__COUNT;
604
 CHECK_BOUND( t_2, "RANK_FILTER_COUNT" )
605
 C_SUM_FIA( t_1, t_2, INTOBJ_INT(2) )
606
 AssGVar( G_RANK__FILTER__COUNT, t_1 );
607
 
608
 /* return RANK_FILTER_LIST[RANK_FILTER_COUNT - 1]; */
609
 t_2 = GC_RANK__FILTER__LIST;
610
 CHECK_BOUND( t_2, "RANK_FILTER_LIST" )
611
 t_4 = GC_RANK__FILTER__COUNT;
612
 CHECK_BOUND( t_4, "RANK_FILTER_COUNT" )
613
 C_DIFF_FIA( t_3, t_4, INTOBJ_INT(1) )
614
 CHECK_INT_POS( t_3 )
615
 C_ELM_LIST_FPL( t_1, t_2, t_3 )
616
 RES_BRK_CURR_STAT();
617
 SWITCH_TO_OLD_FRAME(oldFrame);
618
 return t_1;
619
 
620
 /* return; */
621
 RES_BRK_CURR_STAT();
622
 SWITCH_TO_OLD_FRAME(oldFrame);
623
 return 0;
624
}
625

626
/* handler for function 1 */
627
static Obj  HdlrFunc1 (
628
 Obj  self )
629
{
630
 Obj t_1 = 0;
631
 Obj t_2 = 0;
632
 Obj t_3 = 0;
633
 Obj t_4 = 0;
634
 Bag oldFrame;
635
 OLD_BRK_CURR_STAT
636
 
637
 /* allocate new stack frame */
638
 SWITCH_TO_NEW_FRAME(self,0,0,oldFrame);
639
 REM_BRK_CURR_STAT();
640
 SET_BRK_CURR_STAT(0);
641
 
642
 /* WITH_HIDDEN_IMPS_FLAGS_COUNT := 0; */
643
 AssGVar( G_WITH__HIDDEN__IMPS__FLAGS__COUNT, INTOBJ_INT(0) );
644
 
645
 /* WITH_HIDDEN_IMPS_FLAGS_CACHE_MISS := 0; */
646
 AssGVar( G_WITH__HIDDEN__IMPS__FLAGS__CACHE__MISS, INTOBJ_INT(0) );
647
 
648
 /* WITH_HIDDEN_IMPS_FLAGS_CACHE_HIT := 0; */
649
 AssGVar( G_WITH__HIDDEN__IMPS__FLAGS__CACHE__HIT, INTOBJ_INT(0) );
650
 
651
 /* IMPLICATIONS := [  ]; */
652
 t_1 = NEW_PLIST( T_PLIST, 0 );
653
 SET_LEN_PLIST( t_1, 0 );
654
 AssGVar( G_IMPLICATIONS, t_1 );
655
 
656
 /* WITH_IMPS_FLAGS_CACHE := [  ]; */
657
 t_1 = NEW_PLIST( T_PLIST, 0 );
658
 SET_LEN_PLIST( t_1, 0 );
659
 AssGVar( G_WITH__IMPS__FLAGS__CACHE, t_1 );
660
 
661
 /* WITH_IMPS_FLAGS_COUNT := 0; */
662
 AssGVar( G_WITH__IMPS__FLAGS__COUNT, INTOBJ_INT(0) );
663
 
664
 /* WITH_IMPS_FLAGS_CACHE_HIT := 0; */
665
 AssGVar( G_WITH__IMPS__FLAGS__CACHE__HIT, INTOBJ_INT(0) );
666
 
667
 /* WITH_IMPS_FLAGS_CACHE_MISS := 0; */
668
 AssGVar( G_WITH__IMPS__FLAGS__CACHE__MISS, INTOBJ_INT(0) );
669
 
670
 /* Unbind( CLEAR_IMP_CACHE ); */
671
 AssGVar( G_CLEAR__IMP__CACHE, 0 );
672
 
673
 /* BIND_GLOBAL( "CLEAR_IMP_CACHE", function (  )
674
      WITH_IMPS_FLAGS_CACHE := [  ];
675
      return;
676
  end ); */
677
 t_1 = GF_BIND__GLOBAL;
678
 C_NEW_STRING( t_2, 15, "CLEAR_IMP_CACHE" );
679
 t_3 = NewFunction( NameFunc[2], NargFunc[2], NamsFunc[2], HdlrFunc2 );
680
 ENVI_FUNC( t_3 ) = TLS(CurrLVars);
681
 t_4 = NewBag( T_BODY, NUMBER_HEADER_ITEMS_BODY*sizeof(Obj) );
682
 STARTLINE_BODY(t_4) = INTOBJ_INT(39);
683
 ENDLINE_BODY(t_4) = INTOBJ_INT(41);
684
 FILENAME_BODY(t_4) = FileName;
685
 BODY_FUNC(t_3) = t_4;
686
 CHANGED_BAG( TLS(CurrLVars) );
687
 CALL_2ARGS( t_1, t_2, t_3 );
688
 
689
 /* BIND_GLOBAL( "WITH_IMPS_FLAGS", function ( flags )
690
      local  with, changed, imp, hash, hash2, i;
691
      hash := HASH_FLAGS( flags ) mod 11001;
692
      for i  in [ 0 .. 3 ]  do
693
          hash2 := 2 * ((hash + 31 * i) mod 11001) + 1;
694
          if IsBound( WITH_IMPS_FLAGS_CACHE[hash2] )  then
695
              if IS_IDENTICAL_OBJ( WITH_IMPS_FLAGS_CACHE[hash2], flags )  then
696
                  WITH_IMPS_FLAGS_CACHE_HIT := WITH_IMPS_FLAGS_CACHE_HIT + 1;
697
                  return WITH_IMPS_FLAGS_CACHE[hash2 + 1];
698
              fi;
699
          else
700
              break;
701
          fi;
702
      od;
703
      if i = 3  then
704
          WITH_IMPS_FLAGS_COUNT := (WITH_IMPS_FLAGS_COUNT + 1) mod 4;
705
          i := WITH_IMPS_FLAGS_COUNT;
706
          hash2 := 2 * ((hash + 31 * i) mod 11001) + 1;
707
      fi;
708
      WITH_IMPS_FLAGS_CACHE_MISS := WITH_IMPS_FLAGS_CACHE_MISS + 1;
709
      with := flags;
710
      changed := true;
711
      while changed  do
712
          changed := false;
713
          for imp  in IMPLICATIONS  do
714
              if IS_SUBSET_FLAGS( with, imp[2] ) and not IS_SUBSET_FLAGS( with, imp[1] )  then
715
                  with := AND_FLAGS( with, imp[1] );
716
                  changed := true;
717
              fi;
718
          od;
719
      od;
720
      WITH_IMPS_FLAGS_CACHE[hash2] := flags;
721
      WITH_IMPS_FLAGS_CACHE[hash2 + 1] := with;
722
      return with;
723
  end ); */
724
 t_1 = GF_BIND__GLOBAL;
725
 C_NEW_STRING( t_2, 15, "WITH_IMPS_FLAGS" );
726
 t_3 = NewFunction( NameFunc[3], NargFunc[3], NamsFunc[3], HdlrFunc3 );
727
 ENVI_FUNC( t_3 ) = TLS(CurrLVars);
728
 t_4 = NewBag( T_BODY, NUMBER_HEADER_ITEMS_BODY*sizeof(Obj) );
729
 STARTLINE_BODY(t_4) = INTOBJ_INT(44);
730
 ENDLINE_BODY(t_4) = INTOBJ_INT(83);
731
 FILENAME_BODY(t_4) = FileName;
732
 BODY_FUNC(t_3) = t_4;
733
 CHANGED_BAG( TLS(CurrLVars) );
734
 CALL_2ARGS( t_1, t_2, t_3 );
735
 
736
 /* UNBIND_GLOBAL( "RANK_FILTER" ); */
737
 t_1 = GF_UNBIND__GLOBAL;
738
 C_NEW_STRING( t_2, 11, "RANK_FILTER" );
739
 CALL_1ARGS( t_1, t_2 );
740
 
741
 /* BIND_GLOBAL( "RANK_FILTER", function ( filter )
742
      local  rank, flags, i;
743
      rank := 0;
744
      if IS_FUNCTION( filter )  then
745
          flags := FLAGS_FILTER( filter );
746
      else
747
          flags := filter;
748
      fi;
749
      for i  in TRUES_FLAGS( WITH_HIDDEN_IMPS_FLAGS( flags ) )  do
750
          if IsBound( RANK_FILTERS[i] )  then
751
              rank := rank + RANK_FILTERS[i];
752
          else
753
              rank := rank + 1;
754
          fi;
755
      od;
756
      return rank;
757
  end ); */
758
 t_1 = GF_BIND__GLOBAL;
759
 C_NEW_STRING( t_2, 11, "RANK_FILTER" );
760
 t_3 = NewFunction( NameFunc[4], NargFunc[4], NamsFunc[4], HdlrFunc4 );
761
 ENVI_FUNC( t_3 ) = TLS(CurrLVars);
762
 t_4 = NewBag( T_BODY, NUMBER_HEADER_ITEMS_BODY*sizeof(Obj) );
763
 STARTLINE_BODY(t_4) = INTOBJ_INT(97);
764
 ENDLINE_BODY(t_4) = INTOBJ_INT(114);
765
 FILENAME_BODY(t_4) = FileName;
766
 BODY_FUNC(t_3) = t_4;
767
 CHANGED_BAG( TLS(CurrLVars) );
768
 CALL_2ARGS( t_1, t_2, t_3 );
769
 
770
 /* RankFilter := RANK_FILTER; */
771
 t_1 = GC_RANK__FILTER;
772
 CHECK_BOUND( t_1, "RANK_FILTER" )
773
 AssGVar( G_RankFilter, t_1 );
774
 
775
 /* UNBIND_GLOBAL( "RANK_FILTER_STORE" ); */
776
 t_1 = GF_UNBIND__GLOBAL;
777
 C_NEW_STRING( t_2, 17, "RANK_FILTER_STORE" );
778
 CALL_1ARGS( t_1, t_2 );
779
 
780
 /* BIND_GLOBAL( "RANK_FILTER_STORE", function ( filter )
781
      local  hash, rank, flags;
782
      if IS_FUNCTION( filter )  then
783
          flags := FLAGS_FILTER( filter );
784
      else
785
          flags := filter;
786
      fi;
787
      hash := HASH_FLAGS( flags );
788
      rank := RANK_FILTER( flags );
789
      ADD_LIST( RANK_FILTER_LIST_CURRENT, hash );
790
      ADD_LIST( RANK_FILTER_LIST_CURRENT, rank );
791
      return rank;
792
  end ); */
793
 t_1 = GF_BIND__GLOBAL;
794
 C_NEW_STRING( t_2, 17, "RANK_FILTER_STORE" );
795
 t_3 = NewFunction( NameFunc[5], NargFunc[5], NamsFunc[5], HdlrFunc5 );
796
 ENVI_FUNC( t_3 ) = TLS(CurrLVars);
797
 t_4 = NewBag( T_BODY, NUMBER_HEADER_ITEMS_BODY*sizeof(Obj) );
798
 STARTLINE_BODY(t_4) = INTOBJ_INT(119);
799
 ENDLINE_BODY(t_4) = INTOBJ_INT(133);
800
 FILENAME_BODY(t_4) = FileName;
801
 BODY_FUNC(t_3) = t_4;
802
 CHANGED_BAG( TLS(CurrLVars) );
803
 CALL_2ARGS( t_1, t_2, t_3 );
804
 
805
 /* UNBIND_GLOBAL( "RANK_FILTER_COMPLETION" ); */
806
 t_1 = GF_UNBIND__GLOBAL;
807
 C_NEW_STRING( t_2, 22, "RANK_FILTER_COMPLETION" );
808
 CALL_1ARGS( t_1, t_2 );
809
 
810
 /* BIND_GLOBAL( "RANK_FILTER_COMPLETION", function ( filter )
811
      local  hash, flags;
812
      if IS_FUNCTION( filter )  then
813
          flags := FLAGS_FILTER( filter );
814
      else
815
          flags := filter;
816
      fi;
817
      hash := HASH_FLAGS( flags );
818
      if hash <> RANK_FILTER_LIST[RANK_FILTER_COUNT]  then
819
          Error( "corrupted completion file" );
820
      fi;
821
      RANK_FILTER_COUNT := RANK_FILTER_COUNT + 2;
822
      return RANK_FILTER_LIST[RANK_FILTER_COUNT - 1];
823
  end ); */
824
 t_1 = GF_BIND__GLOBAL;
825
 C_NEW_STRING( t_2, 22, "RANK_FILTER_COMPLETION" );
826
 t_3 = NewFunction( NameFunc[6], NargFunc[6], NamsFunc[6], HdlrFunc6 );
827
 ENVI_FUNC( t_3 ) = TLS(CurrLVars);
828
 t_4 = NewBag( T_BODY, NUMBER_HEADER_ITEMS_BODY*sizeof(Obj) );
829
 STARTLINE_BODY(t_4) = INTOBJ_INT(136);
830
 ENDLINE_BODY(t_4) = INTOBJ_INT(151);
831
 FILENAME_BODY(t_4) = FileName;
832
 BODY_FUNC(t_3) = t_4;
833
 CHANGED_BAG( TLS(CurrLVars) );
834
 CALL_2ARGS( t_1, t_2, t_3 );
835
 
836
 /* return; */
837
 RES_BRK_CURR_STAT();
838
 SWITCH_TO_OLD_FRAME(oldFrame);
839
 return 0;
840
 
841
 /* return; */
842
 RES_BRK_CURR_STAT();
843
 SWITCH_TO_OLD_FRAME(oldFrame);
844
 return 0;
845
}
846

847
/* 'InitKernel' sets up data structures, fopies, copies, handlers */
848
static Int InitKernel ( StructInitInfo * module )
849
{
850
 
851
 /* global variables used in handlers */
852
 InitFopyGVar( "IS_FUNCTION", &GF_IS__FUNCTION );
853
 InitFopyGVar( "ADD_LIST", &GF_ADD__LIST );
854
 InitFopyGVar( "Error", &GF_Error );
855
 InitFopyGVar( "IS_IDENTICAL_OBJ", &GF_IS__IDENTICAL__OBJ );
856
 InitFopyGVar( "AND_FLAGS", &GF_AND__FLAGS );
857
 InitFopyGVar( "HASH_FLAGS", &GF_HASH__FLAGS );
858
 InitFopyGVar( "WITH_HIDDEN_IMPS_FLAGS", &GF_WITH__HIDDEN__IMPS__FLAGS );
859
 InitFopyGVar( "IS_SUBSET_FLAGS", &GF_IS__SUBSET__FLAGS );
860
 InitFopyGVar( "TRUES_FLAGS", &GF_TRUES__FLAGS );
861
 InitFopyGVar( "FLAGS_FILTER", &GF_FLAGS__FILTER );
862
 InitCopyGVar( "IMPLICATIONS", &GC_IMPLICATIONS );
863
 InitCopyGVar( "WITH_IMPS_FLAGS_CACHE", &GC_WITH__IMPS__FLAGS__CACHE );
864
 InitCopyGVar( "WITH_IMPS_FLAGS_COUNT", &GC_WITH__IMPS__FLAGS__COUNT );
865
 InitCopyGVar( "WITH_IMPS_FLAGS_CACHE_HIT", &GC_WITH__IMPS__FLAGS__CACHE__HIT );
866
 InitCopyGVar( "WITH_IMPS_FLAGS_CACHE_MISS", &GC_WITH__IMPS__FLAGS__CACHE__MISS );
867
 InitFopyGVar( "BIND_GLOBAL", &GF_BIND__GLOBAL );
868
 InitFopyGVar( "UNBIND_GLOBAL", &GF_UNBIND__GLOBAL );
869
 InitCopyGVar( "RANK_FILTERS", &GC_RANK__FILTERS );
870
 InitCopyGVar( "RANK_FILTER", &GC_RANK__FILTER );
871
 InitFopyGVar( "RANK_FILTER", &GF_RANK__FILTER );
872
 InitCopyGVar( "RANK_FILTER_LIST_CURRENT", &GC_RANK__FILTER__LIST__CURRENT );
873
 InitCopyGVar( "RANK_FILTER_LIST", &GC_RANK__FILTER__LIST );
874
 InitCopyGVar( "RANK_FILTER_COUNT", &GC_RANK__FILTER__COUNT );
875
 
876
 /* information for the functions */
877
 InitGlobalBag( &DefaultName, "GAPROOT/lib/filter1.g:DefaultName(118753041)" );
878
 InitGlobalBag( &FileName, "GAPROOT/lib/filter1.g:FileName(118753041)" );
879
 InitHandlerFunc( HdlrFunc1, "GAPROOT/lib/filter1.g:HdlrFunc1(118753041)" );
880
 InitGlobalBag( &(NameFunc[1]), "GAPROOT/lib/filter1.g:NameFunc[1](118753041)" );
881
 InitHandlerFunc( HdlrFunc2, "GAPROOT/lib/filter1.g:HdlrFunc2(118753041)" );
882
 InitGlobalBag( &(NameFunc[2]), "GAPROOT/lib/filter1.g:NameFunc[2](118753041)" );
883
 InitHandlerFunc( HdlrFunc3, "GAPROOT/lib/filter1.g:HdlrFunc3(118753041)" );
884
 InitGlobalBag( &(NameFunc[3]), "GAPROOT/lib/filter1.g:NameFunc[3](118753041)" );
885
 InitHandlerFunc( HdlrFunc4, "GAPROOT/lib/filter1.g:HdlrFunc4(118753041)" );
886
 InitGlobalBag( &(NameFunc[4]), "GAPROOT/lib/filter1.g:NameFunc[4](118753041)" );
887
 InitHandlerFunc( HdlrFunc5, "GAPROOT/lib/filter1.g:HdlrFunc5(118753041)" );
888
 InitGlobalBag( &(NameFunc[5]), "GAPROOT/lib/filter1.g:NameFunc[5](118753041)" );
889
 InitHandlerFunc( HdlrFunc6, "GAPROOT/lib/filter1.g:HdlrFunc6(118753041)" );
890
 InitGlobalBag( &(NameFunc[6]), "GAPROOT/lib/filter1.g:NameFunc[6](118753041)" );
891
 
892
 /* return success */
893
 return 0;
894
 
895
}
896

897
/* 'InitLibrary' sets up gvars, rnams, functions */
898
static Int InitLibrary ( StructInitInfo * module )
899
{
900
 Obj func1;
901
 Obj body1;
902
 
903
 /* Complete Copy/Fopy registration */
904
 UpdateCopyFopyInfo();
905
 
906
 /* global variables used in handlers */
907
 G_IS__FUNCTION = GVarName( "IS_FUNCTION" );
908
 G_ADD__LIST = GVarName( "ADD_LIST" );
909
 G_Error = GVarName( "Error" );
910
 G_IS__IDENTICAL__OBJ = GVarName( "IS_IDENTICAL_OBJ" );
911
 G_AND__FLAGS = GVarName( "AND_FLAGS" );
912
 G_HASH__FLAGS = GVarName( "HASH_FLAGS" );
913
 G_WITH__HIDDEN__IMPS__FLAGS = GVarName( "WITH_HIDDEN_IMPS_FLAGS" );
914
 G_IS__SUBSET__FLAGS = GVarName( "IS_SUBSET_FLAGS" );
915
 G_TRUES__FLAGS = GVarName( "TRUES_FLAGS" );
916
 G_FLAGS__FILTER = GVarName( "FLAGS_FILTER" );
917
 G_WITH__HIDDEN__IMPS__FLAGS__COUNT = GVarName( "WITH_HIDDEN_IMPS_FLAGS_COUNT" );
918
 G_WITH__HIDDEN__IMPS__FLAGS__CACHE__MISS = GVarName( "WITH_HIDDEN_IMPS_FLAGS_CACHE_MISS" );
919
 G_WITH__HIDDEN__IMPS__FLAGS__CACHE__HIT = GVarName( "WITH_HIDDEN_IMPS_FLAGS_CACHE_HIT" );
920
 G_IMPLICATIONS = GVarName( "IMPLICATIONS" );
921
 G_WITH__IMPS__FLAGS__CACHE = GVarName( "WITH_IMPS_FLAGS_CACHE" );
922
 G_WITH__IMPS__FLAGS__COUNT = GVarName( "WITH_IMPS_FLAGS_COUNT" );
923
 G_WITH__IMPS__FLAGS__CACHE__HIT = GVarName( "WITH_IMPS_FLAGS_CACHE_HIT" );
924
 G_WITH__IMPS__FLAGS__CACHE__MISS = GVarName( "WITH_IMPS_FLAGS_CACHE_MISS" );
925
 G_CLEAR__IMP__CACHE = GVarName( "CLEAR_IMP_CACHE" );
926
 G_BIND__GLOBAL = GVarName( "BIND_GLOBAL" );
927
 G_UNBIND__GLOBAL = GVarName( "UNBIND_GLOBAL" );
928
 G_RANK__FILTERS = GVarName( "RANK_FILTERS" );
929
 G_RankFilter = GVarName( "RankFilter" );
930
 G_RANK__FILTER = GVarName( "RANK_FILTER" );
931
 G_RANK__FILTER__LIST__CURRENT = GVarName( "RANK_FILTER_LIST_CURRENT" );
932
 G_RANK__FILTER__LIST = GVarName( "RANK_FILTER_LIST" );
933
 G_RANK__FILTER__COUNT = GVarName( "RANK_FILTER_COUNT" );
934
 
935
 /* record names used in handlers */
936
 
937
 /* information for the functions */
938
 C_NEW_STRING( DefaultName, 14, "local function" );
939
 C_NEW_STRING( FileName, 21, "GAPROOT/lib/filter1.g" );
940
 NameFunc[1] = DefaultName;
941
 NamsFunc[1] = 0;
942
 NargFunc[1] = 0;
943
 NameFunc[2] = DefaultName;
944
 NamsFunc[2] = 0;
945
 NargFunc[2] = 0;
946
 NameFunc[3] = DefaultName;
947
 NamsFunc[3] = 0;
948
 NargFunc[3] = 1;
949
 NameFunc[4] = DefaultName;
950
 NamsFunc[4] = 0;
951
 NargFunc[4] = 1;
952
 NameFunc[5] = DefaultName;
953
 NamsFunc[5] = 0;
954
 NargFunc[5] = 1;
955
 NameFunc[6] = DefaultName;
956
 NamsFunc[6] = 0;
957
 NargFunc[6] = 1;
958
 
959
 /* create all the functions defined in this module */
960
 func1 = NewFunction(NameFunc[1],NargFunc[1],NamsFunc[1],HdlrFunc1);
961
 ENVI_FUNC( func1 ) = TLS(CurrLVars);
962
 CHANGED_BAG( TLS(CurrLVars) );
963
 body1 = NewBag( T_BODY, NUMBER_HEADER_ITEMS_BODY*sizeof(Obj));
964
 BODY_FUNC( func1 ) = body1;
965
 CHANGED_BAG( func1 );
966
 CALL_0ARGS( func1 );
967
 
968
 /* return success */
969
 return 0;
970
 
971
}
972

973
/* 'PostRestore' restore gvars, rnams, functions */
974
static Int PostRestore ( StructInitInfo * module )
975
{
976
 
977
 /* global variables used in handlers */
978
 G_IS__FUNCTION = GVarName( "IS_FUNCTION" );
979
 G_ADD__LIST = GVarName( "ADD_LIST" );
980
 G_Error = GVarName( "Error" );
981
 G_IS__IDENTICAL__OBJ = GVarName( "IS_IDENTICAL_OBJ" );
982
 G_AND__FLAGS = GVarName( "AND_FLAGS" );
983
 G_HASH__FLAGS = GVarName( "HASH_FLAGS" );
984
 G_WITH__HIDDEN__IMPS__FLAGS = GVarName( "WITH_HIDDEN_IMPS_FLAGS" );
985
 G_IS__SUBSET__FLAGS = GVarName( "IS_SUBSET_FLAGS" );
986
 G_TRUES__FLAGS = GVarName( "TRUES_FLAGS" );
987
 G_FLAGS__FILTER = GVarName( "FLAGS_FILTER" );
988
 G_WITH__HIDDEN__IMPS__FLAGS__COUNT = GVarName( "WITH_HIDDEN_IMPS_FLAGS_COUNT" );
989
 G_WITH__HIDDEN__IMPS__FLAGS__CACHE__MISS = GVarName( "WITH_HIDDEN_IMPS_FLAGS_CACHE_MISS" );
990
 G_WITH__HIDDEN__IMPS__FLAGS__CACHE__HIT = GVarName( "WITH_HIDDEN_IMPS_FLAGS_CACHE_HIT" );
991
 G_IMPLICATIONS = GVarName( "IMPLICATIONS" );
992
 G_WITH__IMPS__FLAGS__CACHE = GVarName( "WITH_IMPS_FLAGS_CACHE" );
993
 G_WITH__IMPS__FLAGS__COUNT = GVarName( "WITH_IMPS_FLAGS_COUNT" );
994
 G_WITH__IMPS__FLAGS__CACHE__HIT = GVarName( "WITH_IMPS_FLAGS_CACHE_HIT" );
995
 G_WITH__IMPS__FLAGS__CACHE__MISS = GVarName( "WITH_IMPS_FLAGS_CACHE_MISS" );
996
 G_CLEAR__IMP__CACHE = GVarName( "CLEAR_IMP_CACHE" );
997
 G_BIND__GLOBAL = GVarName( "BIND_GLOBAL" );
998
 G_UNBIND__GLOBAL = GVarName( "UNBIND_GLOBAL" );
999
 G_RANK__FILTERS = GVarName( "RANK_FILTERS" );
1000
 G_RankFilter = GVarName( "RankFilter" );
1001
 G_RANK__FILTER = GVarName( "RANK_FILTER" );
1002
 G_RANK__FILTER__LIST__CURRENT = GVarName( "RANK_FILTER_LIST_CURRENT" );
1003
 G_RANK__FILTER__LIST = GVarName( "RANK_FILTER_LIST" );
1004
 G_RANK__FILTER__COUNT = GVarName( "RANK_FILTER_COUNT" );
1005
 
1006
 /* record names used in handlers */
1007
 
1008
 /* information for the functions */
1009
 NameFunc[1] = DefaultName;
1010
 NamsFunc[1] = 0;
1011
 NargFunc[1] = 0;
1012
 NameFunc[2] = DefaultName;
1013
 NamsFunc[2] = 0;
1014
 NargFunc[2] = 0;
1015
 NameFunc[3] = DefaultName;
1016
 NamsFunc[3] = 0;
1017
 NargFunc[3] = 1;
1018
 NameFunc[4] = DefaultName;
1019
 NamsFunc[4] = 0;
1020
 NargFunc[4] = 1;
1021
 NameFunc[5] = DefaultName;
1022
 NamsFunc[5] = 0;
1023
 NargFunc[5] = 1;
1024
 NameFunc[6] = DefaultName;
1025
 NamsFunc[6] = 0;
1026
 NargFunc[6] = 1;
1027
 
1028
 /* return success */
1029
 return 0;
1030
 
1031
}
1032

1033

1034
/* <name> returns the description of this module */
1035
static StructInitInfo module = {
1036
 /* type        = */ 2,
1037
 /* name        = */ "GAPROOT/lib/filter1.g",
1038
 /* revision_c  = */ 0,
1039
 /* revision_h  = */ 0,
1040
 /* version     = */ 0,
1041
 /* crc         = */ 118753041,
1042
 /* initKernel  = */ InitKernel,
1043
 /* initLibrary = */ InitLibrary,
1044
 /* checkInit   = */ 0,
1045
 /* preSave     = */ 0,
1046
 /* postSave    = */ 0,
1047
 /* postRestore = */ PostRestore
1048
};
1049

1050
StructInitInfo * Init__filter1 ( void )
1051
{
1052
 return &module;
1053
}
1054

1055
/* compiled code ends here */
1056
#endif
1057

1058
Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place.

Product

Resources

Company

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more, all in one place.

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place.
