YAP 7.1.0
itries.c
1/*********************************
2 File: itries.c
3 Author: Ricardo Rocha
4 Comments: Tries module for ILP
5 version: $ID$
6*********************************/
7
8
9
10/* -------------------------- */
11/* Includes */
12/* -------------------------- */
13
14#include <YapInterface.h>
15#include <string.h>
16#include <stdio.h>
17#include "core_tries.h"
18#include "base_itries.h"
19
20
21
22/* -------------------------- */
23/* Procedures */
24/* -------------------------- */
25
26void init_itries(void);
27static YAP_Bool p_itrie_open(void);
28static YAP_Bool p_itrie_close(void);
29static YAP_Bool p_itrie_close_all(void);
30static YAP_Bool p_itrie_mode(void);
31static YAP_Bool p_itrie_timestamp(void);
32static YAP_Bool p_itrie_put_entry(void);
33static YAP_Bool p_itrie_update_entry(void);
34static YAP_Bool p_itrie_check_entry(void);
35static YAP_Bool p_itrie_get_entry(void);
36static YAP_Bool p_itrie_get_data(void);
37static YAP_Bool p_itrie_traverse_init(void);
38static YAP_Bool p_itrie_traverse_cont(void);
39static YAP_Bool p_itrie_remove_entry(void);
40static YAP_Bool p_itrie_remove_subtree(void);
41static YAP_Bool p_itrie_add(void);
42static YAP_Bool p_itrie_subtract(void);
43static YAP_Bool p_itrie_join(void);
44static YAP_Bool p_itrie_intersect(void);
45static YAP_Bool p_itrie_count_join(void);
46static YAP_Bool p_itrie_count_intersect(void);
47static YAP_Bool p_itrie_save(void);
48static YAP_Bool p_itrie_save_as_trie(void);
49static YAP_Bool p_itrie_load(void);
50static YAP_Bool p_itrie_save2stream(void);
51static YAP_Bool p_itrie_loadFromStream(void);
52static YAP_Bool p_itrie_stats(void);
53static YAP_Bool p_itrie_max_stats(void);
54static YAP_Bool p_itrie_usage(void);
55static YAP_Bool p_itrie_print(void);
56
57
58
59/* -------------------------- */
60/* Module Init Procedure */
61/* -------------------------- */
62
63void init_itries(void) {
64 itrie_init_module();
65
66 YAP_UserCPredicate("itrie_open", p_itrie_open, 1);
67 YAP_UserCPredicate("itrie_close", p_itrie_close, 1);
68 YAP_UserCPredicate("itrie_close_all", p_itrie_close_all, 0);
69 YAP_UserCPredicate("itrie_mode", p_itrie_mode, 2);
70 YAP_UserCPredicate("itrie_timestamp", p_itrie_timestamp, 2);
71 YAP_UserCPredicate("itrie_put_entry", p_itrie_put_entry, 2);
72 YAP_UserCPredicate("itrie_update_entry", p_itrie_update_entry, 2);
73 YAP_UserCPredicate("itrie_check_entry", p_itrie_check_entry, 3);
74 YAP_UserCPredicate("itrie_get_entry", p_itrie_get_entry, 2);
75 YAP_UserCPredicate("itrie_get_data", p_itrie_get_data, 2);
76 YAP_UserBackCPredicate("itrie_traverse", p_itrie_traverse_init, p_itrie_traverse_cont, 2, 0);
77 YAP_UserCPredicate("itrie_remove_entry", p_itrie_remove_entry, 1);
78 YAP_UserCPredicate("itrie_remove_subtree", p_itrie_remove_subtree, 1);
79 YAP_UserCPredicate("itrie_add", p_itrie_add, 2);
80 YAP_UserCPredicate("itrie_subtract", p_itrie_subtract, 2);
81 YAP_UserCPredicate("itrie_join", p_itrie_join, 2);
82 YAP_UserCPredicate("itrie_intersect", p_itrie_intersect, 2);
83 YAP_UserCPredicate("itrie_count_join", p_itrie_count_join, 3);
84 YAP_UserCPredicate("itrie_count_intersect", p_itrie_count_intersect, 3);
85 YAP_UserCPredicate("itrie_save", p_itrie_save, 2);
86 YAP_UserCPredicate("itrie_save_as_trie", p_itrie_save_as_trie, 2);
87 YAP_UserCPredicate("itrie_load", p_itrie_load, 2);
88 YAP_UserCPredicate("itrie_save2stream", p_itrie_save2stream, 2);
89 YAP_UserCPredicate("itrie_loadFromstream", p_itrie_loadFromStream, 2);
90 YAP_UserCPredicate("itrie_stats", p_itrie_stats, 4);
91 YAP_UserCPredicate("itrie_max_stats", p_itrie_max_stats, 4);
92 YAP_UserCPredicate("itrie_usage", p_itrie_usage, 4);
93 YAP_UserCPredicate("itrie_print", p_itrie_print, 1);
94 return;
95}
96
97
98
99/* -------------------------- */
100/* Local Procedures */
101/* -------------------------- */
102
103/* itrie_open(-Itrie) */
104#define arg_itrie YAP_ARG1
105static YAP_Bool p_itrie_open(void) {
106 TrEntry itrie;
107
108 /* check arg */
109 if (!YAP_IsVarTerm(arg_itrie))
110 return FALSE;
111
112 /* open itrie */
113 itrie = itrie_open();
114 return YAP_Unify(arg_itrie, YAP_MkIntTerm((YAP_Int) itrie));
115}
116#undef arg_itrie
117
118
119/* itrie_close(+Itrie) */
120#define arg_itrie YAP_ARG1
121static YAP_Bool p_itrie_close(void) {
122 /* check arg */
123 if (!YAP_IsIntTerm(arg_itrie))
124 return FALSE;
125
126 /* close itrie */
127 itrie_close((TrEntry) YAP_IntOfTerm(arg_itrie));
128 return TRUE;
129}
130#undef arg_itrie
131
132
133/* itrie_close_all() */
134static YAP_Bool p_itrie_close_all(void) {
135 itrie_close_all();
136 return TRUE;
137}
138
139
140/* itrie_mode(+Itrie,?Mode) */
141#define arg_itrie YAP_ARG1
142#define arg_mode YAP_ARG2
143static YAP_Bool p_itrie_mode(void) {
144 YAP_Term mode_term;
145 const char *mode_str;
146 YAP_Int mode;
147
148 /* check arg */
149 if (!YAP_IsIntTerm(arg_itrie))
150 return FALSE;
151
152 /* get mode */
153 if (YAP_IsVarTerm(arg_mode)) {
154 mode = itrie_get_mode((TrEntry) YAP_IntOfTerm(arg_itrie));
155 if (mode == ITRIES_MODE_INC_POS)
156 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("inc_pos"));
157 else if (mode == ITRIES_MODE_DEC_POS)
158 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("dec_pos"));
159 else if (mode == ITRIES_MODE_INC_NEG)
160 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("inc_neg"));
161 else if (mode == ITRIES_MODE_DEC_NEG)
162 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("dec_neg"));
163 else if (mode == ITRIES_MODE_NONE)
164 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("none"));
165 else
166 return FALSE;
167 return YAP_Unify(arg_mode, mode_term);
168 }
169
170 /* set mode */
171 mode_str = YAP_AtomName(YAP_AtomOfTerm(arg_mode));
172 if (!strcmp(mode_str, "inc_pos"))
173 mode = ITRIES_MODE_INC_POS;
174 else if (!strcmp(mode_str, "dec_pos"))
175 mode = ITRIES_MODE_DEC_POS;
176 else if (!strcmp(mode_str, "inc_neg"))
177 mode = ITRIES_MODE_INC_NEG;
178 else if (!strcmp(mode_str, "dec_neg"))
179 mode = ITRIES_MODE_DEC_NEG;
180 else if (!strcmp(mode_str, "none"))
181 mode = ITRIES_MODE_NONE;
182 else
183 return FALSE;
184 itrie_set_mode((TrEntry) YAP_IntOfTerm(arg_itrie), mode);
185 return TRUE;
186}
187#undef arg_itrie
188#undef arg_mode
189
190
191/* itrie_timestamp(+Itrie,?Time) */
192#define arg_itrie YAP_ARG1
193#define arg_time YAP_ARG2
194static YAP_Bool p_itrie_timestamp(void) {
195 YAP_Int time;
196
197 /* check arg */
198 if (!YAP_IsIntTerm(arg_itrie))
199 return FALSE;
200
201 /* get mode */
202 if (YAP_IsVarTerm(arg_time)) {
203 time = itrie_get_timestamp((TrEntry) YAP_IntOfTerm(arg_itrie));
204 return YAP_Unify(arg_time, YAP_MkIntTerm(time));
205 }
206
207 /* set mode */
208 if (YAP_IsIntTerm(arg_time)) {
209 time = YAP_IntOfTerm(arg_time);
210 itrie_set_timestamp((TrEntry) YAP_IntOfTerm(arg_itrie), time);
211 return TRUE;
212 }
213
214 return FALSE;
215}
216#undef arg_itrie
217#undef arg_time
218
219
220/* itrie_put_entry(+Itrie,+Entry) */
221#define arg_itrie YAP_ARG1
222#define arg_entry YAP_ARG2
223static YAP_Bool p_itrie_put_entry(void) {
224 /* check arg */
225 if (!YAP_IsIntTerm(arg_itrie))
226 return FALSE;
227
228 /* put entry */
229 itrie_put_entry((TrEntry) YAP_IntOfTerm(arg_itrie), arg_entry);
230 return TRUE;
231}
232#undef arg_itrie
233#undef arg_entry
234
235
236/* itrie_update_entry(+Itrie,+Entry) */
237#define arg_itrie YAP_ARG1
238#define arg_entry YAP_ARG2
239static YAP_Bool p_itrie_update_entry(void) {
240 /* check arg */
241 if (!YAP_IsIntTerm(arg_itrie))
242 return FALSE;
243
244 /* update entry */
245 itrie_update_entry((TrEntry) YAP_IntOfTerm(arg_itrie), arg_entry);
246 return TRUE;
247}
248#undef arg_itrie
249#undef arg_entry
250
251
252/* itrie_check_entry(+Itrie,+Entry,-Ref) */
253#define arg_itrie YAP_ARG1
254#define arg_entry YAP_ARG2
255#define arg_ref YAP_ARG3
256static YAP_Bool p_itrie_check_entry(void) {
257 TrData data;
258
259 /* check arg */
260 if (!YAP_IsIntTerm(arg_itrie))
261 return FALSE;
262
263 /* check entry */
264 if (!(data = itrie_check_entry((TrEntry) YAP_IntOfTerm(arg_itrie), arg_entry)))
265 return FALSE;
266 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
267}
268#undef arg_itrie
269#undef arg_entry
270#undef arg_ref
271
272
273/* itrie_get_entry(+Ref,-Entry) */
274#define arg_ref YAP_ARG1
275#define arg_entry YAP_ARG2
276static YAP_Bool p_itrie_get_entry(void) {
277 YAP_Term entry;
278
279 /* check arg */
280 if (!YAP_IsIntTerm(arg_ref))
281 return FALSE;
282
283 /* get entry */
284 entry = itrie_get_entry((TrData) YAP_IntOfTerm(arg_ref));
285 return YAP_Unify(arg_entry, entry);
286}
287#undef arg_ref
288#undef arg_entry
289
290
291/* itrie_get_data(+Ref,-Data) */
292#define arg_ref YAP_ARG1
293#define arg_data YAP_ARG2
294static YAP_Bool p_itrie_get_data(void) {
295 YAP_Term list;
296 YAP_Term item;
297 YAP_Functor f;
298 YAP_Int pos, neg, time;
299
300 /* check arg */
301 if (!YAP_IsIntTerm(arg_ref))
302 return FALSE;
303
304 /* get data */
305 itrie_get_data((TrData) YAP_IntOfTerm(arg_ref), &pos, &neg, &time);
306 list = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
307 f = YAP_MkFunctor(YAP_LookupAtom("timestamp"), 1);
308 item = YAP_MkIntTerm(time);
309 item = YAP_MkApplTerm(f, 1, &item);
310 list = YAP_MkPairTerm(item, list);
311 f = YAP_MkFunctor(YAP_LookupAtom("neg"), 1);
312 item = YAP_MkIntTerm(neg);
313 item = YAP_MkApplTerm(f, 1, &item);
314 list = YAP_MkPairTerm(item, list);
315 f = YAP_MkFunctor(YAP_LookupAtom("pos"), 1);
316 item = YAP_MkIntTerm(pos);
317 item = YAP_MkApplTerm(f, 1, &item);
318 list = YAP_MkPairTerm(item, list);
319 return YAP_Unify(arg_data, list);
320}
321#undef arg_ref
322#undef arg_data
323
324
325/* itrie_traverse(+Itrie,-Ref) */
326#define arg_itrie YAP_ARG1
327#define arg_ref YAP_ARG2
328static YAP_Bool p_itrie_traverse_init(void) {
329 TrData data;
330
331 /* check arg */
332 if (!YAP_IsIntTerm(arg_itrie))
333 return FALSE;
334
335 /* traverse itrie */
336 if (!(data = itrie_traverse_init((TrEntry) YAP_IntOfTerm(arg_itrie)))) {
337 YAP_cut_fail();
338 return FALSE;
339 }
340 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
341}
342#undef arg_itrie
343#undef arg_ref
344
345
346/* itrie_traverse(+Itrie,-Ref) */
347#define arg_itrie YAP_ARG1
348#define arg_ref YAP_ARG2
349static YAP_Bool p_itrie_traverse_cont(void) {
350 TrData data;
351
352 /* traverse itrie */
353 if (!(data = itrie_traverse_cont((TrEntry) YAP_IntOfTerm(arg_itrie)))) {
354 YAP_cut_fail();
355 return FALSE;
356 }
357 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
358}
359#undef arg_itrie
360#undef arg_ref
361
362
363/* itrie_remove_entry(+Ref) */
364#define arg_ref YAP_ARG1
365static YAP_Bool p_itrie_remove_entry(void) {
366 /* check arg */
367 if (!YAP_IsIntTerm(arg_ref))
368 return FALSE;
369
370 /* remove entry */
371 itrie_remove_entry((TrData) YAP_IntOfTerm(arg_ref));
372 return TRUE;
373}
374#undef arg_ref
375
376
377/* itrie_remove_subtree(+Ref) */
378#define arg_ref YAP_ARG1
379static YAP_Bool p_itrie_remove_subtree(void) {
380 /* check arg */
381 if (!YAP_IsIntTerm(arg_ref))
382 return FALSE;
383
384 /* remove subtree */
385 itrie_remove_subtree((TrData) YAP_IntOfTerm(arg_ref));
386 return TRUE;
387}
388#undef arg_ref
389
390
391/* itrie_add(+ItrieDest,+ItrieSource) */
392#define arg_itrie_dest YAP_ARG1
393#define arg_itrie_source YAP_ARG2
394static YAP_Bool p_itrie_add(void) {
395 /* check args */
396 if (!YAP_IsIntTerm(arg_itrie_dest))
397 return FALSE;
398 if (!YAP_IsIntTerm(arg_itrie_source))
399 return FALSE;
400
401 /* add itrie */
402 itrie_add((TrEntry) YAP_IntOfTerm(arg_itrie_dest), (TrEntry) YAP_IntOfTerm(arg_itrie_source));
403 return TRUE;
404}
405#undef arg_itrie_dest
406#undef arg_itrie_source
407
408
409/* itrie_subtract(+ItrieDest,+ItrieSource) */
410#define arg_itrie_dest YAP_ARG1
411#define arg_itrie_source YAP_ARG2
412static YAP_Bool p_itrie_subtract(void) {
413 /* check args */
414 if (!YAP_IsIntTerm(arg_itrie_dest))
415 return FALSE;
416 if (!YAP_IsIntTerm(arg_itrie_source))
417 return FALSE;
418
419 /* subtract itrie */
420 itrie_subtract((TrEntry) YAP_IntOfTerm(arg_itrie_dest), (TrEntry) YAP_IntOfTerm(arg_itrie_source));
421 return TRUE;
422}
423#undef arg_itrie_dest
424#undef arg_itrie_source
425
426
427/* itrie_join(+ItrieDest,+ItrieSource) */
428#define arg_itrie_dest YAP_ARG1
429#define arg_itrie_source YAP_ARG2
430static YAP_Bool p_itrie_join(void) {
431 /* check args */
432 if (!YAP_IsIntTerm(arg_itrie_dest))
433 return FALSE;
434 if (!YAP_IsIntTerm(arg_itrie_source))
435 return FALSE;
436
437 /* join itrie */
438 itrie_join((TrEntry) YAP_IntOfTerm(arg_itrie_dest), (TrEntry) YAP_IntOfTerm(arg_itrie_source));
439 return TRUE;
440}
441#undef arg_itrie_dest
442#undef arg_itrie_source
443
444
445/* itrie_intersect(+ItrieDest,+ItrieSource) */
446#define arg_itrie_dest YAP_ARG1
447#define arg_itrie_source YAP_ARG2
448static YAP_Bool p_itrie_intersect(void) {
449 /* check args */
450 if (!YAP_IsIntTerm(arg_itrie_dest))
451 return FALSE;
452 if (!YAP_IsIntTerm(arg_itrie_source))
453 return FALSE;
454
455 /* intersect itrie */
456 itrie_intersect((TrEntry) YAP_IntOfTerm(arg_itrie_dest), (TrEntry) YAP_IntOfTerm(arg_itrie_source));
457 return TRUE;
458}
459#undef arg_itrie_dest
460#undef arg_itrie_source
461
462
463/* itrie_count_join(+Itrie1,+Itrie2,-Entries) */
464#define arg_itrie1 YAP_ARG1
465#define arg_itrie2 YAP_ARG2
466#define arg_entries YAP_ARG3
467static YAP_Bool p_itrie_count_join(void) {
468 YAP_Int entries;
469
470 /* check args */
471 if (!YAP_IsIntTerm(arg_itrie1))
472 return FALSE;
473 if (!YAP_IsIntTerm(arg_itrie2))
474 return FALSE;
475
476 /* count join itrie */
477 entries = itrie_count_join((TrEntry) YAP_IntOfTerm(arg_itrie1), (TrEntry) YAP_IntOfTerm(arg_itrie2));
478 return YAP_Unify(arg_entries, YAP_MkIntTerm(entries));
479}
480#undef arg_itrie1
481#undef arg_itrie2
482#undef arg_entries
483
484
485/* itrie_count_intersect(+Itrie1,+Itrie2,-Entries) */
486#define arg_itrie1 YAP_ARG1
487#define arg_itrie2 YAP_ARG2
488#define arg_entries YAP_ARG3
489static YAP_Bool p_itrie_count_intersect(void) {
490 YAP_Int entries;
491
492 /* check args */
493 if (!YAP_IsIntTerm(arg_itrie1))
494 return FALSE;
495 if (!YAP_IsIntTerm(arg_itrie2))
496 return FALSE;
497
498 /* count intersect itrie */
499 entries = itrie_count_intersect((TrEntry) YAP_IntOfTerm(arg_itrie1), (TrEntry) YAP_IntOfTerm(arg_itrie2));
500 return YAP_Unify(arg_entries, YAP_MkIntTerm(entries));
501}
502#undef arg_itrie1
503#undef arg_itrie2
504#undef arg_entries
505
506
507/* itrie_save(+Itrie,+FileName) */
508#define arg_itrie YAP_ARG1
509#define arg_file YAP_ARG2
510static YAP_Bool p_itrie_save(void) {
511 const char *file_str;
512 FILE *file;
513
514 /* check args */
515 if (!YAP_IsIntTerm(arg_itrie))
516 return FALSE;
517 if (!YAP_IsAtomTerm(arg_file))
518 return FALSE;
519
520 /* open file */
521 file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file));
522 if (!(file = fopen(file_str, "w")))
523 return FALSE;
524
525 /* save itrie and close file */
526 itrie_save((TrEntry) YAP_IntOfTerm(arg_itrie), file);
527 if (fclose(file))
528 return FALSE;
529 return TRUE;
530}
531#undef arg_itrie
532#undef arg_file
533
534
535/* itrie_save_as_trie(+Itrie,+FileName) */
536#define arg_itrie YAP_ARG1
537#define arg_file YAP_ARG2
538static YAP_Bool p_itrie_save_as_trie(void) {
539 const char *file_str;
540 FILE *file;
541
542 /* check args */
543 if (!YAP_IsIntTerm(arg_itrie))
544 return FALSE;
545 if (!YAP_IsAtomTerm(arg_file))
546 return FALSE;
547
548 /* open file */
549 file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file));
550 if (!(file = fopen(file_str, "w")))
551 return FALSE;
552
553 /* save itrie as trie and close file */
554 itrie_save_as_trie((TrEntry) YAP_IntOfTerm(arg_itrie), file);
555 if (fclose(file))
556 return FALSE;
557 return TRUE;
558}
559#undef arg_itrie
560#undef arg_file
561
562
563/* itrie_load(-Itrie,+FileName) */
564#define arg_itrie YAP_ARG1
565#define arg_file YAP_ARG2
566static YAP_Bool p_itrie_load(void) {
567 TrEntry itrie;
568 const char *file_str;
569 FILE *file;
570
571 /* check args */
572 if (!YAP_IsVarTerm(arg_itrie))
573 return FALSE;
574 if (!YAP_IsAtomTerm(arg_file))
575 return FALSE;
576
577 /* open file */
578 file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file));
579 if (!(file = fopen(file_str, "r")))
580 return FALSE;
581
582 /* load itrie and close file */
583 if (!(itrie = itrie_load(file)))
584 return FALSE;
585 if (fclose(file))
586 return FALSE;
587 return YAP_Unify(arg_itrie, YAP_MkIntTerm((YAP_Int) itrie));
588}
589#undef arg_itrie
590#undef arg_file
591
592
593/* itrie_save2stream(+Itrie,+Stream) */
594#define arg_itrie YAP_ARG1
595#define arg_stream YAP_ARG2
596static YAP_Bool p_itrie_save2stream(void) {
597 FILE *file;
598
599 /* check args */
600 if (!YAP_IsIntTerm(arg_itrie))
601 return FALSE;
602 if ((file = (FILE*) YAP_FileDescriptorFromStream(arg_stream)) == NULL)
603 return FALSE;
604
605 /* save itrie */
606 itrie_save((TrEntry) YAP_IntOfTerm(arg_itrie), file);
607 return TRUE;
608}
609#undef arg_itrie
610#undef arg_stream
611
612
613/* itrie_loadFromStream(-Itrie,+Stream) */
614#define arg_itrie YAP_ARG1
615#define arg_stream YAP_ARG2
616static YAP_Bool p_itrie_loadFromStream(void) {
617 TrEntry itrie;
618 FILE *file;
619
620 /* check args */
621 if (!YAP_IsVarTerm(arg_itrie))
622 return FALSE;
623 if (!(file = (FILE*) YAP_FileDescriptorFromStream(arg_stream)))
624 return FALSE;
625
626 /* load itrie */
627 if (!(itrie = itrie_load(file)))
628 return FALSE;
629 return YAP_Unify(arg_itrie, YAP_MkIntTerm((YAP_Int) itrie));
630}
631#undef arg_itrie
632#undef arg_stream
633
634
635/* itrie_stats(-Memory,-Tries,-Entries,-Nodes) */
636#define arg_memory YAP_ARG1
637#define arg_tries YAP_ARG2
638#define arg_entries YAP_ARG3
639#define arg_nodes YAP_ARG4
640static YAP_Bool p_itrie_stats(void) {
641 YAP_Int memory, tries, entries, nodes;
642
643 /* get stats */
644 itrie_stats(&memory, &tries, &entries, &nodes);
645 if (!YAP_Unify(arg_memory, YAP_MkIntTerm(memory)))
646 return FALSE;
647 if (!YAP_Unify(arg_tries, YAP_MkIntTerm(tries)))
648 return FALSE;
649 if (!YAP_Unify(arg_entries, YAP_MkIntTerm(entries)))
650 return FALSE;
651 if (!YAP_Unify(arg_nodes, YAP_MkIntTerm(nodes)))
652 return FALSE;
653 return TRUE;
654}
655#undef arg_memory
656#undef arg_tries
657#undef arg_entries
658#undef arg_nodes
659
660
661/* itrie_max_stats(-Memory,-Tries,-Entries,-Nodes) */
662#define arg_memory YAP_ARG1
663#define arg_tries YAP_ARG2
664#define arg_entries YAP_ARG3
665#define arg_nodes YAP_ARG4
666static YAP_Bool p_itrie_max_stats(void) {
667 YAP_Int memory, tries, entries, nodes;
668
669 /* get stats */
670 itrie_max_stats(&memory, &tries, &entries, &nodes);
671 if (!YAP_Unify(arg_memory, YAP_MkIntTerm(memory)))
672 return FALSE;
673 if (!YAP_Unify(arg_tries, YAP_MkIntTerm(tries)))
674 return FALSE;
675 if (!YAP_Unify(arg_entries, YAP_MkIntTerm(entries)))
676 return FALSE;
677 if (!YAP_Unify(arg_nodes, YAP_MkIntTerm(nodes)))
678 return FALSE;
679 return TRUE;
680}
681#undef arg_memory
682#undef arg_tries
683#undef arg_entries
684#undef arg_nodes
685
686
687/* itrie_usage(+Itrie,-Entries,-Nodes,-VirtualNodes) */
688#define arg_itrie YAP_ARG1
689#define arg_entries YAP_ARG2
690#define arg_nodes YAP_ARG3
691#define arg_virtualnodes YAP_ARG4
692static YAP_Bool p_itrie_usage(void) {
693 YAP_Int entries, nodes, virtualnodes;
694
695 /* check arg */
696 if (!YAP_IsIntTerm(arg_itrie))
697 return FALSE;
698
699 /* get itrie usage */
700 itrie_usage((TrEntry) YAP_IntOfTerm(arg_itrie), &entries, &nodes, &virtualnodes);
701 if (!YAP_Unify(arg_entries, YAP_MkIntTerm(entries)))
702 return FALSE;
703 if (!YAP_Unify(arg_nodes, YAP_MkIntTerm(nodes)))
704 return FALSE;
705 if (!YAP_Unify(arg_virtualnodes, YAP_MkIntTerm(virtualnodes)))
706 return FALSE;
707 return TRUE;
708}
709#undef arg_itrie
710#undef arg_entries
711#undef arg_nodes
712#undef arg_virtualnodes
713
714
715/* itrie_print(+Itrie) */
716#define arg_itrie YAP_ARG1
717static YAP_Bool p_itrie_print(void) {
718 /* check arg */
719 if (!YAP_IsIntTerm(arg_itrie))
720 return FALSE;
721
722 /* print itrie */
723 itrie_print((TrEntry) YAP_IntOfTerm(arg_itrie));
724 return TRUE;
725}
726#undef arg_itrie
itrie_data
Definition: base_itries.h:50
itrie_entry
Definition: base_itries.h:27