YAP 7.1.0
tries.c
Go to the documentation of this file.
1/****************************************
2 File: tries.c
3 Author: Ricardo Rocha
4 Comments: Tries module for Yap Prolog
5 version: $ID$
6****************************************/
19/* -------------------------- */
20/* Includes */
21/* -------------------------- */
22
23#include <YapInterface.h>
24#include <string.h>
25#include <stdio.h>
26#include "core_tries.h"
27#include "base_tries.h"
28
29
30/* -------------------------- */
31/* Structures */
32/* -------------------------- */
33
34typedef struct {
35 YAP_Term value;
36} db_trie_opt_level;
37
38
39/* -------------------------- */
40/* Procedures */
41/* -------------------------- */
42
43O_API void init_tries(void);
44static YAP_Bool p_trie_open(void);
45static YAP_Bool p_trie_close(void);
46static YAP_Bool p_trie_close_all(void);
47static YAP_Bool p_trie_mode(void);
48static YAP_Bool p_trie_put_entry(void);
49static YAP_Bool p_trie_check_entry(void);
50static YAP_Bool p_trie_get_entry(void);
51static YAP_Bool p_trie_get_first_entry(void);
52static YAP_Bool p_trie_get_last_entry(void);
53static YAP_Bool p_trie_traverse_init(void);
54static YAP_Bool p_trie_traverse_cont(void);
55static YAP_Bool p_trie_remove_entry(void);
56static YAP_Bool p_trie_remove_subtree(void);
57static YAP_Bool p_trie_join(void);
58static YAP_Bool p_trie_intersect(void);
59static YAP_Bool p_trie_count_join(void);
60static YAP_Bool p_trie_count_intersect(void);
61static YAP_Bool p_trie_save(void);
62static YAP_Bool p_trie_load(void);
63static YAP_Bool p_trie_stats(void);
64static YAP_Bool p_trie_max_stats(void);
65static YAP_Bool p_trie_usage(void);
66static YAP_Bool p_trie_print(void);
67
68static YAP_Bool p_trie_traverse_mode(void);
69static YAP_Bool p_trie_disable_hash(void);
70static YAP_Bool p_trie_enable_hash(void);
71static YAP_Bool p_trie_traverse_first(void);
72static YAP_Bool p_trie_traverse_next(void);
73
74static YAP_Bool p_trie_to_list(void);
75
76/* dbtries support */
77static YAP_Bool p_trie_depth_breadth(void);
78static YAP_Bool p_trie_get_depth_breadth_reduction_current_data(void);
79static YAP_Bool p_trie_get_db_opt_level_count_init(void);
80static YAP_Bool p_trie_get_db_opt_level_count_cont(void);
81static YAP_Bool p_trie_replace_nested_trie(void);
82static YAP_Bool p_trie_db_opt_min_prefix(void);
83
84/* backwards compatibility */
85static YAP_Bool p_open_trie(void);
86static YAP_Bool p_close_trie(void);
87static YAP_Bool p_close_all_tries(void);
88static YAP_Bool p_put_trie_entry(void);
89static YAP_Bool p_get_trie_entry(void);
90static YAP_Bool p_remove_trie_entry(void);
91static YAP_Bool p_print_trie(void);
92
93
94
95/* -------------------------- */
96/* Module Init Procedure */
97/* -------------------------- */
98
99O_API void init_tries(void) {
100 trie_init_module();
101
102 YAP_UserCPredicate("trie_open", p_trie_open, 1);
103 YAP_UserCPredicate("trie_close", p_trie_close, 1);
104 YAP_UserCPredicate("trie_close_all", p_trie_close_all, 0);
105 YAP_UserCPredicate("trie_mode", p_trie_mode, 1);
106 YAP_UserCPredicate("trie_put_entry", p_trie_put_entry, 3);
107 YAP_UserCPredicate("trie_check_entry", p_trie_check_entry, 3);
108 YAP_UserCPredicate("trie_get_entry", p_trie_get_entry, 2);
109 YAP_UserCPredicate("trie_get_first_entry", p_trie_get_first_entry, 2);
110 YAP_UserCPredicate("trie_get_last_entry", p_trie_get_last_entry, 2);
111 YAP_UserBackCPredicate("trie_traverse", p_trie_traverse_init, p_trie_traverse_cont, 3, 0);
112 YAP_UserCPredicate("trie_remove_entry", p_trie_remove_entry, 1);
113 YAP_UserCPredicate("trie_remove_subtree", p_trie_remove_subtree, 1);
114 YAP_UserCPredicate("trie_join", p_trie_join, 2);
115 YAP_UserCPredicate("trie_intersect", p_trie_intersect, 2);
116 YAP_UserCPredicate("trie_count_join", p_trie_count_join, 3);
117 YAP_UserCPredicate("trie_count_intersect", p_trie_count_intersect, 3);
118 YAP_UserCPredicate("trie_save", p_trie_save, 2);
119 YAP_UserCPredicate("trie_load", p_trie_load, 2);
120 YAP_UserCPredicate("trie_usage", p_trie_usage, 4);
121 YAP_UserCPredicate("trie_stats", p_trie_stats, 4);
122 YAP_UserCPredicate("trie_max_stats", p_trie_max_stats, 4);
123 YAP_UserCPredicate("trie_print", p_trie_print, 1);
124
125 YAP_UserCPredicate("trie_traverse_mode", p_trie_traverse_mode, 1);
126 YAP_UserCPredicate("trie_disable_hash", p_trie_disable_hash, 0);
127 YAP_UserCPredicate("trie_enable_hash", p_trie_enable_hash, 0);
128 YAP_UserCPredicate("trie_traverse_first", p_trie_traverse_first, 2);
129 YAP_UserCPredicate("trie_traverse_next", p_trie_traverse_next, 2);
130
131 YAP_UserCPredicate("trie_to_list", p_trie_to_list, 2);
132
133 /* dbtries support */
134 YAP_UserCPredicate("trie_depth_breadth", p_trie_depth_breadth, 6);
135 YAP_UserCPredicate("trie_get_depth_breadth_reduction_entry", p_trie_get_depth_breadth_reduction_current_data, 1);
136 YAP_UserBackCPredicate("trie_get_depth_breadth_reduction_opt_level_count", p_trie_get_db_opt_level_count_init, p_trie_get_db_opt_level_count_cont, 2, sizeof(db_trie_opt_level));
137 YAP_UserCPredicate("trie_replace_nested_trie", p_trie_replace_nested_trie, 3);
138 YAP_UserCPredicate("trie_db_opt_min_prefix", p_trie_db_opt_min_prefix, 1);
139
140 /* backwards compatibility */
141 YAP_UserCPredicate("open_trie", p_open_trie, 1);
142 YAP_UserCPredicate("close_trie", p_close_trie, 1);
143 YAP_UserCPredicate("close_all_tries", p_close_all_tries, 0);
144 YAP_UserCPredicate("put_trie_entry", p_put_trie_entry, 4);
145 YAP_UserCPredicate("get_trie_entry", p_get_trie_entry, 3);
146 YAP_UserCPredicate("remove_trie_entry", p_remove_trie_entry, 1);
147 YAP_UserCPredicate("print_trie", p_print_trie, 1);
148 return;
149}
150
151
152
153/* --------------------------------- */
154/* Backwards Compatibility */
155/* --------------------------------- */
156
157/* open_trie(-Trie) */
158static YAP_Bool p_open_trie(void) {
159 return p_trie_open();
160}
161
162
163/* close_trie(+Trie) */
164static YAP_Bool p_close_trie(void) {
165 return p_trie_close();
166}
167
168
169/* close_all_tries() */
170static YAP_Bool p_close_all_tries(void) {
171 return p_trie_close_all();
172}
173
174
175/* put_trie_entry(+Mode,+Trie,+Entry,-Ref) */
185#define arg_mode YAP_ARG1
186#define arg_trie YAP_ARG2
187#define arg_entry YAP_ARG3
188#define arg_ref YAP_ARG4
189static YAP_Bool p_put_trie_entry(void) {
190 TrData data;
191 const char *mode_str;
192 YAP_Int mode, current_mode;
193
194 /* check args */
195 mode_str = YAP_AtomName(YAP_AtomOfTerm(arg_mode));
196 if (!strcmp(mode_str, "std"))
197 mode = TRIE_MODE_STANDARD;
198 else if (!strcmp(mode_str, "rev"))
199 mode = TRIE_MODE_REVERSE;
200 else
201 return FALSE;
202 if (!YAP_IsIntTerm(arg_trie))
203 return FALSE;
204
205 /* put trie entry */
206 current_mode = trie_get_mode();
207 trie_set_mode(mode);
208 data = trie_put_entry((TrEntry) YAP_IntOfTerm(arg_trie), arg_entry);
209 trie_set_mode(current_mode);
210 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
211}
212#undef arg_mode
213#undef arg_trie
214#undef arg_entry
215#undef arg_ref
216
217
218/* get_trie_entry(+Mode,+Ref,-Entry) */
226#define arg_mode YAP_ARG1
227#define arg_ref YAP_ARG2
228#define arg_entry YAP_ARG3
229static YAP_Bool p_get_trie_entry(void) {
230 YAP_Term entry;
231 const char *mode_str;
232 YAP_Int mode, current_mode;
233
234 /* check args */
235 mode_str = YAP_AtomName(YAP_AtomOfTerm(arg_mode));
236 if (!strcmp(mode_str, "std"))
237 mode = TRIE_MODE_STANDARD;
238 else if (!strcmp(mode_str, "rev"))
239 mode = TRIE_MODE_REVERSE;
240 else
241 return FALSE;
242 if (!YAP_IsIntTerm(arg_ref))
243 return FALSE;
244
245 /* get trie entry */
246 current_mode = trie_get_mode();
247 trie_set_mode(mode);
248 entry = trie_get_entry((TrData) YAP_IntOfTerm(arg_ref));
249 trie_set_mode(current_mode);
250 return YAP_Unify(arg_entry, entry);
251}
252#undef arg_mode
253#undef arg_ref
254#undef arg_entry
255
256/* remove_trie_entry(+Ref) */
257static YAP_Bool p_remove_trie_entry(void) {
258 return p_trie_remove_entry();
259}
260
261
262/* print_trie(+Trie) */
263static YAP_Bool p_print_trie(void) {
264 return p_trie_print();
265}
266
267
268
269/* -------------------------- */
270/* Local Procedures */
271/* -------------------------- */
272
273/* trie_open(-Trie) */
274#define arg_trie YAP_ARG1
275static YAP_Bool p_trie_open(void) {
276 TrEntry trie;
277
278 /* check arg */
279 if (!YAP_IsVarTerm(arg_trie))
280 return FALSE;
281
282 /* open trie */
283 trie = trie_open();
284 return YAP_Unify(arg_trie, YAP_MkIntTerm((YAP_Int) trie));
285}
286#undef arg_trie
287
288
289/* trie_close(+Trie) */
298#define arg_trie YAP_ARG1
299static YAP_Bool p_trie_close(void) {
300 /* check arg */
301 if (!YAP_IsIntTerm(arg_trie))
302 return FALSE;
303
304 /* close trie */
305 trie_close((TrEntry) YAP_IntOfTerm(arg_trie));
306 return TRUE;
307}
308#undef arg_trie
309
310
311/* trie_close_all() */
320static YAP_Bool p_trie_close_all(void) {
321 trie_close_all();
322 return TRUE;
323}
324
325
326/* trie_mode(?Mode) */
336#define arg_mode YAP_ARG1
337static YAP_Bool p_trie_mode(void) {
338 YAP_Term mode_term;
339 const char *mode_str;
340 YAP_Int mode;
341
342 /* get mode */
343 if (YAP_IsVarTerm(arg_mode)) {
344 mode = trie_get_mode();
345 if (mode == TRIE_MODE_STANDARD)
346 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("std"));
347 else if (mode == TRIE_MODE_REVERSE)
348 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("rev"));
349 else
350 return FALSE;
351 return YAP_Unify(arg_mode, mode_term);
352 }
353
354 /* set mode */
355 mode_str = YAP_AtomName(YAP_AtomOfTerm(arg_mode));
356 if (!strcmp(mode_str, "std"))
357 mode = TRIE_MODE_STANDARD;
358 else if (!strcmp(mode_str, "rev"))
359 mode = TRIE_MODE_REVERSE;
360 else
361 return FALSE;
362 trie_set_mode(mode);
363 return TRUE;
364}
365#undef arg_mode
366
367
368/* trie_put_entry(+Trie,+Entry,-Ref) */
369#define arg_trie YAP_ARG1
370#define arg_entry YAP_ARG2
371#define arg_ref YAP_ARG3
372static YAP_Bool p_trie_put_entry(void) {
373 TrData data;
374
375 /* check args */
376 if (!YAP_IsIntTerm(arg_trie))
377 return FALSE;
378
379 /* put trie entry */
380 data = trie_put_entry((TrEntry) YAP_IntOfTerm(arg_trie), arg_entry);
381 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
382}
383#undef arg_trie
384#undef arg_entry
385#undef arg_ref
386
387
388/* trie_check_entry(+Trie,+Entry,-Ref) */
398#define arg_trie YAP_ARG1
399#define arg_entry YAP_ARG2
400#define arg_ref YAP_ARG3
401static YAP_Bool p_trie_check_entry(void) {
402 TrData data;
403
404 /* check args */
405 if (!YAP_IsIntTerm(arg_trie))
406 return FALSE;
407
408 /* check trie entry */
409 if (!(data = trie_check_entry((TrEntry) YAP_IntOfTerm(arg_trie), arg_entry)))
410 return FALSE;
411 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
412}
413#undef arg_trie
414#undef arg_entry
415#undef arg_ref
416
417
418/* trie_get_entry(+Ref,-Entry) */
419#define arg_ref YAP_ARG1
420#define arg_entry YAP_ARG2
421static YAP_Bool p_trie_get_entry(void) {
422 YAP_Term entry;
423
424 /* check args */
425 if (!YAP_IsIntTerm(arg_ref))
426 return FALSE;
427
428 /* get trie entry */
429 entry = trie_get_entry((TrData) YAP_IntOfTerm(arg_ref));
430 return YAP_Unify(arg_entry, entry);
431}
432#undef arg_ref
433#undef arg_entry
434
435
436/* trie_get_first_entry(+Trie,-Ref) */
437#define arg_trie YAP_ARG1
438#define arg_ref YAP_ARG2
439static YAP_Bool p_trie_get_first_entry(void) {
440 TrData data;
441
442 /* check args */
443 if (!YAP_IsIntTerm(arg_trie))
444 return FALSE;
445
446 /* get first trie entry */
447 if (!(data = trie_get_first_entry((TrEntry) YAP_IntOfTerm(arg_trie))))
448 return FALSE;
449 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
450}
451#undef arg_trie
452#undef arg_ref
453
454
455/* trie_get_last_entry(+Trie,-Ref) */
456#define arg_trie YAP_ARG1
457#define arg_ref YAP_ARG2
458static YAP_Bool p_trie_get_last_entry(void) {
459 TrData data;
460
461 /* check args */
462 if (!YAP_IsIntTerm(arg_trie))
463 return FALSE;
464
465 /* get last trie entry */
466 if (!(data = trie_get_last_entry((TrEntry) YAP_IntOfTerm(arg_trie))))
467 return FALSE;
468 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
469}
470#undef arg_trie
471#undef arg_ref
472
473
474/* trie_traverse(+Trie,+FirstRef,-Ref) */
475#define arg_trie YAP_ARG1
476#define arg_init_ref YAP_ARG2
477#define arg_ref YAP_ARG3
478static YAP_Bool p_trie_traverse_init(void) {
479 TrData data;
480
481 /* check args */
482 if (!YAP_IsIntTerm(arg_trie))
483 return FALSE;
484 if (!YAP_IsIntTerm(arg_init_ref))
485 return FALSE;
486
487 /* traverse trie */
488 if (!(data = trie_traverse_init((TrEntry) YAP_IntOfTerm(arg_trie), (TrData) YAP_IntOfTerm(arg_init_ref)))) {
489 YAP_cut_fail();
490 return FALSE;
491 }
492 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
493}
494#undef arg_trie
495#undef arg_init_ref
496#undef arg_ref
497
498
499/* trie_traverse(+Trie,+FirstRef,-Ref) */
500#define arg_trie YAP_ARG1
501#define arg_init_ref YAP_ARG2
502#define arg_ref YAP_ARG3
503static YAP_Bool p_trie_traverse_cont(void) {
504 TrData data;
505
506 /* traverse trie */
507 if (!(data = trie_traverse_cont((TrEntry) YAP_IntOfTerm(arg_trie)))) {
508 YAP_cut_fail();
509 return FALSE;
510 }
511 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
512}
513#undef arg_trie
514#undef arg_init_ref
515#undef arg_ref
516
517
518/* trie_remove_entry(+Ref) */
527#define arg_ref YAP_ARG1
528static YAP_Bool p_trie_remove_entry(void) {
529 /* check arg */
530 if (!YAP_IsIntTerm(arg_ref))
531 return FALSE;
532
533 /* remove trie entry */
534 trie_remove_entry((TrData) YAP_IntOfTerm(arg_ref));
535 return TRUE;
536}
537#undef arg_ref
538
539
540/* trie_remove_subtree(+Ref) */
549#define arg_ref YAP_ARG1
550static YAP_Bool p_trie_remove_subtree(void) {
551 /* check arg */
552 if (!YAP_IsIntTerm(arg_ref))
553 return FALSE;
554
555 /* remove trie subtree */
556 trie_remove_subtree((TrData) YAP_IntOfTerm(arg_ref));
557 return TRUE;
558}
559#undef arg_ref
560
561
562/* trie_join(+TrieDest,+TrieSource) */
563#define arg_trie_dest YAP_ARG1
564#define arg_trie_source YAP_ARG2
565static YAP_Bool p_trie_join(void) {
566 /* check args */
567 if (!YAP_IsIntTerm(arg_trie_dest))
568 return FALSE;
569 if (!YAP_IsIntTerm(arg_trie_source))
570 return FALSE;
571
572 /* join trie */
573 trie_join((TrEntry) YAP_IntOfTerm(arg_trie_dest), (TrEntry) YAP_IntOfTerm(arg_trie_source));
574 return TRUE;
575}
576#undef arg_trie_dest
577#undef arg_trie_source
578
579
580/* trie_intersect(+TrieDest,+TrieSource) */
581#define arg_trie_dest YAP_ARG1
582#define arg_trie_source YAP_ARG2
583static YAP_Bool p_trie_intersect(void) {
584 /* check args */
585 if (!YAP_IsIntTerm(arg_trie_dest))
586 return FALSE;
587 if (!YAP_IsIntTerm(arg_trie_source))
588 return FALSE;
589
590 /* intersect trie */
591 trie_intersect((TrEntry) YAP_IntOfTerm(arg_trie_dest), (TrEntry) YAP_IntOfTerm(arg_trie_source));
592 return TRUE;
593}
594#undef arg_trie_dest
595#undef arg_trie_source
596
597
598/* trie_count_join(+Trie1,+Trie2,-Entries) */
599#define arg_trie1 YAP_ARG1
600#define arg_trie2 YAP_ARG2
601#define arg_entries YAP_ARG3
602static YAP_Bool p_trie_count_join(void) {
603 YAP_Int entries;
604
605 /* check args */
606 if (!YAP_IsIntTerm(arg_trie1))
607 return FALSE;
608 if (!YAP_IsIntTerm(arg_trie2))
609 return FALSE;
610
611 /* count join trie */
612 entries = trie_count_join((TrEntry) YAP_IntOfTerm(arg_trie1), (TrEntry) YAP_IntOfTerm(arg_trie2));
613 return YAP_Unify(arg_entries, YAP_MkIntTerm(entries));
614}
615#undef arg_trie1
616#undef arg_trie2
617#undef arg_entries
618
619
620/* trie_count_intersect(+Trie1,+Trie2,-Entries) */
621#define arg_trie1 YAP_ARG1
622#define arg_trie2 YAP_ARG2
623#define arg_entries YAP_ARG3
624static YAP_Bool p_trie_count_intersect(void) {
625 YAP_Int entries;
626
627 /* check args */
628 if (!YAP_IsIntTerm(arg_trie1))
629 return FALSE;
630 if (!YAP_IsIntTerm(arg_trie2))
631 return FALSE;
632
633 /* count intersect trie */
634 entries = trie_count_intersect((TrEntry) YAP_IntOfTerm(arg_trie1), (TrEntry) YAP_IntOfTerm(arg_trie2));
635 return YAP_Unify(arg_entries, YAP_MkIntTerm(entries));
636}
637#undef arg_trie1
638#undef arg_trie2
639#undef arg_entries
640
648#define arg_trie YAP_ARG1
649#define arg_file YAP_ARG2
650static YAP_Bool p_trie_save(void) {
651 const char *file_str;
652 FILE *file;
653
654 /* check args */
655 if (!YAP_IsIntTerm(arg_trie))
656 return FALSE;
657 if (!YAP_IsAtomTerm(arg_file))
658 return FALSE;
659
660 /* open file */
661 file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file));
662 if (!(file = fopen(file_str, "w")))
663 return FALSE;
664
665 /* save trie and close file */
666 trie_save((TrEntry) YAP_IntOfTerm(arg_trie), file);
667 if (fclose(file))
668 return FALSE;
669 return TRUE;
670}
671#undef arg_trie
672#undef arg_file
673
674
675/* trie_load(-Trie,+FileName) */
683#define arg_trie YAP_ARG1
684#define arg_file YAP_ARG2
685static YAP_Bool p_trie_load(void) {
686 TrEntry data;
687 const char *file_str;
688 FILE *file;
689
690 /* check args */
691 if (!YAP_IsVarTerm(arg_trie))
692 return FALSE;
693 if (!YAP_IsAtomTerm(arg_file))
694 return FALSE;
695
696 /* open file */
697 file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file));
698 if (!(file = fopen(file_str, "r")))
699 return FALSE;
700
701 /* load trie and close file */
702 if (!(data = trie_load(file)))
703 return FALSE;
704 if (fclose(file))
705 return FALSE;
706 return YAP_Unify(arg_trie, YAP_MkIntTerm((YAP_Int) data));
707}
708#undef arg_trie
709#undef arg_file
710
721/* trie_stats(-Memory,-Tries,-Entries,-Nodes) */
722#define arg_memory YAP_ARG1
723#define arg_tries YAP_ARG2
724#define arg_entries YAP_ARG3
725#define arg_nodes YAP_ARG4
726static YAP_Bool p_trie_stats(void) {
727 YAP_Int memory, tries, entries, nodes;
728
729 /* get stats */
730 trie_stats(&memory, &tries, &entries, &nodes);
731 if (!YAP_Unify(arg_memory, YAP_MkIntTerm(memory)))
732 return FALSE;
733 if (!YAP_Unify(arg_tries, YAP_MkIntTerm(tries)))
734 return FALSE;
735 if (!YAP_Unify(arg_entries, YAP_MkIntTerm(entries)))
736 return FALSE;
737 if (!YAP_Unify(arg_nodes, YAP_MkIntTerm(nodes)))
738 return FALSE;
739 return TRUE;
740}
741#undef arg_memory
742#undef arg_tries
743#undef arg_entries
744#undef arg_nodes
745
746
747/* trie_max_stats(-Memory,-Tries,-Entries,-Nodes) */
757#define arg_memory YAP_ARG1
758#define arg_tries YAP_ARG2
759#define arg_entries YAP_ARG3
760#define arg_nodes YAP_ARG4
761static YAP_Bool p_trie_max_stats(void) {
762 YAP_Int memory, tries, entries, nodes;
763
764 /* get stats */
765 trie_max_stats(&memory, &tries, &entries, &nodes);
766 if (!YAP_Unify(arg_memory, YAP_MkIntTerm(memory)))
767 return FALSE;
768 if (!YAP_Unify(arg_tries, YAP_MkIntTerm(tries)))
769 return FALSE;
770 if (!YAP_Unify(arg_entries, YAP_MkIntTerm(entries)))
771 return FALSE;
772 if (!YAP_Unify(arg_nodes, YAP_MkIntTerm(nodes)))
773 return FALSE;
774 return TRUE;
775}
776#undef arg_memory
777#undef arg_tries
778#undef arg_entries
779#undef arg_nodes
780
781
791/* trie_usage(+Trie,-Entries,-Nodes,-VirtualNodes) */
792#define arg_trie YAP_ARG1
793#define arg_entries YAP_ARG2
794#define arg_nodes YAP_ARG3
795#define arg_virtualnodes YAP_ARG4
796static YAP_Bool p_trie_usage(void) {
797 YAP_Int entries, nodes, virtualnodes;
798
799 /* check arg */
800 if (!YAP_IsIntTerm(arg_trie))
801 return FALSE;
802
803 /* get trie usage */
804 trie_usage((TrEntry) YAP_IntOfTerm(arg_trie), &entries, &nodes, &virtualnodes);
805 if (!YAP_Unify(arg_entries, YAP_MkIntTerm(entries)))
806 return FALSE;
807 if (!YAP_Unify(arg_nodes, YAP_MkIntTerm(nodes)))
808 return FALSE;
809 if (!YAP_Unify(arg_virtualnodes, YAP_MkIntTerm(virtualnodes)))
810 return FALSE;
811 return TRUE;
812}
813#undef arg_trie
814#undef arg_entries
815#undef arg_nodes
816#undef arg_virtualnodes
817
818
819/* trie_print(+Trie) */
829#define arg_trie YAP_ARG1
830static YAP_Bool p_trie_print(void) {
831 /* check arg */
832 if (!YAP_IsIntTerm(arg_trie))
833 return FALSE;
834
835 /* print trie */
836 trie_print((TrEntry) YAP_IntOfTerm(arg_trie));
837 return TRUE;
838}
839#undef arg_trie
840
841
842/* trie_traverse_mode(?Mode) */
843#define arg_mode YAP_ARG1
844static YAP_Bool p_trie_traverse_mode(void) {
845 YAP_Term mode_term;
846 const char *mode_str;
847 YAP_Int mode;
848
849 /* get mode */
850 if (YAP_IsVarTerm(arg_mode)) {
851 mode = trie_get_traverse_mode();
852 if (mode == TRAVERSE_MODE_FORWARD)
853 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("forward"));
854 else if (mode == TRAVERSE_MODE_BACKWARD)
855 mode_term = YAP_MkAtomTerm(YAP_LookupAtom("backward"));
856 else
857 return FALSE;
858 return YAP_Unify(arg_mode, mode_term);
859 }
860
861 /* set mode */
862 mode_str = YAP_AtomName(YAP_AtomOfTerm(arg_mode));
863 if (!strcmp(mode_str, "forward"))
864 mode = TRAVERSE_MODE_FORWARD;
865 else if (!strcmp(mode_str, "backward"))
866 mode = TRAVERSE_MODE_BACKWARD;
867 else
868 return FALSE;
869 trie_set_traverse_mode(mode);
870 return TRUE;
871}
872#undef arg_mode
873
874
875/* trie_traverse_first(+Trie, -Ref) */
876#define arg_trie YAP_ARG1
877#define arg_ref YAP_ARG2
878static YAP_Bool p_trie_traverse_first(void) {
879 TrData data;
880
881 /* check arg */
882 if (!YAP_IsIntTerm(arg_trie))
883 return FALSE;
884
885 /* traverse trie */
886 if (!(data = trie_traverse_first((TrEntry) YAP_IntOfTerm(arg_trie)))) {
887 return FALSE;
888 }
889 return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data));
890}
891#undef arg_trie
892#undef arg_ref
893
894
895/* trie_traverse_next(+Ref, -Ref) */
896#define arg_cur YAP_ARG1
897#define arg_next YAP_ARG2
898static YAP_Bool p_trie_traverse_next(void) {
899 TrData data;
900
901 /* check arg */
902 if (!YAP_IsIntTerm(arg_cur))
903 return FALSE;
904
905 /* traverse trie */
906 if (!(data = trie_traverse_next((TrData) YAP_IntOfTerm(arg_cur)))) {
907 return FALSE;
908 }
909 return YAP_Unify(arg_next, YAP_MkIntTerm((YAP_Int) data));
910}
911#undef arg_cur
912#undef arg_next
913
914
915/* trie_disable_hash */
916static YAP_Bool p_trie_disable_hash(void) {
917 trie_disable_hash_table();
918 return TRUE;
919}
920
921
922/* trie_enable_hash */
923static YAP_Bool p_trie_enable_hash(void) {
924 trie_enable_hash_table();
925 return TRUE;
926}
927
928
929/* trie_to_list(+Trie, -List) */
930#define arg_trie YAP_ARG1
931#define arg_list YAP_ARG2
932static YAP_Bool p_trie_to_list(void) {
933 YAP_Term list;
934
935 /* check arg */
936 if (!YAP_IsIntTerm(arg_trie))
937 return FALSE;
938
939 /* get list from trie */
940 list = trie_to_list((TrEntry) YAP_IntOfTerm(arg_trie));
941 return YAP_Unify(arg_list, list);
942}
943#undef arg_trie
944#undef arg_list
945
946
947/* trie_depth_breadth(+Trie, -DepthBreadthTrie, -FinalLabel, +OptimizationLevel, +StartCounter, -EndCounter) */
948#define arg_trie YAP_ARG1
949#define arg_db_trie YAP_ARG2
950#define arg_final_label YAP_ARG3
951#define arg_opt_level YAP_ARG4
952#define arg_start_counter YAP_ARG5
953#define arg_end_counter YAP_ARG6
954static YAP_Bool p_trie_depth_breadth(void) {
955 /* get depth breadth trie */
956 if (!YAP_IsIntTerm(arg_opt_level))
957 return FALSE;
958 if (!YAP_IsIntTerm(arg_start_counter))
959 return FALSE;
960 YAP_Int End;
961 YAP_Term t = trie_depth_breadth((TrEntry) YAP_IntOfTerm(arg_trie), (TrEntry) YAP_IntOfTerm(arg_db_trie), YAP_IntOfTerm(arg_opt_level), YAP_IntOfTerm(arg_start_counter), &End);
962 int a = YAP_Unify(t, arg_final_label);
963 a = a && YAP_Unify(YAP_MkIntTerm(End), arg_end_counter);
964 return a;
965}
966#undef arg_trie
967#undef arg_db_trie
968#undef arg_final_label
969#undef arg_opt_level
970#undef arg_start_counter
971#undef arg_end_counter
972
973
974/* trie_get_depth_breadth_reduction_entry(-Entry) */
975#define arg_entry YAP_ARG1
976static YAP_Bool p_trie_get_depth_breadth_reduction_current_data(void) {
977 TrData data = trie_get_depth_breadth_reduction_current_data();
978 if (data)
979 return YAP_Unify(arg_entry, YAP_MkIntTerm((YAP_Int) data));
980 return FALSE;
981}
982#undef arg_entry
983
984
985db_trie_opt_level *opt_level;
986
987/* trie_get_depth_breadth_reduction_opt_level_count(?OptLevel, -Count) */
988#define arg_opt_level YAP_ARG1
989#define arg_count YAP_ARG2
990static YAP_Bool p_trie_get_db_opt_level_count_init(void) {
991 if (YAP_IsIntTerm(arg_opt_level)) {
992 if (YAP_IntOfTerm(arg_opt_level) > 0 && YAP_IntOfTerm(arg_opt_level) < 4) {
993 if (YAP_Unify(arg_count, YAP_MkIntTerm(trie_get_db_opt_level_count(YAP_IntOfTerm(arg_opt_level))))) {
994 YAP_cut_succeed();
995 return TRUE;
996 } else {
997 YAP_cut_fail();
998 return FALSE;
999 }
1000 } else {
1001 YAP_cut_fail();
1002 return FALSE;
1003 }
1004 }
1005 if (YAP_IsVarTerm(arg_opt_level)) {
1006 YAP_PRESERVE_DATA(opt_level, db_trie_opt_level);
1007 opt_level->value = YAP_MkIntTerm(1);
1008 if (YAP_Unify(arg_opt_level, opt_level->value)) {
1009 return YAP_Unify(arg_count, YAP_MkIntTerm(trie_get_db_opt_level_count(YAP_IntOfTerm(arg_opt_level))));
1010 }
1011 YAP_cut_fail();
1012 return FALSE;
1013 }
1014 YAP_cut_fail();
1015 return FALSE;
1016}
1017#undef arg_opt_level
1018#undef arg_count
1019
1020
1021/* trie_get_depth_breadth_reduction_opt_level_count(?OptLevel, -Count) */
1022#define arg_opt_level YAP_ARG1
1023#define arg_count YAP_ARG2
1024static YAP_Bool p_trie_get_db_opt_level_count_cont(void) {
1025 YAP_PRESERVED_DATA(opt_level, db_trie_opt_level);
1026 opt_level->value = YAP_MkIntTerm(YAP_IntOfTerm(opt_level->value) + 1);
1027 if (YAP_IntOfTerm(opt_level->value) < 4) {
1028 if (YAP_Unify(arg_opt_level, opt_level->value))
1029 return YAP_Unify(arg_count, YAP_MkIntTerm(trie_get_db_opt_level_count(YAP_IntOfTerm(arg_opt_level))));
1030 YAP_cut_fail();
1031 return FALSE;
1032 } else {
1033 YAP_cut_fail();
1034 return FALSE;
1035 }
1036}
1037#undef arg_opt_level
1038#undef arg_count
1039
1040
1041/* trie_replace_nested_trie(+Trie, +NestedTrieID, +ReplaceTerm) */
1042#define arg_trie YAP_ARG1
1043#define arg_nested_id YAP_ARG2
1044#define arg_term YAP_ARG3
1045static YAP_Bool p_trie_replace_nested_trie(void) {
1046 if (!YAP_IsIntTerm(arg_nested_id))
1047 return FALSE;
1048 if (!YAP_IsNonVarTerm(arg_term))
1049 return FALSE;
1050 trie_replace_nested_trie((TrEntry) YAP_IntOfTerm(arg_trie), YAP_IntOfTerm(arg_nested_id), arg_term);
1051 return TRUE;
1052}
1053#undef arg_trie
1054#undef arg_nested_id
1055#undef arg_term
1056
1057
1058/* trie_db_opt_min_prefix(?MinPrefix) */
1059#define arg_min_prefix YAP_ARG1
1060static YAP_Bool p_trie_db_opt_min_prefix(void) {
1061 YAP_Int min_prefix;
1062
1063 /* get mode */
1064 if (YAP_IsVarTerm(arg_min_prefix)) {
1065 min_prefix = trie_get_db_opt_min_prefix();
1066 return YAP_Unify(arg_min_prefix, YAP_MkIntTerm(min_prefix));
1067 }
1068
1069 /* set mode */
1070 if (YAP_IsIntTerm(arg_min_prefix)) {
1071 min_prefix = YAP_IntOfTerm(arg_min_prefix);
1072 if (min_prefix > 1) {
1073 trie_set_db_opt_min_prefix(min_prefix);
1074 return TRUE;
1075 }
1076 }
1077 return FALSE;
1078}
1079#undef min_prefix
1080
1081
1082#ifdef _WIN32
1083
1084#include <windows.h>
1085
1086int WINAPI win_tries(HANDLE, DWORD, LPVOID);
1087
1088int WINAPI win_tries(HANDLE hinst, DWORD reason, LPVOID reserved)
1089{
1090 switch (reason)
1091 {
1092 case DLL_PROCESS_ATTACH:
1093 break;
1094 case DLL_PROCESS_DETACH:
1095 break;
1096 case DLL_THREAD_ATTACH:
1097 break;
1098 case DLL_THREAD_DETACH:
1099 break;
1100 }
1101 return 1;
1102}
1103#endif
1104
db_trie_opt_level
Definition: tries.c:34
itrie_data
Definition: base_itries.h:50
itrie_entry
Definition: base_itries.h:27