This is info/sicstus.info, produced by makeinfo version 4.8 from sicstus.texi. INFO-DIR-SECTION SICStus Prolog START-INFO-DIR-ENTRY * SICStus Prolog Manual: (sicstus). SICStus Prolog User's Manual. END-INFO-DIR-ENTRY Generated 10 May 2011.  File: sicstus.info, Node: Book Index, Prev: Keystroke Index, Up: Top Book Index ********** [index] * Menu: * !/0, cut <1>: Control. (line 13) * !/0, cut: Cut. (line 6) * # /2, bitwise exclusive or: Arithmetic. (line 99) * # /2, boolean eor: CLPB. (line 42) * #/\ /2 (clpfd): Propositional Constraints. (line 25) * #< /2 (clpfd): Arithmetic Constraints. (line 7) * #<= /2 (clpfd): Propositional Constraints. (line 35) * #<=> /2 (clpfd) <1>: Propositional Constraints. (line 38) * #<=> /2 (clpfd): Reified Constraints. (line 17) * #= /2 (clpfd): Arithmetic Constraints. (line 7) * #=< /2 (clpfd): Arithmetic Constraints. (line 7) * #=> /2 (clpfd): Propositional Constraints. (line 35) * #> /2 (clpfd): Arithmetic Constraints. (line 7) * #>= /2 (clpfd): Arithmetic Constraints. (line 7) * #\ /1 (clpfd): Propositional Constraints. (line 22) * #\ /2 (clpfd): Propositional Constraints. (line 28) * #\/ /2 (clpfd): Propositional Constraints. (line 31) * #\= /2 (clpfd): Arithmetic Constraints. (line 7) * 'SU_messages':generate_message/3: Message Handling Predicates. (line 51) * 'SU_messages':query_abbreviation/3: Query Handling Predicates. (line 117) * 'SU_messages':query_class/5: Query Handling Predicates. (line 89) * 'SU_messages':query_input/3: Query Handling Predicates. (line 143) * 'SU_messages':query_map/4: Query Handling Predicates. (line 157) * (vbsp becomes \VBSP and findex cannot: Loading the Prolog Code. (line 24) * * /2, boolean and: CLPB. (line 36) * * /2, multiplication: Arithmetic. (line 49) * ** /2, exponent: Arithmetic. (line 252) * + /1, identity: Arithmetic. (line 37) * + /2, addition: Arithmetic. (line 43) * + /2, boolean ior: CLPB. (line 39) * ,/2, conjunction: Control. (line 7) * - /1, negation: Arithmetic. (line 40) * - /2, subtraction: Arithmetic. (line 46) * --> /2, grammar rule: Term and Goal Expansion. (line 17) * -/2 (debugger show control): Action Variables. (line 32) * -> /2 ;/2, if then else: Control. (line 44) * -> /2, if then: Control. (line 70) * . /2, consult: Read In. (line 113) * . /2, identity: Arithmetic. (line 114) * .emacs Emacs initialization file: Quick-Start. (line 12) * / /2, floating division: Arithmetic. (line 52) * // /2, integer division: Arithmetic. (line 55) * /\ /2, bitwise conjunction: Arithmetic. (line 91) * :- /1, directive: Directives. (line 6) * :- /2, clause: Programs. (line 37) * :/2: Control. (line 138) * ::/1 (objects): Obj Self. (line 21) * ::/2 (objects): Obj Self. (line 21) * ;/2, disjunction: Control. (line 10) * < /2, arithmetic less than: Arithmetic. (line 286) * < /2, boolean less: CLPB. (line 61) * <:/1 (objects): Obj Self. (line 28) * <:/2 (objects): Obj Self. (line 28) * << /2, left shift: Arithmetic. (line 106) * = /2, unification: Misc Pred. (line 7) * =.. /2, univ: Meta Logic. (line 81) * =/2 (clpfd:dispatch_global/4 request): The Global Constraint Programming Interface. (line 51) * =:= /2, arithmetic equal: Arithmetic. (line 280) * =:= /2, boolean equal: CLPB. (line 49) * =< /2, arithmetic less or equal: Arithmetic. (line 292) * =< /2, boolean less or equal: CLPB. (line 55) * == /2, equality of terms: Term Compare. (line 42) * =\= /2, arithmetic not equal: Arithmetic. (line 283) * =\= /2, boolean not equal: CLPB. (line 52) * > /2, arithmetic greater than: Arithmetic. (line 289) * > /2, boolean greater: CLPB. (line 64) * >= /2, arithmetic greater or equal: Arithmetic. (line 296) * >= /2, boolean greater or equal: CLPB. (line 58) * >> /2, right shift: Arithmetic. (line 110) * ?- /1, query: Queries. (line 6) * ?= /2, terms identical or cannot unify: Term Compare. (line 75) * @< /2, term less than: Term Compare. (line 61) * @=< /2, term less or equal: Term Compare. (line 67) * @> /2, term greater than: Term Compare. (line 64) * @>= /2, term greater or equal: Term Compare. (line 70) * []/0 (debugger condition): Other Tests. (line 35) * []/0, consult: Read In. (line 113) * \ /1, bitwise negation: Arithmetic. (line 102) * \+ /1, not provable: Control. (line 16) * \/ /2, bitwise disjunction: Arithmetic. (line 95) * \= /2, not unifiable: Misc Pred. (line 10) * \== /2, inequality of terms: Term Compare. (line 57) * ^ /2, boolean existential quantifier: CLPB. (line 45) * ^ /2, existential quantifier: All Solutions. (line 101) * abolish: Glossary. (line 7) * abolish/0 (object method): The Proto-Object. (line 101) * abolish/[1,2]: Modify Prog. (line 96) * abort (debugger command): Debug Commands. (line 271) * abort/0: Misc Pred. (line 80) * abort/0 (debugger command control): Action Variables. (line 91) * abs/1, absolute value: Arithmetic. (line 126) * absolute_file_name/[2,3]: Stream Pred. (line 19) * accept (top-level command): Queries. (line 39) * accepted_hosts/1 (start/1 option): PB Prolog Server Interface. (line 26) * access driven programming: Obj Daemons. (line 6) * access/1 (absolute_file_name/3 option): Stream Pred. (line 89) * accumulating parameter: Accumulating Parameters. (line 6) * acos/1, function: Arithmetic. (line 211) * acosh/1, function: Arithmetic. (line 229) * acot/1, function: Arithmetic. (line 220) * acot2/2, function: Arithmetic. (line 223) * acoth/1, function: Arithmetic. (line 235) * action condition, breakpoint: Action Conditions. (line 6) * action execution, breakpoint: Breakpoint Actions. (line 93) * action variables, debugger <1>: Breakpoint Actions. (line 6) * action variables, debugger: Action Variables. (line 6) * action, breakpoint <1>: Creating Breakpoints. (line 39) * action, breakpoint: Breakpoint Actions. (line 6) * acyclic_term/1 (terms): Term Utilities. (line 108) * add_breakpoint/2 <1>: Debug Pred. (line 68) * add_breakpoint/2: Breakpoint Predicates. (line 10) * add_edges/3 (ugraphs): UGraphs. (line 66) * add_edges/3 (wgraphs): WGraphs. (line 70) * add_to_heap/4 (heaps): Heaps. (line 14) * add_vertices/3 (ugraphs): UGraphs. (line 59) * add_vertices/3 (wgraphs): WGraphs. (line 63) * address-constrained memory: Initializing the Prolog Engine. (line 63) * advice breakpoint <1>: Advice-points. (line 6) * advice breakpoint: Advanced Debugging. (line 6) * advice-point: Glossary. (line 12) * advice/0 (debugger condition) <1>: Other Tests. (line 11) * advice/0 (debugger condition): Advice-points. (line 24) * agc_margin (prolog flag) <1>: Creating and Manipulating SP_term_refs. (line 87) * agc_margin (prolog flag): State Info. (line 88) * alias, of a stream: Input Output. (line 70) * alias, stream: Glossary. (line 757) * alias/1 (open/4 option): Stream Pred. (line 359) * alias/1 (stream property): Stream Pred. (line 475) * all (labeling/2 option): Enumeration Predicates. (line 138) * all (profile_data/4 resolution): Profiling. (line 91) * all solutions: All Solutions. (line 6) * all_different/[1,2] (clpfd): Combinatorial Constraints. (line 235) * all_distinct/[1,2] (clpfd): Combinatorial Constraints. (line 235) * alphanumeric: Glossary. (line 18) * ancestor goal: Debug Format. (line 36) * ancestor/1 (utility method): The Utility Object. (line 47) * ancestor/2 (debugger condition) <1>: Accessing Past Debugger States. (line 126) * ancestor/2 (debugger condition): Goal Tests. (line 48) * ancestor/2 (utility method): The Utility Object. (line 50) * ancestors: Glossary. (line 23) * ancestors (debugger command): Debug Commands. (line 187) * ancestors/1 (utility method): The Utility Object. (line 54) * ancestors/2 (utility method): The Utility Object. (line 57) * and_cast/2 (utility method): The Utility Object. (line 64) * annotate goal (debugger command): FDBG Debugger Commands. (line 15) * annotation: FDBG Names of Terms. (line 14) * anonymous variable <1>: Glossary. (line 28) * anonymous variable: Variables. (line 11) * ANSI conformance <1>: Function Prototypes. (line 6) * ANSI conformance: CPL Notes. (line 7) * anti-unifications: Term Utilities. (line 6) * API: Mixing C and Prolog. (line 6) * app, file search path: Loading the Prolog Code. (line 15) * append (open/[3,4] mode): Stream Pred. (line 340) * append, avoiding: Accumulating Lists. (line 6) * append/3 (lists): Lists. (line 15) * application builder: The Application Builder. (line 12) * aref/3 (arrays): Arrays. (line 28) * arefa/3 (arrays): Arrays. (line 32) * arefl/3 (arrays): Arrays. (line 39) * arg/3: Meta Logic. (line 75) * argument: Glossary. (line 33) * arguments, command-line: Start. (line 6) * argv (prolog flag, volatile) <1>: WCX Concepts. (line 58) * argv (prolog flag, volatile) <2>: State Info. (line 98) * argv (prolog flag, volatile) <3>: Start. (line 69) * argv (prolog flag, volatile): Initializing the Prolog Engine. (line 13) * arithmetic: Arithmetic. (line 6) * arithmetic expression: Arithmetic. (line 6) * arity <1>: Compound Terms. (line 6) * arity: Glossary. (line 36) * array_to_list/2 (arrays): Arrays. (line 46) * arrays: Arrays. (line 6) * aset/4 (arrays): Arrays. (line 54) * asin/1, function: Arithmetic. (line 208) * asinh/1, function: Arithmetic. (line 226) * ask/0 (debugger command control): Action Variables. (line 38) * ask_query/4: Query Handling Predicates. (line 7) * ASPX: PB Features. (line 36) * assert/1 (object method) <1>: The Proto-Object. (line 80) * assert/1 (object method): Method Additions. (line 6) * assert/2 (object method): The Proto-Object. (line 80) * assert/[1,2]: Modify Prog. (line 47) * asserta/1 (object method) <1>: The Proto-Object. (line 80) * asserta/1 (object method): Method Additions. (line 6) * asserta/2 (object method): The Proto-Object. (line 80) * asserta/[1,2]: Modify Prog. (line 57) * asserted clause: Modify Prog. (line 6) * assertz/1 (object method) <1>: The Proto-Object. (line 80) * assertz/1 (object method): Method Additions. (line 6) * assertz/2 (object method): The Proto-Object. (line 80) * assertz/[1,2]: Modify Prog. (line 62) * assignment, destructive: Modify Term. (line 6) * assignment/[2,3] (clpfd): Combinatorial Constraints. (line 289) * assoc_to_list/2 (assoc): Assoc. (line 30) * association lists: Assoc. (line 6) * assumptions/1 (labeling/2 option): Enumeration Predicates. (line 152) * asynchronously, calling Prolog: Calling Prolog Asynchronously. (line 6) * at_end_of_line/[0,1]: Stream Pred. (line 544) * at_end_of_stream/[0,1]: Stream Pred. (line 531) * atan/1, function: Arithmetic. (line 214) * atan2/2, function: Arithmetic. (line 217) * atanh/1, function: Arithmetic. (line 232) * atom <1>: Atoms. (line 6) * atom: Glossary. (line 40) * atom (double_quotes flag value): State Info. (line 173) * atom, one-char: Glossary. (line 519) * atom/1: Meta Logic. (line 33) * atom_chars/2: Meta Logic. (line 168) * atom_codes/2: Meta Logic. (line 153) * atom_concat/3: Meta Logic. (line 189) * atom_garbage_collection (statistics/2 option): State Info. (line 492) * atom_length/2: Meta Logic. (line 184) * atom_to_chars/[2,3] (charsio): Chars I/O. (line 45) * atomic term: Glossary. (line 51) * atomic/1: Meta Logic. (line 46) * atoms (statistics/2 option): State Info. (line 484) * attribute declaration: Attributes. (line 25) * attribute/1 (declaration): Attributes. (line 25) * attribute_goal/2 (Module): Attributes. (line 112) * attributed variables: Attributes. (line 6) * attributes, object <1>: Object Attributes. (line 6) * attributes, object: Obj Intro. (line 23) * attributes/1 (universal method): Universal Methods. (line 13) * augment/1 (object method): The Proto-Object. (line 106) * augmenta/1 (object method): The Proto-Object. (line 106) * augmentz/1 (object method): The Proto-Object. (line 106) * auto-generation of names: FDBG Name Auto-Generation. (line 6) * avoiding append: Accumulating Lists. (line 6) * backtrace <1>: Glossary. (line 54) * backtrace <2>: Accessing Past Debugger States. (line 9) * backtrace: Debug Commands. (line 189) * backtrace (debugger command): Debug Commands. (line 204) * backtracking <1>: Procedural. (line 79) * backtracking: Glossary. (line 61) * backtracking, terminating a loop: Terminating a Backtracking Loop. (line 14) * backtracks (fd_statistics/2 option): Statistics Predicates. (line 30) * backtracks (profile_data/4 option): Profiling. (line 52) * bagof/3: All Solutions. (line 95) * bagof_rd_noblock/3 (linda_client): Client. (line 81) * bb_delete/2: Blackboard Primitives. (line 33) * bb_get/2: Blackboard Primitives. (line 29) * bb_inf/[3,5] (clpqr): Solver Predicates. (line 126) * bb_put/2: Blackboard Primitives. (line 25) * bb_update/3: Blackboard Primitives. (line 38) * bid/1 (debugger condition) <1>: Port Tests. (line 38) * bid/1 (debugger condition): Built-in Predicates for Breakpoint Handling. (line 53) * binary stream: Input Output. (line 34) * binary trees: Trees. (line 6) * binding: Glossary. (line 66) * bisect (labeling/2 option): Enumeration Predicates. (line 97) * blackboard: Blackboard Primitives. (line 6) * block declaration: Block Declarations. (line 6) * block/0 (debugger port value): Port Tests. (line 13) * block/1 (declaration): Block Declarations. (line 6) * blocked goal <1>: Glossary. (line 70) * blocked goal: Debug Format. (line 69) * blocked goals (debugger command) <1>: FDBG Debugger Commands. (line 9) * blocked goals (debugger command): Debug Commands. (line 212) * body <1>: Programs. (line 17) * body: Glossary. (line 73) * bof (seek/4 method): Stream Pred. (line 515) * boolean on PrologSession: PB Java Client Interface. (line 71) * boolean on QueryAnswer: PB Java Client Interface. (line 103) * boolean on Term: PB Java Client Interface. (line 140) * bound/1 (cumulatives/3 option): Combinatorial Constraints. (line 440) * bounded (prolog flag, volatile): State Info. (line 103) * bounds_only/1 (cumulative/5 option): Combinatorial Constraints. (line 393) * bounds_only/1 (serialized/3 option): Combinatorial Constraints. (line 393) * box, invocation <1>: Glossary. (line 419) * box, invocation: Procedure Box. (line 103) * box, procedure <1>: Glossary. (line 601) * box, procedure: Procedure Box. (line 6) * box, WCX: WCX Hooks. (line 7) * break: Nested. (line 6) * break (debugger command): Debug Commands. (line 283) * break (top-level command): Queries. (line 50) * break/0 <1>: Misc Pred. (line 77) * break/0: Nested. (line 6) * break_level/1 (debugger condition) <1>: Break Tests. (line 10) * break_level/1 (debugger condition): Past States. (line 13) * breakpoint: Glossary. (line 77) * breakpoint action <1>: Breakpoint Actions. (line 6) * breakpoint action: Creating Breakpoints. (line 39) * breakpoint action condition: Action Conditions. (line 6) * breakpoint action execution: Breakpoint Actions. (line 93) * breakpoint condition: Creating Breakpoints. (line 39) * breakpoint conditions: Breakpoint Conditions. (line 6) * breakpoint handling predicates: Breakpoint Predicates. (line 6) * breakpoint identifier: Creating Breakpoints. (line 31) * breakpoint processing: Breakpoint Processing. (line 6) * breakpoint spec <1>: Creating Breakpoints. (line 6) * breakpoint spec: Glossary. (line 87) * breakpoint test: Creating Breakpoints. (line 39) * breakpoint test condition: Goal Tests. (line 6) * breakpoint, advice <1>: Advanced Debugging. (line 6) * breakpoint, advice: Advice-points. (line 6) * breakpoint, debugger: Advanced Debugging. (line 6) * breakpoint, generic: Specific and Generic Breakpoints. (line 6) * breakpoint, line: Usage. (line 125) * breakpoint, setting: Usage. (line 125) * breakpoint, specific: Specific and Generic Breakpoints. (line 6) * breakpoint_expansion/2 (user) <1>: Condition Macros. (line 23) * breakpoint_expansion/2 (user): Hooks Related to Breakpoints. (line 8) * buffer: Glossary. (line 93) * builder, application: The Application Builder. (line 12) * built-in predicate <1>: Programs. (line 110) * built-in predicate: Glossary. (line 96) * Button (Tk event type): Event Handling. (line 36) * button (Tk widget): Types of Widget. (line 10) * ButtonPress (Tk event type): Event Handling. (line 37) * ButtonRelease (Tk event type): Event Handling. (line 40) * byte_count/2: Stream Pred. (line 430) * C/3: Term and Goal Expansion. (line 262) * cache_size/1 (db_open/5 option): The Predicates. (line 55) * call (leashing mode): Basic Debug. (line 55) * call, procedure: Procedural. (line 66) * call/0 (debugger port value): Port Tests. (line 13) * call/1: Control. (line 138) * call/1 (clpfd:dispatch_global/4 request): The Global Constraint Programming Interface. (line 62) * call_cleanup/2: Control. (line 148) * call_residue/2: Coroutining. (line 55) * callable term: Glossary. (line 100) * callable/1: Meta Logic. (line 56) * calling Prolog asynchronously: Calling Prolog Asynchronously. (line 6) * calling Prolog from C: Calling Prolog from C. (line 6) * calls (profile_data/4 option): Profiling. (line 46) * CallSpec: Terminology. (line 75) * canvas (Tk widget): Types of Widget. (line 13) * card/2, boolean cardinality: CLPB. (line 67) * case/[3,4] (clpfd): Combinatorial Constraints. (line 83) * catch/3: Exception. (line 15) * ceiling/1, function: Arithmetic. (line 180) * char-list: Glossary. (line 104) * char_code/2: Meta Logic. (line 181) * char_conversion (prolog flag, volatile) <1>: Glossary. (line 125) * char_conversion (prolog flag, volatile): State Info. (line 109) * char_conversion/2: Term I/O. (line 116) * character code: Glossary. (line 107) * character code set <1>: Glossary. (line 114) * character code set: WCX Concepts. (line 37) * character I/O: Char I/O. (line 6) * character set <1>: Token String. (line 6) * character set: Environment Variables. (line 16) * character, EOF: Keyboard Characters. (line 13) * character, interrupt: Keyboard Characters. (line 13) * character-conversion mapping: Glossary. (line 120) * character-type mapping <1>: Glossary. (line 128) * character-type mapping: WCX Concepts. (line 46) * character_count/2: Stream Pred. (line 426) * character_escapes (prolog flag) <1>: Term I/O. (line 254) * character_escapes (prolog flag): State Info. (line 181) * character_escapes/1 (write_term/[2,3] option): Term I/O. (line 251) * characters, wide: Input Output. (line 34) * chars (double_quotes flag value): State Info. (line 170) * checkbutton (Tk widget): Types of Widget. (line 17) * checking indexicals: Indexicals. (line 11) * choice (statistics/2 option): State Info. (line 445) * choice_points (profile_data/4 option): Profiling. (line 56) * choicepoints: Glossary. (line 133) * CHOICESTKSIZE (environment): Environment Variables. (line 38) * CHR control flow model: CHR Control Flow Model. (line 6) * CHR debugging messages: CHR Debugging Messages. (line 6) * CHR debugging options: CHR Debugging Options. (line 6) * CHR debugging predicates: CHR Debugging Predicates. (line 6) * CHR spypoints: CHR Spypoints. (line 6) * CHR, propagation: CHR Introduction. (line 32) * CHR, simpagation: CHR Introduction. (line 32) * CHR, simplification: CHR Introduction. (line 32) * CHR, trying a: How CHR Work. (line 6) * chr_debug/0 (chr): CHR Debugging Predicates. (line 21) * chr_debugging/0 (chr): CHR Debugging Predicates. (line 33) * chr_leash/1 (chr): CHR Debugging Predicates. (line 43) * chr_nodebug/0 (chr): CHR Debugging Predicates. (line 26) * chr_nospy/1 (chr): CHR Spypoints. (line 77) * chr_notrace/0 (chr): CHR Debugging Predicates. (line 30) * chr_spy/1 (chr): CHR Spypoints. (line 23) * chr_trace/0 (chr): CHR Debugging Predicates. (line 9) * circuit/1 (assignment/3 option): Combinatorial Constraints. (line 303) * circuit/[1,2] (clpfd): Combinatorial Constraints. (line 323) * clash, name: Glossary. (line 511) * Classname, Fully Qualified: Jasper Library Predicates. (line 98) * clause <1>: Programs. (line 17) * clause: Glossary. (line 137) * clause (profile_data/4 resolution): Profiling. (line 85) * clause, asserted: Modify Prog. (line 6) * clause, definite: Prolog Intro. (line 6) * clause, guarded <1>: Conditionals and Disjunction. (line 91) * clause, guarded: Glossary. (line 357) * clause, Horn: Prolog Intro. (line 6) * clause, retracted: Modify Prog. (line 6) * clause, unit <1>: Programs. (line 24) * clause, unit: Glossary. (line 835) * clause/[2,3]: Modify Prog. (line 68) * clauseref/5 (source information descriptor): Message Handling Predicates. (line 93) * clique/3 (ugraphs): UGraphs. (line 141) * close (Tcl command): File I/O. (line 29) * close on SPQuery: Jasper Package Class Reference. (line 148) * close/[1,2]: Stream Pred. (line 385) * close_client/0 (linda_client): Client. (line 28) * clpfd:dispatch_global/4: The Global Constraint Programming Interface. (line 22) * clpfd:full_answer/0: Answer Constraints. (line 19) * CLSID: Terminology. (line 11) * code, character: Glossary. (line 107) * code, glue: Glossary. (line 339) * code, source: Glossary. (line 718) * code, unreachable: Xref Introduction. (line 6) * code, wide character: WCX Concepts. (line 9) * code-list: Glossary. (line 142) * codes (double_quotes flag value): State Info. (line 167) * collection, garbage <1>: State Info. (line 202) * collection, garbage: Glossary. (line 312) * coloring/3 (ugraphs): UGraphs. (line 149) * colouring/3 (ugraphs): UGraphs. (line 149) * comclient_clsid_from_progid/2 (comclient): COM Client Predicates. (line 93) * comclient_create_instance/2 (comclient): COM Client Predicates. (line 18) * comclient_equal/2 (comclient): COM Client Predicates. (line 60) * comclient_exception_code/2 (comclient): COM Client Predicates. (line 81) * comclient_exception_culprit/2 (comclient): COM Client Predicates. (line 82) * comclient_exception_description/2 (comclient): COM Client Predicates. (line 83) * comclient_garbage_collect/0 (comclient): COM Client Predicates. (line 64) * comclient_get_active_object/2 (comclient): COM Client Predicates. (line 23) * comclient_iid_from_name/2 (comclient): COM Client Predicates. (line 110) * comclient_invoke_method_fun/3 (comclient): COM Client Predicates. (line 38) * comclient_invoke_method_proc/2 (comclient): COM Client Predicates. (line 34) * comclient_invoke_put/3 (comclient): COM Client Predicates. (line 30) * comclient_is_exception/1 (comclient): COM Client Predicates. (line 70) * comclient_is_object/1 (comclient): COM Client Predicates. (line 7) * comclient_name_from_iid/2 (comclient): COM Client Predicates. (line 117) * comclient_progid_from_clsid/2 (comclient): COM Client Predicates. (line 98) * comclient_release/1 (comclient): COM Client Predicates. (line 43) * comclient_valid_object/1 (comclient): COM Client Predicates. (line 14) * ComInArg: Terminology. (line 63) * command (debugger command): Debug Commands. (line 292) * command-line arguments: Start. (line 6) * command/1 (debugger condition) <1>: Action Conditions. (line 13) * command/1 (debugger condition) <2>: Breakpoint Actions. (line 12) * command/1 (debugger condition): Port Tests. (line 46) * commands, debug: Debug Commands. (line 6) * communication, process <1>: Sockets. (line 6) * communication, process: Linda Library. (line 6) * compactcode: Glossary. (line 149) * compactcode (compiling flag value) <1>: Load Intro. (line 30) * compactcode (compiling flag value): State Info. (line 116) * compare/3: Term Compare. (line 79) * comparison, term: Term Compare. (line 6) * compilation: Read In. (line 55) * compilation_mode/1 (load_files/2 option): Read In. (line 94) * compile: Glossary. (line 154) * compile-buffer (emacs command): Usage. (line 52) * compile-file (emacs command): Usage. (line 49) * compile-predicate (emacs command): Usage. (line 58) * compile-region (emacs command): Usage. (line 55) * compile/1 <1>: Read In. (line 118) * compile/1: Load Predicates. (line 46) * compiling: Run Intro. (line 15) * compiling (prolog flag) <1>: Load Intro. (line 27) * compiling (prolog flag) <2>: Glossary. (line 151) * compiling (prolog flag) <3>: State Info. (line 113) * compiling (prolog flag): Profiling. (line 23) * complement/2 (ugraphs): UGraphs. (line 81) * compose/3 (ugraphs): UGraphs. (line 86) * compound term <1>: Compound Terms. (line 6) * compound term <2>: Glossary. (line 160) * compound term: Terms. (line 6) * compound/1: Meta Logic. (line 53) * computation rule: Procedural. (line 66) * ComValue: Terminology. (line 32) * concat (Tcl command): Lists (Tcl). (line 60) * concepts, FDBG: FDBG Concepts. (line 6) * condition, breakpoint: Creating Breakpoints. (line 39) * conditional spypoint: Creating Breakpoints. (line 26) * conditionals: Conditionals and Disjunction. (line 6) * conditions, breakpoint: Breakpoint Conditions. (line 6) * conformance, ANSI <1>: CPL Notes. (line 7) * conformance, ANSI: Function Prototypes. (line 6) * conjunction: Glossary. (line 145) * considerations for fcompile: Considerations. (line 6) * consistency/1 (all_different/2 option): Combinatorial Constraints. (line 263) * consistency/1 (all_distinct/2 option): Combinatorial Constraints. (line 263) * consistency/1 (assignment/3 option): Combinatorial Constraints. (line 300) * consistency_error/[3,4] (error class): Exception. (line 110) * consistent store: Definitions. (line 10) * console-based executable: Glossary. (line 168) * constant <1>: Terms. (line 6) * constant: Glossary. (line 172) * constraint: CLPFD Interface. (line 15) * constraint event: FDBG Events. (line 10) * constraint handling rule: CHR Introduction. (line 6) * constraint store: Definitions. (line 10) * constraint, domain: Definitions. (line 6) * constraint, global: The Global Constraint Programming Interface. (line 6) * constraint, partner: How CHR Work. (line 6) * constraints (fd_statistics/2 option): Statistics Predicates. (line 36) * constraints, posting: Posting Constraints. (line 6) * consult: Glossary. (line 177) * consult-buffer (emacs command): Usage. (line 40) * consult-file (emacs command): Usage. (line 37) * consult-predicate (emacs command): Usage. (line 46) * consult-region (emacs command): Usage. (line 43) * consult/1 <1>: Load Predicates. (line 9) * consult/1: Read In. (line 113) * consulting <1>: Run Intro. (line 15) * consulting <2>: Reading In. (line 6) * consulting <3>: Read In. (line 55) * consulting: Load Predicates. (line 9) * consume_layout/1 (read_term/[2,3] option): Term I/O. (line 80) * context, load: State Info. (line 385) * context_error/[2,3] (error class): Exception. (line 88) * contradictory store: Definitions. (line 10) * conversions, term: Support Functions. (line 6) * copy_term/2: Meta Logic. (line 225) * core (statistics/2 option): State Info. (line 450) * coroutining: Coroutining. (line 6) * cos/1, function: Arithmetic. (line 187) * cosh/1, function: Arithmetic. (line 199) * cost/2 (assignment/3 option): Combinatorial Constraints. (line 307) * cost/2 (global_cardinality/3 option): Combinatorial Constraints. (line 40) * cot/1, function: Arithmetic. (line 193) * coth/1, function: Arithmetic. (line 205) * count/4 (clpfd): Combinatorial Constraints. (line 12) * counter: Profiling. (line 6) * create_mutable/2: Modify Term. (line 34) * creep: Glossary. (line 183) * creep (debugger command): Debug Commands. (line 48) * cross-referencer: Xref Introduction. (line 6) * cumulative/[4,5] (clpfd): Combinatorial Constraints. (line 465) * cumulatives/[2,3] (clpfd): Combinatorial Constraints. (line 436) * current (seek/4 method): Stream Pred. (line 518) * current input stream: Input Output. (line 71) * current output stream: Input Output. (line 71) * current_atom/1: State Info. (line 18) * current_breakpoint/5 <1>: Built-in Predicates for Breakpoint Handling. (line 71) * current_breakpoint/5 <2>: Breakpoint Predicates. (line 59) * current_breakpoint/5: Debug Pred. (line 72) * current_char_conversion/2: Term I/O. (line 132) * current_constraint/2 (chr): CHR Built-In Predicates. (line 14) * current_handler/2 (chr): CHR Built-In Predicates. (line 10) * current_host/1 (sockets): Sockets. (line 131) * current_input/1: Stream Pred. (line 397) * current_key/2: Database. (line 45) * current_module/[1,2]: State Info. (line 70) * current_op/3: Misc Pred. (line 71) * current_output/1: Stream Pred. (line 401) * current_predicate/[1,2]: State Info. (line 30) * current_prolog_flag/2: State Info. (line 380) * current_stream/3: Stream Pred. (line 405) * cursor: Glossary. (line 188) * customize-group (emacs command): Customizing Emacs. (line 6) * customize-variable (emacs command): Customizing Emacs. (line 6) * cut <1>: Cut. (line 6) * cut <2>: Glossary. (line 193) * cut: Cut Overview. (line 10) * cut and generate-and-test: Terminating a Backtracking Loop. (line 6) * cut on SPQuery: Jasper Package Class Reference. (line 155) * cut, green: Cut. (line 61) * cut, placement of: Placement of Cuts. (line 6) * cut, red: Cut. (line 61) * cycles/1 (read_term/[2,3] option): Term I/O. (line 59) * cycles/1 (write_term/[2,3] option): Term I/O. (line 239) * cyclic term <1>: Term I/O. (line 59) * cyclic term <2>: Occur. (line 6) * cyclic term: Term I/O. (line 239) * cyclic_term/1 (terms): Term Utilities. (line 111) * daemon: Obj Daemons. (line 6) * data resource: The Application Builder. (line 192) * data tables: Data Tables. (line 6) * database <1>: Database. (line 6) * database <2>: Glossary. (line 199) * database: BDB Basics. (line 12) * database reference <1>: Glossary. (line 205) * database reference: Modify Prog. (line 53) * datime/[1,2] (system): System Utilities. (line 31) * db-spec: The DB-Spec Informal Description. (line 6) * db_close/1 (bdb): The Predicates. (line 67) * db_close_env/1 (bdb): The Predicates. (line 23) * db_compress/[2,3] (bdb): The Predicates. (line 131) * db_current/5 (bdb): The Predicates. (line 71) * db_current_env/2 (bdb): The Predicates. (line 27) * db_current_iterator/3 (bdb): The Predicates. (line 172) * db_enumerate/3 (bdb): The Predicates. (line 116) * db_erase/[2,3] (bdb): The Predicates. (line 107) * db_export/[2,3] (bdb): The Predicates. (line 179) * db_fetch/3 (bdb): The Predicates. (line 82) * db_findall/3 (bdb): The Predicates. (line 98) * db_import/[2,3] (bdb): The Predicates. (line 190) * db_iterator_done/1 (bdb): The Predicates. (line 169) * db_iterator_next/3 (bdb): The Predicates. (line 164) * db_make_iterator/[2,3] (bdb): The Predicates. (line 154) * db_open/[4,5] (bdb): The Predicates. (line 33) * db_open_env/[2,3] (bdb): The Predicates. (line 8) * db_store/3 (bdb): The Predicates. (line 77) * db_sync/1 (bdb): The Predicates. (line 126) * DCG: Term and Goal Expansion. (line 17) * debug: Glossary. (line 208) * debug (debugging flag value): State Info. (line 140) * debug (FD flag): The Global Constraint Programming Interface. (line 141) * debug (prolog flag, volatile) <1>: State Info. (line 150) * debug (prolog flag, volatile): Runtime Systems. (line 24) * debug commands: Debug Commands. (line 6) * debug/0 <1>: Debug Pred. (line 32) * debug/0: Basic Debug. (line 10) * debug/0 (debugger mode control): Action Variables. (line 138) * debugcode: Glossary. (line 213) * debugcode (compiling flag value) <1>: State Info. (line 128) * debugcode (compiling flag value): Load Intro. (line 46) * debugger action variables <1>: Action Variables. (line 6) * debugger action variables: Breakpoint Actions. (line 6) * debugger breakpoint: Advanced Debugging. (line 6) * debugger port: Port Tests. (line 11) * debugger, port: Procedure Box. (line 35) * debugger-ancestor: Goal Tests. (line 55) * debugger-parent: Goal Tests. (line 55) * debugger/0 (debugger condition) <1>: Other Tests. (line 14) * debugger/0 (debugger condition): Advice-points. (line 24) * debugger_command_hook/2 (user) <1>: Debug Pred. (line 91) * debugger_command_hook/2 (user) <2>: Hooks Related to Breakpoints. (line 72) * debugger_command_hook/2 (user): Breakpoint Predicates. (line 111) * debugger_print_options (prolog flag) <1>: Debug Commands. (line 315) * debugger_print_options (prolog flag) <2>: Runtime Systems. (line 24) * debugger_print_options (prolog flag) <3>: Debug Intro. (line 41) * debugger_print_options (prolog flag) <4>: Breakpoint Actions. (line 17) * debugger_print_options (prolog flag) <5>: Action Variables. (line 17) * debugger_print_options (prolog flag): State Info. (line 184) * debugging: Debug Intro. (line 6) * debugging (debugger command): Debug Commands. (line 223) * debugging (prolog flag, volatile): State Info. (line 134) * debugging messages: Debug Format. (line 6) * debugging messages, CHR: CHR Debugging Messages. (line 6) * debugging options, CHR: CHR Debugging Options. (line 6) * debugging predicates: Basic Debug. (line 6) * debugging/0 <1>: Basic Debug. (line 90) * debugging/0: Debug Pred. (line 65) * dec10 (syntax_errors flag value): State Info. (line 305) * declaration <1>: Built Intro. (line 28) * declaration <2>: Glossary. (line 217) * declaration: Load Intro. (line 53) * declaration, attribute: Attributes. (line 25) * declaration, block: Block Declarations. (line 6) * declaration, discontiguous: Discontiguous Declarations. (line 6) * declaration, dynamic: Dynamic Declarations. (line 6) * declaration, include: Include Declarations. (line 6) * declaration, meta-predicate <1>: Meta-Predicate Declarations. (line 6) * declaration, meta-predicate: Meta Decl. (line 6) * declaration, mode: Mode Declarations. (line 6) * declaration, module: Module Declarations. (line 6) * declaration, multifile <1>: Load Predicates. (line 18) * declaration, multifile: Multifile Declarations. (line 6) * declaration, operator: Declarations. (line 18) * declaration, predicate: Declarations. (line 6) * declaration, public: Public Declarations. (line 6) * declaration, volatile: Volatile Declarations. (line 6) * declarations: Declarations. (line 6) * declarative semantics: Declarative. (line 6) * declaring nondeterminacy: Declaring Nondeterminacy. (line 6) * decomposition/1 (cumulative/5 option): Combinatorial Constraints. (line 389) * decomposition/1 (disjoint1/2 option): Combinatorial Constraints. (line 520) * decomposition/1 (disjoint2/2 option): Combinatorial Constraints. (line 562) * decomposition/1 (serialized/3 option): Combinatorial Constraints. (line 389) * deep failure: Profiling. (line 67) * deep_fails (profile_data/4 option): Profiling. (line 67) * definite clause: Prolog Intro. (line 6) * definite clause grammar: Term and Goal Expansion. (line 12) * definition, procedure: Procedural. (line 61) * deinit function <1>: Conversion Declarations. (line 9) * deinit function: Glossary. (line 221) * del_assoc/4 (assoc): Assoc. (line 91) * del_edges/3 (ugraphs): UGraphs. (line 70) * del_edges/3 (wgraphs): WGraphs. (line 74) * del_max_assoc/4 (assoc): Assoc. (line 101) * del_min_assoc/4 (assoc): Assoc. (line 96) * del_vertices/3 (ugraphs): UGraphs. (line 62) * del_vertices/3 (wgraphs): WGraphs. (line 66) * delegation: Obj Intro. (line 6) * delegation, message: Obj Self. (line 6) * delete/3 (lists): Lists. (line 20) * delete_file/[1,2] (system): System Utilities. (line 35) * delete_from_heap/4 (heaps): Heaps. (line 64) * depth/1 (debugger condition) <1>: Goal Tests. (line 14) * depth/1 (debugger condition): Breakpoint Tests. (line 120) * descendant/1 (utility method): The Utility Object. (line 34) * descendant/2 (utility method): The Utility Object. (line 37) * descendants/1 (utility method): The Utility Object. (line 41) * descendants/2 (utility method): The Utility Object. (line 44) * destructive assignment: Modify Term. (line 6) * determinacy checker: The Determinacy Checker. (line 6) * determinacy detection, last clause: Last Clause Determinacy Detection. (line 6) * determinacy detection, via indexing: Determinacy Detection. (line 6) * determinate: Glossary. (line 225) * determinate goal: Cut. (line 12) * development system <1>: Glossary. (line 228) * development system: Development and Runtime Systems. (line 6) * dif/2: Coroutining. (line 47) * differential inheritance: Differential Inheritance. (line 6) * directive <1>: Queries and Directives. (line 6) * directive <2>: Start. (line 110) * directive <3>: Programs. (line 51) * directive: Glossary. (line 235) * directory (load_context/2 key): State Info. (line 400) * directory_files/2 (system): System Utilities. (line 49) * disable this (debugger command): Debug Commands. (line 254) * disable_breakpoints/1 <1>: Breakpoint Predicates. (line 74) * disable_breakpoints/1: Debug Pred. (line 79) * discontiguous declaration: Discontiguous Declarations. (line 6) * discontiguous/1 (declaration): Discontiguous Declarations. (line 6) * discontiguous_warnings (prolog flag) <1>: Discontiguous Declarations. (line 14) * discontiguous_warnings (prolog flag) <2>: Read In. (line 48) * discontiguous_warnings (prolog flag) <3>: State Info. (line 190) * discontiguous_warnings (prolog flag): Runtime Systems. (line 32) * discrepancy/1 (labeling/2 option): Enumeration Predicates. (line 158) * disjoint1/[1,2] (clpfd): Combinatorial Constraints. (line 510) * disjoint2/[1,2] (clpfd): Combinatorial Constraints. (line 550) * disjunction <1>: Glossary. (line 240) * disjunction: Conditionals and Disjunction. (line 6) * dispatch_global/4 (clpfd): The Global Constraint Programming Interface. (line 22) * display (debugger command): Debug Commands. (line 169) * display/0 (debugger show control): Action Variables. (line 23) * display/1: Term I/O. (line 143) * display/1 (tk_new/2 option): Creating a Tcl Interpreter Extended with Tk. (line 38) * dom/1 (case/4 spec): Combinatorial Constraints. (line 132) * dom/1 (fd_global/3 spec): The Global Constraint Programming Interface. (line 82) * domain constraint: Definitions. (line 6) * domain variable: CLPFD Interface. (line 15) * domain, finite: CLPFD Interface. (line 15) * domain-consistent: Definitions. (line 23) * domain-disentailed: Definitions. (line 27) * domain-entailed: Definitions. (line 27) * domain/3 (clpfd): Membership Constraints. (line 7) * domain_error/[2,4] (error class): Exception. (line 72) * double on Term: PB Java Client Interface. (line 152) * double_quotes (prolog flag, volatile) <1>: Compound Terms. (line 105) * double_quotes (prolog flag, volatile) <2>: Glossary. (line 780) * double_quotes (prolog flag, volatile) <3>: Term I/O. (line 278) * double_quotes (prolog flag, volatile): State Info. (line 174) * down (labeling/2 option): Enumeration Predicates. (line 131) * dump/3 (clpqr): Solver Predicates. (line 178) * dynamic code, semantics of: Modify Prog. (line 10) * dynamic declaration: Dynamic Declarations. (line 6) * dynamic method: Dynamic Methods. (line 6) * dynamic object <1>: Obj Intro. (line 23) * dynamic object <2>: Obj Dynamic. (line 6) * dynamic object: Dynamically Declared Objects. (line 6) * dynamic predicate: Glossary. (line 244) * dynamic resource: Foreign Resources. (line 33) * dynamic/0 (object method) <1>: Dynamically Declared Objects. (line 6) * dynamic/0 (object method): The Proto-Object. (line 25) * dynamic/1 (declaration): Dynamic Declarations. (line 6) * dynamic/1 (object method) <1>: The Proto-Object. (line 31) * dynamic/1 (object method): Dynamic Methods. (line 6) * dynamic_methods/1 (utility method): The Utility Object. (line 28) * dynamic_objects/1 (utility method): The Utility Object. (line 19) * ect (order_resource/2 option): Enumeration Predicates. (line 224) * edge_finder/1 (cumulative/5 option): Combinatorial Constraints. (line 384) * edge_finder/1 (serialized/3 option): Combinatorial Constraints. (line 384) * edges/2 (ugraphs): UGraphs. (line 56) * edges/2 (wgraphs): WGraphs. (line 60) * efficiency, increasing: Writing Efficient Programs. (line 6) * element/3 (clpfd): Combinatorial Constraints. (line 51) * Emacs initialization file .emacs: Quick-Start. (line 12) * emacs interface: Emacs Interface. (line 6) * empty_assoc/1 (assoc): Assoc. (line 27) * empty_fdset/1 (clpfd): FD Set Operations. (line 16) * empty_heap/1 (heaps): Heaps. (line 35) * empty_interval/2 (clpfd): FD Set Operations. (line 29) * empty_queue/1 (queues): Queues. (line 26) * enable this (debugger command): Debug Commands. (line 261) * enable_breakpoints/1 <1>: Debug Pred. (line 79) * enable_breakpoints/1: Breakpoint Predicates. (line 74) * encoded string <1>: Glossary. (line 250) * encoded string: CPL Notes. (line 49) * encoding, external: WCX Concepts. (line 22) * encoding, external (of wide characters): Glossary. (line 267) * encoding, internal: WCX Concepts. (line 61) * encoding, internal (of wide characters): Glossary. (line 408) * encoding, system: WCX Concepts. (line 54) * encoding, system (of wide characters): Glossary. (line 794) * encoding, UTF-8: Glossary. (line 838) * end of line: Stream Pred. (line 544) * end of stream: Stream Pred. (line 531) * end_of_stream/1 (stream property): Stream Pred. (line 482) * ensure_loaded/1 <1>: Load Predicates. (line 103) * ensure_loaded/1: Read In. (line 128) * entailed/1 (clpqr): Solver Predicates. (line 71) * entailments (fd_statistics/2 option): Statistics Predicates. (line 23) * Enter (Tk event type): Event Handling. (line 43) * entry (Tk widget): Types of Widget. (line 20) * enum (labeling/2 option): Enumeration Predicates. (line 93) * environ/2 (system): System Utilities. (line 56) * environment: The Environment. (line 6) * environment/1 (db_open/5 option): The Predicates. (line 52) * eof (seek/4 method): Stream Pred. (line 521) * eof (Tcl command): File I/O. (line 66) * EOF character: Keyboard Characters. (line 13) * eof_action/1 (open/4 option): Stream Pred. (line 362) * eof_action/1 (stream property): Stream Pred. (line 490) * eof_code (open/4 eof_action value): Stream Pred. (line 371) * erase/1: Modify Prog. (line 104) * error (open/4 eof_action value): Stream Pred. (line 368) * error (overflow FD flag value): The Global Constraint Programming Interface. (line 135) * error (syntax_errors flag value): State Info. (line 308) * error (unknown flag value) <1>: State Info. (line 349) * error (unknown flag value) <2>: Debug Pred. (line 28) * error (unknown flag value): Undefined Predicates. (line 24) * error handling <1>: Exceptions Debug. (line 6) * error handling: Exception. (line 6) * error, syntax: Syntax Errors. (line 6) * error_exception/1 (user) <1>: Debug Pred. (line 96) * error_exception/1 (user): Exceptions Debug. (line 15) * escape sequence <1>: State Info. (line 181) * escape sequence <2>: Glossary. (line 254) * escape sequence: Escape Sequences. (line 6) * est (order_resource/2 option): Enumeration Predicates. (line 218) * eval (Tcl command): Control Flow. (line 124) * evaluation_error/[2,4] (error class): Exception. (line 99) * event, constraint: FDBG Events. (line 10) * event, FDBG: FDBG Events. (line 6) * event, labeling: FDBG Events. (line 13) * exception (leashing mode): Basic Debug. (line 67) * exception handling <1>: Exceptions Debug. (line 6) * exception handling: Exception. (line 6) * exception handling in C: Exception Handling in C. (line 6) * exception term: Exception Handling in C. (line 6) * exception/1 (debugger command control): Action Variables. (line 88) * exception/1 (debugger port value): Port Tests. (line 13) * exec/3 (system): System Utilities. (line 61) * executable, console-based: Glossary. (line 168) * executable, stand-alone <1>: Stand-alone Executables. (line 6) * executable, stand-alone: Glossary. (line 742) * executable, windowed: Glossary. (line 862) * execution: Execution. (line 6) * execution profiling: Profiling. (line 6) * execution, nested: Nested. (line 6) * execution_state/[1,2] <1>: Debug Pred. (line 86) * execution_state/[1,2] <2>: Built-in Predicates for Breakpoint Handling. (line 17) * execution_state/[1,2] <3>: Accessing Past Debugger States. (line 21) * execution_state/[1,2] <4>: Debug Pred. (line 83) * execution_state/[1,2]: Breakpoint Predicates. (line 81) * execution_time (profile_data/4 option): Profiling. (line 73) * existence_error/[2,5] (error class): Exception. (line 78) * exit (leashing mode): Basic Debug. (line 58) * exit/0 (clpfd:dispatch_global/4 request): The Global Constraint Programming Interface. (line 44) * exit/1 (debugger port value): Port Tests. (line 13) * exited/1 (debugger condition) <1>: Goal Tests. (line 39) * exited/1 (debugger condition): Accessing Past Debugger States. (line 84) * exiting: Exiting. (line 6) * exp/1, exponent: Arithmetic. (line 247) * exp/2, exponent: Arithmetic. (line 252) * expand/0 (clpqr): Syntactic Sugar. (line 59) * expand_term/2: Term and Goal Expansion. (line 181) * expansion, macro: Term and Goal Expansion. (line 220) * expansion, module name <1>: Meta-Predicate Declarations. (line 15) * expansion, module name <2>: Glossary. (line 489) * expansion, module name <3>: Meta Exp. (line 6) * expansion, module name: Mode Spec. (line 12) * export: Glossary. (line 258) * exported predicate: Basic Concepts. (line 12) * expr (Tcl command): Expressions. (line 10) * expression, arithmetic: Arithmetic. (line 6) * extended runtime system: Glossary. (line 261) * extended_characters/1 (xml_parse/3 option): XML. (line 72) * extendible predicate <1>: Built Intro. (line 34) * extendible predicate: Glossary. (line 367) * extensions/1 (absolute_file_name/3 option): Stream Pred. (line 36) * external encoding: WCX Concepts. (line 22) * external encoding (of wide characters): Glossary. (line 267) * fact: Glossary. (line 271) * fail (debugger command): Debug Commands. (line 132) * fail (leashing mode): Basic Debug. (line 64) * fail (overflow FD flag value): The Global Constraint Programming Interface. (line 138) * fail (syntax_errors flag value): State Info. (line 312) * fail (unknown flag value) <1>: Undefined Predicates. (line 32) * fail (unknown flag value) <2>: State Info. (line 342) * fail (unknown flag value): Debug Pred. (line 21) * fail/0: Control. (line 103) * fail/0 (clpfd:dispatch_global/4 request): The Global Constraint Programming Interface. (line 47) * fail/0 (debugger port value): Port Tests. (line 13) * fail/1 (debugger command control): Action Variables. (line 114) * failure, deep: Profiling. (line 67) * failure, shallow: Profiling. (line 62) * false/0: Control. (line 103) * false/0 (debugger condition): Other Tests. (line 38) * fastcode: Glossary. (line 282) * fastcode (compiling flag value) <1>: Load Intro. (line 35) * fastcode (compiling flag value): State Info. (line 120) * fcompile, considerations for: Considerations. (line 6) * fcompile/1 <1>: Load Predicates. (line 57) * fcompile/1: Read In. (line 158) * FD predicate <1>: FD Predicates. (line 6) * FD predicate: User-Defined Constraints. (line 17) * FD set: FD Set Operations. (line 6) * fd_closure/2 (clpfd): Reflection Predicates. (line 56) * fd_copy_term/3 (clpfd): Reflection Predicates. (line 67) * fd_degree/2 (clpfd): Reflection Predicates. (line 40) * fd_dom/2 (clpfd): Reflection Predicates. (line 35) * fd_flag/3 (clpfd): The Global Constraint Programming Interface. (line 126) * fd_global/[3,4] (clpfd): The Global Constraint Programming Interface. (line 74) * fd_max/2 (clpfd): Reflection Predicates. (line 20) * fd_min/2 (clpfd): Reflection Predicates. (line 15) * fd_neighbors/2 (clpfd): Reflection Predicates. (line 52) * fd_set/2 (clpfd): Reflection Predicates. (line 30) * fd_size/2 (clpfd): Reflection Predicates. (line 25) * fd_statistics/[0,2] (clpfd): Statistics Predicates. (line 39) * fd_var/1 (clpfd): Reflection Predicates. (line 11) * FDBG concepts: FDBG Concepts. (line 6) * FDBG event: FDBG Events. (line 6) * FDBG output stream: FDBG The fdbg_output Stream. (line 6) * fdbg:fdvar_portray/3: FDBG Customizing Output. (line 9) * fdbg:legend_portray/3 (fdbg): FDBG Customizing Output. (line 24) * fdbg_annotate/[3,4] (fdbg): FDBG Writing Visualizers. (line 72) * fdbg_assign_name/2 (fdbg): FDBG Naming Terms. (line 10) * fdbg_current_name/2 (fdbg): FDBG Naming Terms. (line 16) * fdbg_get_name/2 (fdbg): FDBG Naming Terms. (line 20) * fdbg_guard/3 (fdbg): FDBG Debugging Global Constraints. (line 15) * fdbg_label_show/3 (fdbg): FDBG Built-In Visualizers. (line 35) * fdbg_labeling_step/2 (fdbg): FDBG Annotation. (line 23) * fdbg_legend/[1,2] (fdbg): FDBG Writing Visualizers. (line 94) * fdbg_off/0 (fdbg): FDBG Options. (line 18) * fdbg_on/[0,1] (fdbg): FDBG Options. (line 8) * fdbg_output: FDBG The fdbg_output Stream. (line 6) * fdbg_show/2 (fdbg): FDBG Built-In Visualizers. (line 14) * fdbg_start_labeling/1 (fdbg): FDBG Annotation. (line 21) * fdbg_transform_actions/3 (fdbg): FDBG Writing Legend Printers. (line 15) * fdset_add_element/3 (clpfd): FD Set Operations. (line 67) * fdset_complement/2 (clpfd): FD Set Operations. (line 106) * fdset_del_element/3 (clpfd): FD Set Operations. (line 70) * fdset_disjoint/2 (clpfd): FD Set Operations. (line 73) * fdset_eq/2 (clpfd): FD Set Operations. (line 89) * fdset_intersect/2 (clpfd): FD Set Operations. (line 76) * fdset_intersection/[2,3] (clpfd): FD Set Operations. (line 82) * fdset_interval/3 (clpfd): FD Set Operations. (line 32) * fdset_max/2 (clpfd): FD Set Operations. (line 42) * fdset_member/2 (clpfd): FD Set Operations. (line 85) * fdset_min/2 (clpfd): FD Set Operations. (line 39) * fdset_parts/4 (clpfd): FD Set Operations. (line 19) * fdset_singleton/2 (clpfd): FD Set Operations. (line 35) * fdset_size/2 (clpfd): FD Set Operations. (line 46) * fdset_subset/2 (clpfd): FD Set Operations. (line 93) * fdset_subtract/3 (clpfd): FD Set Operations. (line 96) * fdset_to_list/2 (clpfd): FD Set Operations. (line 55) * fdset_to_range/2 (clpfd): FD Set Operations. (line 63) * fdset_union/[2,3] (clpfd): FD Set Operations. (line 100) * fdvar_portray/3 (fdbg): FDBG Customizing Output. (line 9) * ff (labeling/2 option): Enumeration Predicates. (line 62) * ffc (labeling/2 option): Enumeration Predicates. (line 66) * file: Input Output. (line 6) * file (load_context/2 key): State Info. (line 395) * file search path <1>: Input Output. (line 92) * file search path: Stream Pred. (line 295) * file specification <1>: Glossary. (line 287) * file specification: Input Output. (line 82) * file, PO <1>: Load Predicates. (line 57) * file, PO: Glossary. (line 617) * file, QL <1>: Load Predicates. (line 57) * file, QL: Glossary. (line 624) * file/1 (debugger condition) <1>: Source Tests. (line 12) * file/1 (debugger condition): Breakpoint Tests. (line 223) * file_errors/1 (absolute_file_name/3 option): Stream Pred. (line 114) * file_exists/[1,2] (system): System Utilities. (line 90) * file_name/1 (stream property): Stream Pred. (line 463) * file_property/2 (system): System Utilities. (line 115) * file_search_path/2 (user) <1>: Input Output. (line 92) * file_search_path/2 (user): Stream Pred. (line 295) * file_type/1 (absolute_file_name/3 option): Stream Pred. (line 47) * fileerrors (prolog flag) <1>: State Info. (line 198) * fileerrors (prolog flag): Stream Pred. (line 229) * fileerrors/0: Stream Pred. (line 551) * fileerrors/1 (absolute_file_name/3 option): Stream Pred. (line 114) * fileref/2 (source information descriptor): Message Handling Predicates. (line 90) * find this (debugger command): Debug Commands. (line 265) * find_constraint/2 (chr): CHR Built-In Predicates. (line 34) * find_constraint/3 (chr): CHR Built-In Predicates. (line 39) * findall/[3,4]: All Solutions. (line 108) * findall_constraints/[2,3] (chr): CHR Built-In Predicates. (line 45) * finding nondeterminacy: The Determinacy Checker. (line 6) * finite domain: CLPFD Interface. (line 15) * first (order_resource/2 option): Enumeration Predicates. (line 205) * first_bound/2 (clpfd): Enumeration Predicates. (line 26) * flag, Prolog: State Info. (line 380) * flit/0 (debugger command control): Action Variables. (line 45) * flit/2 (debugger command control): Action Variables. (line 80) * float: Floats. (line 6) * float on Term: PB Java Client Interface. (line 149) * float/1: Meta Logic. (line 37) * float/1, coercion: Arithmetic. (line 87) * float_format/1 (write_term/[2,3] option): Term I/O. (line 257) * float_fractional_part/1, fractional part: Arithmetic. (line 82) * float_integer_part/1, coercion: Arithmetic. (line 78) * floor/1, function: Arithmetic. (line 172) * floundered query: Glossary. (line 292) * floundering: Procedural. (line 106) * flow control model, CHR: CHR Control Flow Model. (line 6) * flush_output/[0,1]: Stream Pred. (line 418) * for (Tcl command): Control Flow. (line 43) * force/1 (close/2 option): Stream Pred. (line 391) * foreach (Tcl command): Control Flow. (line 60) * foreign language interface <1>: Mixing C and Prolog. (line 6) * foreign language interface: Calling C from Prolog. (line 6) * foreign predicate: Glossary. (line 295) * foreign resource <1>: Glossary. (line 300) * foreign resource: Foreign Resources. (line 6) * foreign resource linker: The Foreign Resource Linker. (line 6) * foreign resource, linked <1>: Creating the Linked Foreign Resource. (line 6) * foreign resource, linked: Foreign Resources. (line 6) * foreign resource, pre-linked: Glossary. (line 565) * foreign/[2,3]: Conversion Declarations. (line 27) * foreign_file/2: Interface Predicates. (line 44) * foreign_resource/2: Conversion Declarations. (line 9) * format (Tcl command): Commands over Strings. (line 14) * format-command: Message Phases. (line 14) * format/1 (xml_parse/3 option): XML. (line 69) * format/[2,3]: Term I/O. (line 268) * format_to_chars/[3,4] (charsio): Chars I/O. (line 24) * frame (Tk widget): Types of Widget. (line 23) * freeze/2: Coroutining. (line 29) * frozen/2: Coroutining. (line 40) * full_answer/0 (clpfd): Answer Constraints. (line 19) * Fully Qualified Classname: Jasper Library Predicates. (line 98) * function prototype: Function Prototypes. (line 6) * function, deinit <1>: Conversion Declarations. (line 9) * function, deinit: Glossary. (line 221) * function, init <1>: Glossary. (line 395) * function, init: Conversion Declarations. (line 9) * functor <1>: Glossary. (line 303) * functor: Compound Terms. (line 6) * functor/3: Meta Logic. (line 65) * garbage collection <1>: Glossary. (line 312) * garbage collection: State Info. (line 202) * garbage_collect/0: Misc Pred. (line 139) * garbage_collect_atoms/0: Misc Pred. (line 142) * garbage_collection (statistics/2 option): State Info. (line 477) * gauge: Gauge. (line 6) * gc (prolog flag) <1>: State Info. (line 202) * gc (prolog flag): Spaceout. (line 35) * gc/0: Misc Pred. (line 145) * gc_margin (prolog flag): State Info. (line 208) * gc_trace (prolog flag): State Info. (line 211) * gcd/2, greatest common divisor: Arithmetic. (line 134) * gen_assoc/3 (assoc): Assoc. (line 46) * gen_label/3 (trees): Trees. (line 17) * generalization/1 (cumulatives/3 option): Combinatorial Constraints. (line 451) * generalized predicate spec: Glossary. (line 317) * generate-and-test, use with cut: Terminating a Backtracking Loop. (line 6) * generate_message/3 (SU_messages): Message Handling Predicates. (line 51) * generate_message_hook/3 (user): Message Handling Predicates. (line 46) * generic breakpoint: Specific and Generic Breakpoints. (line 6) * generic object <1>: Generic Objects for Easy Reuse. (line 6) * generic object: Parameter Transfer. (line 6) * get/1 (debugger condition): Port Tests. (line 64) * get/1 (inlined method): Inlined Methods. (line 14) * get/1 (object method): The Proto-Object. (line 62) * get/[1,2]: Char I/O. (line 71) * get0/[1,2]: Char I/O. (line 66) * get_assoc/[3,5] (assoc): Assoc. (line 54) * get_atts/2 (Module): Attributes. (line 42) * get_byte/[1,2]: Char I/O. (line 61) * get_char/[1,2]: Char I/O. (line 52) * get_code/[1,2]: Char I/O. (line 43) * get_from_heap/4 (heaps): Heaps. (line 25) * get_label/3 (trees): Trees. (line 22) * get_mutable/2: Modify Term. (line 38) * get_next_assoc/4 (assoc): Assoc. (line 59) * get_prev_assoc/4 (assoc): Assoc. (line 63) * getrand/1 (random): Random. (line 33) * gets (Tcl command): File I/O. (line 47) * global (Tcl command): Global Variables. (line 13) * global constraint: The Global Constraint Programming Interface. (line 6) * global/1 (disjoint1/2 option): Combinatorial Constraints. (line 524) * global/1 (disjoint2/2 option): Combinatorial Constraints. (line 566) * global_cardinality/[2,3] (clpfd): Combinatorial Constraints. (line 24) * global_stack (statistics/2 option): State Info. (line 429) * GLOBALSTKSIZE (environment): Environment Variables. (line 32) * glue code: Glossary. (line 339) * GNU Emacs: Emacs Interface. (line 6) * goal <1>: Programs. (line 6) * goal: Glossary. (line 344) * goal, ancestor: Debug Format. (line 36) * goal, blocked <1>: Glossary. (line 70) * goal, blocked: Debug Format. (line 69) * goal, determinate: Cut. (line 12) * goal, parent: Cut. (line 12) * goal, unblocked: Glossary. (line 809) * goal/1 (debugger condition) <1>: Goal Tests. (line 17) * goal/1 (debugger condition): Breakpoint Tests. (line 12) * goal_expansion/3 (user): Term and Goal Expansion. (line 220) * goal_private/1 (debugger condition) <1>: Goal Tests. (line 33) * goal_private/1 (debugger condition): Storing User Information in the Backtrace. (line 6) * goal_source_info/3: Message Handling Predicates. (line 78) * grammar rule: Term and Goal Expansion. (line 17) * grammar, definite clause: Term and Goal Expansion. (line 12) * graphs, unweighted: UGraphs. (line 6) * graphs, weighted: WGraphs. (line 6) * green cut: Cut. (line 61) * ground: Glossary. (line 353) * ground/1: Meta Logic. (line 28) * guarded clause <1>: Glossary. (line 357) * guarded clause: Conditionals and Disjunction. (line 91) * halt/[0,1]: Misc Pred. (line 55) * handling, error <1>: Exception. (line 6) * handling, error: Exceptions Debug. (line 6) * handling, exception <1>: Exception. (line 6) * handling, exception: Exceptions Debug. (line 6) * handling, interrupt: Calling Prolog Asynchronously. (line 6) * handling, signal: Calling Prolog Asynchronously. (line 6) * has_attribute/1 (object method): The Proto-Object. (line 59) * has_instance/1 (object method): The Proto-Object. (line 56) * head <1>: Glossary. (line 361) * head: Programs. (line 17) * heap (statistics/2 option): State Info. (line 457) * heap_size/2 (heaps): Heaps. (line 38) * heap_to_list/2 (heaps): Heaps. (line 41) * heaps: Heaps. (line 6) * help (debugger command): Debug Commands. (line 333) * help (top-level command): Queries. (line 75) * help/0: Misc Pred. (line 183) * hidden module: Def Modules. (line 20) * hidden/1 (module/3 option): Def Modules. (line 20) * hide/0 (debugger condition): Condition Macros. (line 13) * hierarchy, object: Obj Hierarchies. (line 6) * hook functions for I/O: Hooks. (line 6) * hook predicate <1>: Glossary. (line 371) * hook predicate <2>: Multifile Declarations. (line 17) * hook predicate: Built Intro. (line 37) * hookable predicate <1>: Built Intro. (line 40) * hookable predicate: Glossary. (line 375) * Horn clause: Prolog Intro. (line 6) * host_id/1 (system): System Utilities. (line 119) * host_name/1 (system): System Utilities. (line 123) * host_type (prolog flag, volatile) <1>: State Info. (line 223) * host_type (prolog flag, volatile): Stream Pred. (line 306) * hostname_address/2 (sockets): Sockets. (line 136) * I/O hook functions: Hooks. (line 6) * I/O, character: Char I/O. (line 6) * I/O, term: Term I/O. (line 6) * idempotent/1 (fd_global/3 option): The Global Constraint Programming Interface. (line 108) * identifier, breakpoint: Creating Breakpoints. (line 31) * identifier, query: Opening and Closing a Query. (line 22) * if (Tcl command): Control Flow. (line 15) * if/1 (load_files/2 option): Read In. (line 65) * if/3: Control. (line 76) * ignore_ops/1 (write_term/[2,3] option): Term I/O. (line 224) * ignore_underscores/1 (absolute_file_name/3 option): Stream Pred. (line 28) * IID: Terminology. (line 18) * import: Glossary. (line 379) * importation: Importation. (line 6) * imported predicate: Basic Concepts. (line 12) * imports/1 (load_files/2 option): Read In. (line 90) * in/1 (linda_client): Client. (line 51) * in/2 (clpfd): Membership Constraints. (line 13) * in/2 (clpfd:dispatch_global/4 request): The Global Constraint Programming Interface. (line 54) * in/2 (linda_client): Client. (line 62) * in_noblock/1 (linda_client): Client. (line 56) * in_set/2 (clpfd): Membership Constraints. (line 18) * in_set/2 (clpfd:dispatch_global/4 request): The Global Constraint Programming Interface. (line 58) * IName: Terminology. (line 23) * include declaration: Include Declarations. (line 6) * include/1 (declaration): Include Declarations. (line 6) * incore/1: Control. (line 138) * incr (Tcl command): Commands to Do with Variables. (line 26) * increasing efficiency: Writing Efficient Programs. (line 6) * indented/1 (write_term/[2,3] option): Term I/O. (line 243) * independent_set/3 (ugraphs): UGraphs. (line 145) * indexed term: The DB-Spec Informal Description. (line 15) * indexical: Indexicals. (line 6) * indexicals: FDBG Events. (line 27) * indexicals, checking: Indexicals. (line 11) * indexicals, propagating: Indexicals. (line 11) * indexing <1>: Indexing. (line 6) * indexing: Glossary. (line 389) * indexing, determinacy detection via: Determinacy Detection. (line 6) * indomain/1 (clpfd): Enumeration Predicates. (line 14) * inf/0, infinity: Arithmetic. (line 255) * inf/[2,4] (clpqr): Solver Predicates. (line 84) * infix operator: Operators. (line 18) * information, source <1>: Usage. (line 17) * information, source: State Info. (line 286) * informational (prolog flag, volatile) <1>: State Info. (line 228) * informational (prolog flag, volatile): Start. (line 42) * inheritance <1>: Inheritance. (line 6) * inheritance <2>: Obj Intro. (line 6) * inheritance: Obj Hierarchies. (line 6) * inheritance by overriding: Obj Intro. (line 23) * inheritance, differential: Differential Inheritance. (line 6) * inheritance, multiple: Inheritance. (line 45) * init function <1>: Glossary. (line 395) * init function: Conversion Declarations. (line 9) * initialization <1>: Glossary. (line 399) * initialization: Initializations. (line 6) * initialization/1: Initializations. (line 6) * input: Input Output. (line 6) * input stream, current: Input Output. (line 71) * input/0 (stream property): Stream Pred. (line 469) * insert_constraint/[2,3] (chr): CHR Built-In Predicates. (line 18) * instance variable: Inheritance and Delegation. (line 12) * instance/1 (object method): The Proto-Object. (line 50) * instance/2: Modify Prog. (line 108) * instances: Instances. (line 6) * instances, object: Object Instances. (line 6) * instantiation: Glossary. (line 404) * instantiation_error/[0,2] (error class): Exception. (line 63) * int on PrologSession: PB Java Client Interface. (line 55) * int on Term: PB Java Client Interface. (line 143) * integer: Integers. (line 6) * integer, large: Glossary. (line 422) * integer, small: Glossary. (line 714) * integer/1: Meta Logic. (line 40) * integer/1, coercion: Arithmetic. (line 74) * integer_rounding_function (prolog flag, volatile): State Info. (line 238) * interface, emacs: Emacs Interface. (line 6) * interface, foreign language <1>: Mixing C and Prolog. (line 6) * interface, foreign language: Calling C from Prolog. (line 6) * internal encoding: WCX Concepts. (line 61) * internal encoding (of wide characters): Glossary. (line 408) * interoperability: Mixing C and Prolog. (line 6) * interpret: Glossary. (line 413) * interrupt character: Keyboard Characters. (line 13) * interrupt handling: Calling Prolog Asynchronously. (line 6) * interval-consistent: Definitions. (line 32) * interval-disentailed: Definitions. (line 37) * interval-entailed: Definitions. (line 37) * introductory message: Misc Pred. (line 162) * inv/1 (debugger condition) <1>: Breakpoint Tests. (line 120) * inv/1 (debugger condition) <2>: Past States. (line 19) * inv/1 (debugger condition): Goal Tests. (line 10) * invocation box <1>: Glossary. (line 419) * invocation box: Procedure Box. (line 103) * is/2: Arithmetic. (line 276) * is_array/1 (arrays): Arrays. (line 25) * is_assoc/1 (assoc): Assoc. (line 36) * is_fdset/1 (clpfd): FD Set Operations. (line 13) * is_heap/1 (heaps): Heaps. (line 45) * is_list/1 (lists): Lists. (line 24) * is_mutable/1 <1>: Meta Logic. (line 60) * is_mutable/1: Modify Term. (line 45) * is_ordset/1 (ordsets): Ordsets. (line 17) * is_queue/1 (queues): Queues. (line 29) * jasper_call/4 (jasper): Jasper Library Predicates. (line 73) * jasper_call_instance/6 (jasper): Deprecated Jasper Predicates. (line 40) * jasper_call_static/6 (jasper): Deprecated Jasper Predicates. (line 34) * jasper_create_global_ref/3 (jasper): Jasper Library Predicates. (line 152) * jasper_create_local_ref/3 (jasper): Jasper Library Predicates. (line 159) * jasper_deinitialize/1 (jasper): Jasper Library Predicates. (line 69) * jasper_delete_global_ref/2 (jasper): Jasper Library Predicates. (line 156) * jasper_delete_local_ref/2 (jasper): Jasper Library Predicates. (line 163) * jasper_initialize/[1,2] (jasper): Jasper Library Predicates. (line 8) * jasper_is_instance_of/3 (jasper): Jasper Library Predicates. (line 186) * jasper_is_jvm/1 (jasper): Jasper Library Predicates. (line 166) * jasper_is_object/[1,2] (jasper): Jasper Library Predicates. (line 170) * jasper_is_same_object/3 (jasper): Jasper Library Predicates. (line 179) * jasper_new_object/5 (jasper) <1>: Deprecated Jasper Predicates. (line 7) * jasper_new_object/5 (jasper): Jasper Library Predicates. (line 114) * jasper_null/2 (jasper): Jasper Library Predicates. (line 198) * jasper_object_class_name/3 (jasper): Jasper Library Predicates. (line 191) * Java Virtual Machine: Jasper Overview. (line 12) * JNDI: PB Features. (line 34) * join (Tcl command): Lists (Tcl). (line 110) * jump to port (debugger command): Debug Commands. (line 165) * JVM: Jasper Overview. (line 12) * kernel, runtime: Glossary. (line 674) * Key (Tk event type): Event Handling. (line 29) * keyboard: Keyboard Characters. (line 6) * KeyPress (Tk event type): Event Handling. (line 30) * KeyRelease (Tk event type): Event Handling. (line 33) * keysort/2: Term Compare. (line 100) * kill/2 (system): System Utilities. (line 129) * knapsack/3 (clpfd): Arithmetic Constraints. (line 49) * label (Tk widget): Types of Widget. (line 26) * labeling: FDBG Annotation. (line 17) * labeling event: FDBG Events. (line 13) * labeling levels: FDBG Labeling Levels. (line 6) * labeling/1 (clpb): CLPB Interface. (line 25) * labeling/2 (clpfd): Enumeration Predicates. (line 19) * language (prolog flag) <1>: ISO Compliance. (line 14) * language (prolog flag) <2>: The Application Builder. (line 270) * language (prolog flag) <3>: Start. (line 36) * language (prolog flag): State Info. (line 241) * large integer: Glossary. (line 422) * last (order_resource/2 option): Enumeration Predicates. (line 209) * last call optimization: Last Call Optimization. (line 6) * last clause determinacy detection: Last Clause Determinacy Detection. (line 6) * last/2 (lists): Lists. (line 27) * later_bound/2 (clpfd): Enumeration Predicates. (line 109) * layout term: Term I/O. (line 66) * layout/1 (read_term/[2,3] option): Term I/O. (line 66) * lct(order_resource/2 option): Enumeration Predicates. (line 227) * leap: Glossary. (line 425) * leap (debugger command): Debug Commands. (line 59) * leash/0 (debugger condition): Condition Macros. (line 16) * leash/1 <1>: Basic Debug. (line 44) * leash/1: Debug Pred. (line 46) * leashing: Glossary. (line 431) * Leave (Tk event type): Event Handling. (line 46) * leaves/2 (case/4 spec): Combinatorial Constraints. (line 114) * leftmost (labeling/2 option): Enumeration Predicates. (line 51) * legend: FDBG Legend. (line 6) * legend_portray/3 (fdbg): FDBG Customizing Output. (line 24) * length/2: Misc Pred. (line 17) * levels, labeling: FDBG Labeling Levels. (line 6) * lex_chain/[1,2] (clpfd): Combinatorial Constraints. (line 659) * lexical scope: Programs. (line 65) * library: The Prolog Library. (line 8) * library_directory/1 (user): Stream Pred. (line 317) * Linda: Linda Library. (line 6) * linda/[0,1] (linda): Server. (line 17) * linda_client/1 (linda_client): Client. (line 18) * linda_timeout/2 (linda_client): Client. (line 41) * lindex (Tcl command): Lists (Tcl). (line 66) * line breakpoint: Usage. (line 125) * line, end of: Stream Pred. (line 544) * line/1 (debugger condition) <1>: Source Tests. (line 20) * line/1 (debugger condition): Breakpoint Tests. (line 223) * line/2 (debugger condition) <1>: Source Tests. (line 16) * line/2 (debugger condition): Breakpoint Tests. (line 223) * line_count/2: Stream Pred. (line 437) * line_position/2: Stream Pred. (line 441) * linked foreign resource <1>: Creating the Linked Foreign Resource. (line 6) * linked foreign resource <2>: Glossary. (line 436) * linked foreign resource: Foreign Resources. (line 6) * linker, foreign resource: The Foreign Resource Linker. (line 6) * linsert (Tcl command): Lists (Tcl). (line 71) * list <1>: Glossary. (line 440) * list: Compound Terms. (line 47) * list (Tcl command): Lists (Tcl). (line 76) * list of variables: FDBG Legend. (line 6) * list_queue/2 (queues): Queues. (line 62) * list_to_assoc/2 (assoc): Assoc. (line 67) * list_to_fdset/2 (clpfd): FD Set Operations. (line 51) * list_to_heap/2 (heaps): Heaps. (line 48) * list_to_ord_set/2 (ordsets): Ordsets. (line 20) * list_to_tree/2 (trees): Trees. (line 25) * listbox (Tk widget): Types of Widget. (line 29) * listing/[0,1]: State Info. (line 7) * lists: Lists. (line 6) * llength (Tcl command): Lists (Tcl). (line 80) * load: Glossary. (line 460) * load context: State Info. (line 385) * load/1: Read In. (line 124) * load_files/[1,2] <1>: Read In. (line 57) * load_files/[1,2]: Load Predicates. (line 73) * load_foreign_files/2: Interface Predicates. (line 49) * load_foreign_resource/1: Interface Predicates. (line 7) * load_type/1 (load_files/2 option): Read In. (line 83) * loading <1>: Read In. (line 55) * loading: Load Intro. (line 6) * local_stack (statistics/2 option): State Info. (line 435) * LOCALSTKSIZE (environment): Environment Variables. (line 35) * locks, mutual exclusion: OS Threads. (line 11) * log/1, logarithm: Arithmetic. (line 241) * log/2, logarithm: Arithmetic. (line 244) * logic programming: Intro. (line 12) * long on Term: PB Java Client Interface. (line 146) * loop, repeat: I/O Example. (line 19) * lrange (Tcl command): Lists (Tcl). (line 84) * lreplace (Tcl command): Lists (Tcl). (line 89) * lsearch (Tcl command): Lists (Tcl). (line 94) * lsort (Tcl command): Lists (Tcl). (line 100) * lst (order_resource/2 option): Enumeration Predicates. (line 221) * macro expansion: Term and Goal Expansion. (line 220) * main thread: Calling Prolog Asynchronously. (line 6) * make_directory/1 (system): System Utilities. (line 53) * make_index:make_library_index/1: The Prolog Library. (line 155) * make_library_index/1 (make_index): The Prolog Library. (line 155) * map_assoc/[2,3] (assoc): Assoc. (line 77) * map_tree/3 (trees): Trees. (line 29) * mapping, character-type: WCX Concepts. (line 46) * margin/3 (disjoint1/2 option): Combinatorial Constraints. (line 535) * margin/4 (disjoint2/2 option): Combinatorial Constraints. (line 588) * max (labeling/2 option): Enumeration Predicates. (line 58) * max/1 (case/4 spec): Combinatorial Constraints. (line 141) * max/1 (fd_global/3 spec): The Global Constraint Programming Interface. (line 88) * max/2, maximum value: Arithmetic. (line 141) * max_arity (prolog flag, volatile): State Info. (line 247) * max_assoc/3 (assoc): Assoc. (line 43) * max_depth/1 (write_term/[2,3] option): Term I/O. (line 247) * max_integer (prolog flag, volatile): State Info. (line 253) * max_inv/1 (debugger condition) <1>: Break Tests. (line 14) * max_inv/1 (debugger condition): Accessing Past Debugger States. (line 84) * max_list/2 (lists): Lists. (line 34) * max_path/5 (ugraphs): UGraphs. (line 103) * max_path/5 (wgraphs): WGraphs. (line 102) * maximize/1 (clpqr): Solver Predicates. (line 115) * maximize/1 (labeling/2 option): Enumeration Predicates. (line 142) * maximize/2 (clpfd): Enumeration Predicates. (line 31) * member/2 (lists): Lists. (line 37) * memberchk/2 (lists): Lists. (line 51) * memory (statistics/2 option): State Info. (line 451) * memory, address-constrained: Initializing the Prolog Engine. (line 63) * menu (Tk widget): Types of Widget. (line 32) * menubutton (Tk widget): Types of Widget. (line 35) * message (Tk widget): Types of Widget. (line 38) * message delegation: Obj Self. (line 6) * message sending: Obj Self. (line 6) * message, introductory: Misc Pred. (line 162) * message_hook/3 (user): Message Handling Predicates. (line 60) * messages, debugging: Debug Format. (line 6) * messages, suppressing: Exception. (line 6) * meta-call: Glossary. (line 464) * meta-logical predicate <1>: Meta Logic. (line 6) * meta-logical predicate: Glossary. (line 468) * meta-predicate: Glossary. (line 474) * meta-predicate declaration <1>: Meta-Predicate Declarations. (line 6) * meta-predicate declaration: Meta Decl. (line 6) * meta_predicate/1 (declaration) <1>: Meta-Predicate Declarations. (line 6) * meta_predicate/1 (declaration): Meta Decl. (line 6) * method: Obj Intro. (line 23) * method, dynamic: Dynamic Methods. (line 6) * method/3 (Java method identifier): Jasper Library Predicates. (line 94) * method_expansion/3 (user): Object Declaration. (line 36) * methods/1 (utility method): The Utility Object. (line 25) * min (labeling/2 option): Enumeration Predicates. (line 54) * min/1 (case/4 spec): Combinatorial Constraints. (line 137) * min/1 (fd_global/3 spec): The Global Constraint Programming Interface. (line 85) * min/2, minimum value: Arithmetic. (line 138) * min_assoc/3 (assoc): Assoc. (line 40) * min_integer (prolog flag, volatile): State Info. (line 259) * min_list/2 (lists): Lists. (line 61) * min_of_heap/[3,5] (heaps): Heaps. (line 55) * min_path/5 (ugraphs): UGraphs. (line 107) * min_path/5 (wgraphs): WGraphs. (line 107) * min_paths/3 (ugraphs): UGraphs. (line 111) * min_paths/3 (wgraphs): WGraphs. (line 111) * min_tree/3 (ugraphs): UGraphs. (line 138) * min_tree/3 (wgraphs): WGraphs. (line 140) * minimize/1 (clpqr): Solver Predicates. (line 110) * minimize/1 (labeling/2 option): Enumeration Predicates. (line 142) * minimize/2 (clpfd): Enumeration Predicates. (line 31) * minmax/1 (case/4 spec): Combinatorial Constraints. (line 145) * minmax/1 (fd_global/3 spec): The Global Constraint Programming Interface. (line 91) * mixing C/C++ and Prolog: Mixing C and Prolog. (line 6) * mktemp/2 (system): System Utilities. (line 132) * mod/2, integer modulus: Arithmetic. (line 71) * mod_time/1 (file_property/2 property): System Utilities. (line 109) * mode declaration: Mode Declarations. (line 6) * mode spec <1>: Glossary. (line 480) * mode spec: Mode Spec. (line 6) * mode, WCX: WCX Concepts. (line 78) * mode/1 (debugger condition) <1>: Port Tests. (line 42) * mode/1 (debugger condition) <2>: Action Conditions. (line 10) * mode/1 (debugger condition): Breakpoint Actions. (line 12) * mode/1 (declaration): Mode Declarations. (line 6) * mode/1 (stream property): Stream Pred. (line 466) * module: Glossary. (line 484) * module (load_context/2 key): State Info. (line 405) * module declaration: Module Declarations. (line 6) * module name expansion <1>: Mode Spec. (line 12) * module name expansion <2>: Glossary. (line 489) * module name expansion <3>: Meta-Predicate Declarations. (line 15) * module name expansion: Meta Exp. (line 6) * module system: Module Intro. (line 6) * module, hidden: Def Modules. (line 20) * module, object: Obj Expand. (line 15) * module, source <1>: Glossary. (line 722) * module, source: Basic Concepts. (line 14) * module, type-in <1>: State Info. (line 331) * module, type-in <2>: Basic Concepts. (line 19) * module, type-in: Glossary. (line 806) * module-file <1>: Def Modules. (line 14) * module-file: Glossary. (line 493) * module/1: State Info. (line 77) * module/1 (debugger condition): Goal Tests. (line 29) * module/2 (declaration) <1>: Module Declarations. (line 6) * module/2 (declaration): Def Modules. (line 7) * module/3 (declaration) <1>: Def Modules. (line 9) * module/3 (declaration): Module Declarations. (line 6) * most general unifier: Procedural. (line 66) * Motion (Tk event type): Event Handling. (line 49) * msb/1, most significant bit: Arithmetic. (line 144) * multifile declaration <1>: Load Predicates. (line 18) * multifile declaration: Multifile Declarations. (line 6) * multifile predicate: Glossary. (line 501) * multifile/1 (declaration): Multifile Declarations. (line 6) * multiple inheritance: Inheritance. (line 45) * mutable: Terminology. (line 70) * mutable term <1>: Modify Term. (line 21) * mutable term: Glossary. (line 506) * mutex: OS Threads. (line 11) * mutual exclusion locks: OS Threads. (line 11) * name auto-generation: FDBG Name Auto-Generation. (line 6) * name clash: Glossary. (line 511) * name variable (debugger command): FDBG Debugger Commands. (line 30) * name/1 (tk_new/2 option): Creating a Tcl Interpreter Extended with Tk. (line 32) * name/2: Meta Logic. (line 106) * names of terms <1>: FDBG Names of Terms. (line 6) * names of terms: FDBG Naming Terms. (line 6) * nan/0, not-a-number: Arithmetic. (line 258) * neighbors/3 (ugraphs): UGraphs. (line 77) * neighbors/3 (wgraphs): WGraphs. (line 82) * neighbours/3 (ugraphs): UGraphs. (line 77) * neighbours/3 (wgraphs): WGraphs. (line 82) * nested execution: Nested. (line 6) * network path: Input Output. (line 147) * new/1 (object method) <1>: The Proto-Object. (line 37) * new/1 (object method): Object Creation. (line 6) * new/2 (object method) <1>: Object Creation. (line 11) * new/2 (object method): The Proto-Object. (line 42) * new_array/1 (arrays): Arrays. (line 18) * newProlog on Jasper: Java Threads. (line 19) * newProlog on SICStus: Java Threads. (line 31) * nextSolution on SPQuery: Jasper Package Class Reference. (line 138) * nextto/3 (lists): Lists. (line 64) * nl/[0,1]: Char I/O. (line 37) * no_doubles/1 (lists): Lists. (line 76) * nodebug (debugger command): Debug Commands. (line 218) * nodebug/0 <1>: Debug Pred. (line 43) * nodebug/0: Basic Debug. (line 86) * noexpand/0 (clpqr): Syntactic Sugar. (line 59) * nofileerrors/0: Stream Pred. (line 554) * nogc/0: Misc Pred. (line 148) * non-backtraced tests: Breakpoint Conditions. (line 13) * non-terminal: Syntax Notation. (line 6) * non_member/2 (lists): Lists. (line 80) * nondeterminacy, declaring: Declaring Nondeterminacy. (line 6) * nondeterminacy, finding: The Determinacy Checker. (line 6) * none/1 (case/4 spec): Combinatorial Constraints. (line 153) * nonvar/1: Meta Logic. (line 24) * nospy this (debugger command): Debug Commands. (line 238) * nospy/1 <1>: Plain Spypoint. (line 40) * nospy/1: Debug Pred. (line 57) * nospyall/0 <1>: Debug Pred. (line 61) * nospyall/0: Plain Spypoint. (line 45) * notation: Notation. (line 6) * notify_constrained/1 (chr): CHR Built-In Predicates. (line 63) * notrace/0 <1>: Basic Debug. (line 86) * notrace/0: Debug Pred. (line 43) * now/1 (system): System Utilities. (line 22) * nozip/0 <1>: Debug Pred. (line 43) * nozip/0: Basic Debug. (line 86) * nth/[3,4] (lists): Lists. (line 84) * nth0/[3,4] (lists): Lists. (line 95) * null/0 (exec/3 stream spec): System Utilities. (line 67) * number/1: Meta Logic. (line 43) * number_chars/2: Meta Logic. (line 172) * number_codes/2: Meta Logic. (line 158) * number_to_chars/[2,3] (charsio): Chars I/O. (line 53) * numbervars/1 (write_term/[2,3] option): Term I/O. (line 233) * numbervars/3: Misc Pred. (line 28) * object: Obj Intro. (line 23) * Object: Terminology. (line 29) * object (built-in object): The Proto-Object. (line 6) * object attributes: Object Attributes. (line 6) * object hierarchy: Obj Hierarchies. (line 6) * object instances: Object Instances. (line 6) * object module: Obj Expand. (line 15) * object, dynamic <1>: Dynamically Declared Objects. (line 6) * object, dynamic <2>: Obj Intro. (line 23) * object, dynamic: Obj Dynamic. (line 6) * object, generic <1>: Parameter Transfer. (line 6) * object, generic: Generic Objects for Easy Reuse. (line 6) * object, parameterized <1>: Generic Objects for Easy Reuse. (line 6) * object, parameterized: Parameter Transfer. (line 6) * object, static <1>: Dynamically Declared Objects. (line 6) * object, static: Obj Intro. (line 23) * object-oriented programming: Obj Intro. (line 6) * object/1 (object method): The Proto-Object. (line 22) * objects/1 (utility method): The Utility Object. (line 16) * occurs-check <1>: Glossary. (line 515) * occurs-check <2>: Term Utilities. (line 6) * occurs-check: Occur. (line 6) * off (debug flag value): State Info. (line 156) * off (debugging flag value): State Info. (line 146) * off (gc_trace flag value): State Info. (line 220) * off/0 (debugger mode control): Action Variables. (line 144) * on/1 (all_different/2 option): Combinatorial Constraints. (line 243) * on/1 (all_distinct/2 option): Combinatorial Constraints. (line 243) * on/1 (assignment/3 option): Combinatorial Constraints. (line 297) * on/1 (case/4 spec): Combinatorial Constraints. (line 121) * on_exception/3: Exception. (line 15) * once/1: Control. (line 89) * one-char atom: Glossary. (line 519) * op/3 <1>: Misc Pred. (line 64) * op/3 <2>: Operators. (line 6) * op/3: Standard Operators. (line 6) * open (Tcl command): File I/O. (line 11) * open/[3,4]: Stream Pred. (line 327) * open_chars_stream/2 (charsio): Chars I/O. (line 69) * open_null_stream/1: Stream Pred. (line 422) * openQuery on SICStus: Jasper Package Class Reference. (line 109) * operating system: System Utilities. (line 6) * operator: Glossary. (line 522) * operator declaration: Declarations. (line 18) * operator, infix: Operators. (line 18) * operator, postfix: Operators. (line 18) * operator, prefix: Operators. (line 18) * operators <1>: Misc Pred. (line 64) * operators <2>: Operators. (line 6) * operators: Standard Operators. (line 6) * optimization, last call: Last Call Optimization. (line 6) * or_cast/2 (utility method): The Utility Object. (line 67) * ord_add_element/3 (ordsets): Ordsets. (line 27) * ord_del_element/3 (ordsets): Ordsets. (line 34) * ord_disjoint/2 (ordsets): Ordsets. (line 37) * ord_intersect/2 (ordsets): Ordsets. (line 40) * ord_intersection/[2,3,4] (ordsets): Ordsets. (line 43) * ord_list_to_assoc/2 (assoc): Assoc. (line 72) * ord_member/2 (ordsets): Ordsets. (line 58) * ord_seteq/2 (ordsets): Ordsets. (line 61) * ord_setproduct/3 (ordsets): Ordsets. (line 65) * ord_subset/2 (ordsets): Ordsets. (line 73) * ord_subtract/3 (ordsets): Ordsets. (line 77) * ord_symdiff/3 (ordsets): Ordsets. (line 84) * ord_union/[2,3,4] (ordsets): Ordsets. (line 90) * order, standard: Term Compare. (line 6) * order_resource/2 (clpfd): Enumeration Predicates. (line 194) * ordered sets: Ordsets. (line 6) * ordering/1 (clpqr) <1>: Solver Predicates. (line 174) * ordering/1 (clpqr): Variable Ordering. (line 6) * otherwise/0: Control. (line 97) * out (debugger command): Debug Commands. (line 86) * out/1 (linda_client): Client. (line 48) * output: Input Output. (line 6) * output stream, current: Input Output. (line 71) * output/0 (stream property): Stream Pred. (line 472) * overflow (FD flag): The Global Constraint Programming Interface. (line 131) * overriding, inheritance by: Obj Intro. (line 23) * pair: Glossary. (line 552) * parameter, accumulating: Accumulating Parameters. (line 6) * parameterized object <1>: Generic Objects for Easy Reuse. (line 6) * parameterized object: Parameter Transfer. (line 6) * parent: Glossary. (line 556) * parent goal: Cut. (line 12) * parent_clause/1 (debugger condition) <1>: Breakpoint Tests. (line 263) * parent_clause/1 (debugger condition): Source Tests. (line 23) * parent_clause/2 (debugger condition) <1>: Breakpoint Tests. (line 263) * parent_clause/2 (debugger condition): Source Tests. (line 26) * parent_clause/3 (debugger condition) <1>: Breakpoint Tests. (line 263) * parent_clause/3 (debugger condition): Source Tests. (line 30) * parent_inv/1 (debugger condition) <1>: Goal Tests. (line 44) * parent_inv/1 (debugger condition): Accessing Past Debugger States. (line 126) * parent_pred/1 (debugger condition) <1>: Source Tests. (line 36) * parent_pred/1 (debugger condition): Breakpoint Tests. (line 236) * parent_pred/2 (debugger condition) <1>: Breakpoint Tests. (line 236) * parent_pred/2 (debugger condition): Source Tests. (line 39) * partner constraint: How CHR Work. (line 6) * path, file search <1>: Stream Pred. (line 295) * path, file search: Input Output. (line 92) * path, network: Input Output. (line 147) * path/3 (ugraphs): UGraphs. (line 116) * path/3 (wgraphs): WGraphs. (line 116) * path_consistency/1 (cumulative/5 option): Combinatorial Constraints. (line 374) * path_consistency/1 (serialized/3 option): Combinatorial Constraints. (line 374) * peek_byte/[1,2]: Char I/O. (line 94) * peek_char/[1,2]: Char I/O. (line 84) * peek_code/[1,2]: Char I/O. (line 77) * permission_error/[3,5] (error class): Exception. (line 84) * permutation/2 (lists): Lists. (line 107) * phrase/[2,3]: Term and Goal Expansion. (line 255) * pid/1 (system): System Utilities. (line 126) * pipe/1 (exec/3 stream spec): System Utilities. (line 78) * placement of cut: Placement of Cuts. (line 6) * plain spypoint <1>: Creating Breakpoints. (line 16) * plain spypoint: Plain Spypoint. (line 6) * PO file: Glossary. (line 617) * PO File: Load Predicates. (line 57) * popen/3 (system): System Utilities. (line 138) * port: Glossary. (line 561) * port debugger: Procedure Box. (line 35) * port, debugger: Port Tests. (line 11) * port/1 (debugger condition) <1>: Breakpoint Tests. (line 301) * port/1 (debugger condition): Port Tests. (line 23) * port/1 (start/1 option): PB Prolog Server Interface. (line 19) * portray/1 (clpqr): Rationals. (line 10) * portray/1 (user): Term I/O. (line 196) * portray_clause/[1,2]: Term I/O. (line 202) * portray_message/2 (user): Message Handling Predicates. (line 40) * portrayed/1 (write_term/[2,3] option): Term I/O. (line 229) * position, stream: Glossary. (line 763) * position/1 (stream property): Stream Pred. (line 478) * postfix operator: Operators. (line 18) * posting constraints: Posting Constraints. (line 6) * pre-linked foreign resource: Glossary. (line 565) * pre-linked resource: Foreign Resources. (line 42) * precedence: Glossary. (line 569) * precedences/1 (cumulative/5 option): Combinatorial Constraints. (line 353) * precedences/1 (serialized/3 option): Combinatorial Constraints. (line 353) * pred/1 (debugger condition) <1>: Goal Tests. (line 24) * pred/1 (debugger condition): Creating Breakpoints. (line 16) * predicate <1>: Programs. (line 11) * predicate <2>: Glossary. (line 579) * predicate: Programs. (line 93) * predicate (profile_data/4 resolution): Profiling. (line 81) * predicate declaration: Declarations. (line 6) * predicate spec: Glossary. (line 587) * predicate spec, generalized: Glossary. (line 317) * predicate, built-in <1>: Programs. (line 110) * predicate, built-in: Glossary. (line 96) * predicate, dynamic: Glossary. (line 244) * predicate, exported: Basic Concepts. (line 12) * predicate, extendible <1>: Glossary. (line 367) * predicate, extendible: Built Intro. (line 34) * predicate, FD <1>: User-Defined Constraints. (line 17) * predicate, FD: FD Predicates. (line 6) * predicate, foreign: Glossary. (line 295) * predicate, hook <1>: Built Intro. (line 37) * predicate, hook <2>: Multifile Declarations. (line 17) * predicate, hook: Glossary. (line 371) * predicate, hookable <1>: Built Intro. (line 40) * predicate, hookable: Glossary. (line 375) * predicate, imported: Basic Concepts. (line 12) * predicate, meta-logical <1>: Glossary. (line 468) * predicate, meta-logical: Meta Logic. (line 6) * predicate, multifile: Glossary. (line 501) * predicate, private: Basic Concepts. (line 12) * predicate, public: Basic Concepts. (line 12) * predicate, static: Glossary. (line 750) * predicate, undefined <1>: Undefined Predicates. (line 6) * predicate, undefined <2>: State Info. (line 334) * predicate, undefined: Exception. (line 130) * predicate_property/2: State Info. (line 37) * predicates debugging, CHR: CHR Debugging Predicates. (line 6) * predicates, breakpoint handling: Breakpoint Predicates. (line 6) * predicates, debugging: Basic Debug. (line 6) * prefix operator: Operators. (line 18) * prefix/2 (lists): Lists. (line 110) * print (debugger command): Debug Commands. (line 174) * print/0 (debugger show control): Action Variables. (line 16) * print/[1,2]: Term I/O. (line 167) * print_message/2: Message Handling Predicates. (line 7) * print_message_lines/3: Message Handling Predicates. (line 67) * priority queues: Heaps. (line 6) * priority/1 (write_term/[2,3] option): Term I/O. (line 262) * private predicate: Basic Concepts. (line 12) * private/1 (debugger condition) <1>: Storing User Information in the Backtrace. (line 6) * private/1 (debugger condition): Break Tests. (line 19) * proc (Tcl command): User Defined Procedures. (line 13) * procedural semantics: Procedural. (line 6) * procedure: Glossary. (line 591) * procedure box <1>: Procedure Box. (line 6) * procedure box: Glossary. (line 601) * procedure call: Procedural. (line 66) * procedure definition: Procedural. (line 61) * proceed/0 (debugger command control): Action Variables. (line 41) * proceed/2 (debugger command control): Action Variables. (line 51) * process communication <1>: Sockets. (line 6) * process communication: Linda Library. (line 6) * processing, breakpoint: Breakpoint Processing. (line 6) * profile_data/4: Profiling. (line 38) * profile_reset/1: Profiling. (line 101) * profiledcode: Glossary. (line 605) * profiledcode (compiling flag value) <1>: State Info. (line 124) * profiledcode (compiling flag value): Load Intro. (line 41) * profiling <1>: Glossary. (line 609) * profiling: Gauge. (line 6) * profiling, execution: Profiling. (line 6) * ProgID: Terminology. (line 7) * program <1>: Glossary. (line 614) * program: Programs. (line 6) * program (statistics/2 option): State Info. (line 458) * program state <1>: State Info. (line 6) * program state: Saving. (line 6) * programming in logic: Intro. (line 12) * programming, access driven: Obj Daemons. (line 6) * programming, object-oriented: Obj Intro. (line 6) * project_attributes/2 (Module): Attributes. (line 127) * projecting_assert/1 (clpqr): Solver Predicates. (line 212) * Prolog flag: State Info. (line 380) * prolog_flag/[2,3]: State Info. (line 81) * prolog_load_context/2: State Info. (line 385) * PrologCloseQuery (VB function): Summary of the Interface Functions. (line 14) * PrologDeInit (VB function): Summary of the Interface Functions. (line 69) * PrologGetException (VB function): Summary of the Interface Functions. (line 60) * PrologGetLong (VB function): Summary of the Interface Functions. (line 30) * PrologGetString (VB function): Summary of the Interface Functions. (line 38) * PrologGetStringQuoted (VB function): Summary of the Interface Functions. (line 48) * PROLOGINCSIZE (environment): Environment Variables. (line 50) * PrologInit (VB function): Summary of the Interface Functions. (line 65) * PROLOGINITSIZE (environment): Environment Variables. (line 44) * PROLOGKEEPSIZE (environment): Environment Variables. (line 54) * PROLOGMAXSIZE (environment): Environment Variables. (line 47) * PrologNextSolution (VB function): Summary of the Interface Functions. (line 20) * PrologOpenQuery (VB function): Summary of the Interface Functions. (line 9) * PrologQueryCutFail (VB function): Summary of the Interface Functions. (line 54) * PrologSession on PrologSession: PB Java Client Interface. (line 31) * prompt/2: Misc Pred. (line 151) * propagating indexicals: Indexicals. (line 11) * propagation CHR: CHR Introduction. (line 32) * prototype: Obj Intro. (line 6) * prototype, function: Function Prototypes. (line 6) * prune/1 (case/4 spec): Combinatorial Constraints. (line 125) * prune/1 (cumulatives/3 option): Combinatorial Constraints. (line 445) * prunings (fd_statistics/2 option): Statistics Predicates. (line 27) * public declaration: Public Declarations. (line 6) * public predicate: Basic Concepts. (line 12) * public/1 (declaration): Public Declarations. (line 6) * put/[1,2]: Char I/O. (line 127) * put_assoc/4 (assoc): Assoc. (line 86) * put_atts/2 (Module): Attributes. (line 56) * put_byte/[1,2]: Char I/O. (line 123) * put_char/[1,2]: Char I/O. (line 118) * put_code/[1,2]: Char I/O. (line 114) * put_label/[4,5] (trees): Trees. (line 33) * puts (Tcl command): File I/O. (line 57) * QL File: Load Predicates. (line 57) * QL file: Glossary. (line 624) * qskip/1 (debugger mode control): Action Variables. (line 122) * quasi-skip (debugger command): Debug Commands. (line 94) * query <1>: Glossary. (line 630) * query <2>: Start. (line 110) * query: Queries and Directives. (line 6) * query identifier: Opening and Closing a Query. (line 22) * query on SICStus: Jasper Package Class Reference. (line 81) * query, floundered: Glossary. (line 292) * query_abbreviation/3 (SU_messages): Query Handling Predicates. (line 117) * query_class/5 (SU_messages): Query Handling Predicates. (line 89) * query_class_hook/5 (user): Query Handling Predicates. (line 83) * query_hook/6 (user): Query Handling Predicates. (line 77) * query_input/3 (SU_messages): Query Handling Predicates. (line 143) * query_input_hook/3 (user): Query Handling Predicates. (line 137) * query_map/4 (SU_messages): Query Handling Predicates. (line 157) * query_map_hook/4 (user): Query Handling Predicates. (line 151) * QueryAnswer on PrologSession: PB Java Client Interface. (line 74) * queryCutFail on SICStus: Jasper Package Class Reference. (line 104) * queue/2 (queues): Queues. (line 32) * queue_head/3 (queues): Queues. (line 35) * queue_head_list/3 (queues): Queues. (line 46) * queue_last/3 (queues): Queues. (line 50) * queue_last_list/3 (queues): Queues. (line 54) * queue_length/2 (queues): Queues. (line 69) * queues: Queues. (line 6) * quiet (syntax_errors flag value): State Info. (line 315) * quoted/1 (write_term/[2,3] option): Term I/O. (line 219) * radiobutton (Tk widget): Types of Widget. (line 41) * raise exception (debugger command): Debug Commands. (line 309) * raise_exception/1: Exception. (line 15) * random numbers: Random. (line 6) * random/[1,3] (random): Random. (line 14) * random_ugraph/3 (ugraphs): UGraphs. (line 131) * random_wgraph/4 (wgraphs): WGraphs. (line 133) * randseq/3 (random): Random. (line 24) * randset/3 (random): Random. (line 29) * range_to_fdset/2 (clpfd): FD Set Operations. (line 59) * rd/[1,2] (linda_client): Client. (line 68) * rd_noblock/1 (linda_client): Client. (line 73) * reachable/3 (ugraphs): UGraphs. (line 126) * reachable/3 (wgraphs): WGraphs. (line 128) * read (open/[3,4] mode): Stream Pred. (line 333) * read (Tcl command): File I/O. (line 40) * read/[1,2]: Term I/O. (line 24) * read_from_chars/2 (charsio): Chars I/O. (line 59) * read_line/[1,2]: Char I/O. (line 108) * read_term/[2,3]: Term I/O. (line 35) * read_term_from_chars/3 (charsio): Chars I/O. (line 64) * reading in: Reading In. (line 6) * reconsult: Consult. (line 6) * reconsult/1: Read In. (line 113) * recorda/3: Database. (line 33) * recorded/3: Database. (line 23) * recordz/3: Database. (line 41) * recursion: Glossary. (line 648) * red cut: Cut. (line 61) * redefine_warnings (prolog flag) <1>: State Info. (line 278) * redefine_warnings (prolog flag) <2>: Read In. (line 48) * redefine_warnings (prolog flag) <3>: Runtime Systems. (line 32) * redefine_warnings (prolog flag): Importation. (line 22) * redo (leashing mode): Basic Debug. (line 61) * redo/0 (debugger port value): Port Tests. (line 13) * redo/1 (debugger command control): Action Variables. (line 107) * reduce/2 (ugraphs): UGraphs. (line 120) * reduce/2 (wgraphs): WGraphs. (line 121) * reexit/1 (debugger command control): Action Variables. (line 100) * reference, database <1>: Modify Prog. (line 53) * reference, database: Glossary. (line 205) * reference, term: Mixing C and Prolog. (line 14) * regexp (Tcl command): Commands over Strings. (line 63) * region: Glossary. (line 653) * register_event_listener/[2,3] (prologbeans): PB Prolog Server Interface. (line 114) * register_query/1: PB Prolog Server Interface. (line 80) * register_query/[2,3] (prologbeans): PB Prolog Server Interface. (line 69) * regsub (Tcl command): Commands over Strings. (line 107) * reification: Reified Constraints. (line 17) * reject (top-level command): Queries. (line 44) * relation/3 (clpfd): Combinatorial Constraints. (line 64) * relative_to/1 (absolute_file_name/3 option): Stream Pred. (line 146) * rem/2, integer remainder: Arithmetic. (line 60) * remove this (debugger command): Debug Commands. (line 246) * remove_attribute_prefixes/1 (xml_parse/3 option): XML. (line 76) * remove_breakpoints/1 <1>: Built-in Predicates for Breakpoint Handling. (line 43) * remove_breakpoints/1 <2>: Debug Pred. (line 79) * remove_breakpoints/1: Breakpoint Predicates. (line 74) * remove_constraint/1 (chr): CHR Built-In Predicates. (line 53) * remove_duplicates/2 (lists): Lists. (line 114) * rename_file/2 (system): System Utilities. (line 147) * repeat loop: I/O Example. (line 19) * repeat/0: Control. (line 108) * reposition/1 (open/4 option): Stream Pred. (line 355) * representation_error/[1,3] (error class): Exception. (line 104) * require/1: Read In. (line 174) * reset (open/4 eof_action value): Stream Pred. (line 375) * reset printdepth (debugger command): Debug Commands. (line 315) * reset printdepth (top-level command): Queries. (line 53) * reset subterm (debugger command): Debug Commands. (line 329) * reset subterm (top-level command): Queries. (line 63) * resource, data: The Application Builder. (line 192) * resource, dynamic: Foreign Resources. (line 33) * resource, foreign <1>: Glossary. (line 300) * resource, foreign: Foreign Resources. (line 6) * resource, linked foreign: Glossary. (line 436) * resource, pre-linked: Foreign Resources. (line 42) * resource, static: Foreign Resources. (line 33) * resource/1 (cumulative/5 option): Combinatorial Constraints. (line 369) * resource/1 (serialized/3 option): Combinatorial Constraints. (line 369) * resource_error/[1,2] (error class): Exception. (line 116) * restart/0 (utility method): The Utility Object. (line 60) * restore/1 <1>: Saving. (line 23) * restore/1: Misc Pred. (line 133) * restoring: Saving. (line 6) * resumptions (fd_statistics/2 option): Statistics Predicates. (line 20) * retract/1: Modify Prog. (line 75) * retract/1 (object method): The Proto-Object. (line 88) * retractall/1: Modify Prog. (line 81) * retractall/1 (object method): The Proto-Object. (line 97) * retracted clause: Modify Prog. (line 6) * retry (debugger command): Debug Commands. (line 117) * retry/1 (debugger command control): Action Variables. (line 94) * return (Tcl command): User Defined Procedures. (line 87) * reverse/2 (lists): Lists. (line 123) * rewriting, syntactic: Input Output. (line 86) * round/1, function: Arithmetic. (line 151) * rule <1>: Programs. (line 37) * rule: Glossary. (line 657) * rule, computation: Procedural. (line 66) * rule, constraint handling: CHR Introduction. (line 6) * rule, grammar: Term and Goal Expansion. (line 17) * rule, search: Procedural. (line 66) * running: Start. (line 6) * runtime (statistics/2 option): State Info. (line 463) * runtime kernel: Glossary. (line 674) * runtime system <1>: Glossary. (line 678) * runtime system <2>: Development and Runtime Systems. (line 6) * runtime system: Stand-alone Executables. (line 6) * runtime system, extended: Glossary. (line 261) * same_length/[2,3] (lists): Lists. (line 126) * sat/1 (clpb): CLPB Interface. (line 9) * save_files/2 <1>: Saving. (line 61) * save_files/2: Misc Pred. (line 85) * save_modules/2 <1>: Misc Pred. (line 101) * save_modules/2: Saving. (line 61) * save_predicates/2 <1>: Saving. (line 61) * save_predicates/2: Misc Pred. (line 114) * save_program/[1,2] <1>: Saving. (line 10) * save_program/[1,2]: Misc Pred. (line 126) * saved state: Saving. (line 6) * saved-state: Glossary. (line 684) * saving: Saving. (line 6) * scalar_product/4 (clpfd): Arithmetic Constraints. (line 40) * scale (Tk widget): Types of Widget. (line 45) * scan (Tcl command): Commands over Strings. (line 42) * scollbar (Tk widget): Types of Widget. (line 50) * scope, lexical: Programs. (line 65) * search rule: Procedural. (line 66) * see/1: File Pred. (line 9) * seeing/1: File Pred. (line 18) * seek/4: Stream Pred. (line 509) * seen/0: File Pred. (line 23) * select/3 (lists): Lists. (line 138) * selector: FDBG Selectors. (line 6) * selector, subterm <1>: Glossary. (line 783) * selector, subterm <2>: Breakpoint Tests. (line 263) * selector, subterm: Queries. (line 64) * self: Obj Self. (line 6) * self/1 (inlined method): Inlined Methods. (line 11) * self/1 (object method): The Proto-Object. (line 17) * semantics: Glossary. (line 697) * semantics of dynamic code: Modify Prog. (line 10) * semantics, declarative: Declarative. (line 6) * semantics, procedural: Procedural. (line 6) * sending, message: Obj Self. (line 6) * sentence <1>: Programs. (line 17) * sentence <2>: Load Intro. (line 53) * sentence <3>: Full Syntax. (line 6) * sentence: Glossary. (line 702) * sequence, escape <1>: Escape Sequences. (line 6) * sequence, escape <2>: State Info. (line 181) * sequence, escape: Glossary. (line 254) * serialized/[2,3] (clpfd): Combinatorial Constraints. (line 334) * servlet: PB Features. (line 32) * session_gc_timeout/1 (start/1 option): PB Prolog Server Interface. (line 38) * session_get/4 (prologbeans): PB Prolog Server Interface. (line 83) * session_put/3 (prologbeans): PB Prolog Server Interface. (line 98) * session_timeout/1 (start/1 option): PB Prolog Server Interface. (line 31) * set (Tcl command): Commands to Do with Variables. (line 9) * set printdepth (debugger command): Debug Commands. (line 315) * set printdepth (top-level command): Queries. (line 53) * set subterm (debugger command): Debug Commands. (line 329) * set subterm (top-level command): Queries. (line 63) * set, character <1>: Environment Variables. (line 16) * set, character: Token String. (line 6) * set, character code: WCX Concepts. (line 37) * set, FD: FD Set Operations. (line 6) * set/1 (inlined method): Inlined Methods. (line 19) * set/1 (object method): The Proto-Object. (line 68) * set_input/1: Stream Pred. (line 411) * set_output/1: Stream Pred. (line 414) * set_prolog_flag/2: State Info. (line 81) * set_stream_position/2: Stream Pred. (line 501) * setof/3: All Solutions. (line 18) * setrand/1 (random): Random. (line 37) * sets, ordered: Ordsets. (line 6) * setting a breakpoint: Usage. (line 125) * shallow failure: Profiling. (line 62) * shallow_fails (profile_data/4 option): Profiling. (line 62) * shell/[0,1,2] (system): System Utilities. (line 152) * show/1 (debugger condition) <1>: Breakpoint Actions. (line 12) * show/1 (debugger condition) <2>: Action Conditions. (line 16) * show/1 (debugger condition): Port Tests. (line 50) * shutdown/[0,1] (prologbeans): PB Prolog Server Interface. (line 50) * shutdown_server/0 (linda_client): Client. (line 31) * side-effect: Glossary. (line 705) * SIG_DFL: Signal Handling. (line 35) * SIG_ERR: Signal Handling. (line 35) * SIG_IGN: Signal Handling. (line 35) * sigaction: Signal Handling. (line 6) * SIGBREAK: Signal Handling. (line 17) * SIGCHLD: Signal Handling. (line 17) * SIGCLD: Signal Handling. (line 17) * SIGINT: Signal Handling. (line 17) * sign/1: Arithmetic. (line 129) * signal: Signal Handling. (line 6) * signal handling: Calling Prolog Asynchronously. (line 6) * SIGUSR1: Signal Handling. (line 17) * SIGUSR2: Signal Handling. (line 17) * SIGVTALRM: Signal Handling. (line 17) * silent/0 (debugger show control): Action Variables. (line 20) * simpagation CHR: CHR Introduction. (line 32) * simple term: Glossary. (line 710) * simple/1: Meta Logic. (line 49) * SimpleCallSpec: Terminology. (line 56) * simplification CHR: CHR Introduction. (line 32) * sin/1, function: Arithmetic. (line 184) * single_var_warnings (prolog flag) <1>: Runtime Systems. (line 32) * single_var_warnings (prolog flag) <2>: Read In. (line 48) * single_var_warnings (prolog flag): State Info. (line 283) * singletons/1 (read_term/[2,3] option): Term I/O. (line 54) * sinh/1, function: Arithmetic. (line 196) * size/1 (file_property/2 property): System Utilities. (line 106) * skip (debugger command): Debug Commands. (line 81) * skip/1 (debugger mode control): Action Variables. (line 130) * skip/[1,2]: Char I/O. (line 99) * skip_line/[0,1]: Char I/O. (line 104) * sleep/1 (system): System Utilities. (line 172) * small integer: Glossary. (line 714) * socket/2 (sockets): Sockets. (line 33) * socket_accept/[2,3] (sockets): Sockets. (line 57) * socket_bind/2 (sockets): Sockets. (line 42) * socket_buffering/4 (sockets): Sockets. (line 84) * socket_close/1 (sockets): Sockets. (line 36) * socket_connect/3 (sockets): Sockets. (line 48) * socket_listen/2 (sockets): Sockets. (line 52) * socket_select/[5,6] (sockets): Sockets. (line 90) * sockets: Sockets. (line 6) * solutions, all: All Solutions. (line 6) * solutions/1 (absolute_file_name/3 option): Stream Pred. (line 132) * sort/2: Term Compare. (line 94) * sorting/3 (clpfd): Combinatorial Constraints. (line 491) * source (load_context/2 key): State Info. (line 390) * source (Tcl command): source. (line 9) * source code: Glossary. (line 718) * source information <1>: Usage. (line 17) * source information: State Info. (line 286) * source module <1>: Basic Concepts. (line 14) * source module: Glossary. (line 722) * source/1 (fd_global/3 option): The Global Constraint Programming Interface. (line 99) * source/sink: Input Output. (line 17) * source_file/[1,2]: Read In. (line 167) * source_info (prolog flag, volatile) <1>: Usage. (line 28) * source_info (prolog flag, volatile) <2>: State Info. (line 286) * source_info (prolog flag, volatile): Breakpoint Tests. (line 228) * SP_AllocHook() (C function): Initializing the Prolog Engine. (line 71) * SP_APP_DIR (environment): Environment Variables. (line 74) * SP_atom (C type) <1>: OS Threads. (line 13) * SP_atom (C type): Glossary. (line 40) * SP_atom_from_string() (C function): Creating and Manipulating SP_term_refs. (line 59) * SP_atom_length() (C function): Creating and Manipulating SP_term_refs. (line 72) * SP_calloc() (C function): OS Memory Allocation. (line 18) * SP_chdir() (C function): OS File System. (line 12) * SP_close_query() (C function): Finding Multiple Solutions of a Call. (line 52) * SP_code_wci() (C function): WCX Utility Functions. (line 56) * SP_compare() (C function): Unifying and Comparing Terms. (line 6) * SP_cons_functor() (C function): Creating Prolog Terms. (line 14) * SP_cons_list() (C function): Creating Prolog Terms. (line 14) * SP_continue() (C function): Signal Handling. (line 55) * SP_CSETLEN (environment): Environment Variables. (line 12) * SP_CTYPE (environment): Environment Variables. (line 16) * SP_cut_query() (C function): Finding Multiple Solutions of a Call. (line 43) * SP_define_c_predicate() (C function): An Alternative Way to Define C Predicates. (line 12) * SP_DeinitAllocHook() (C function): Initializing the Prolog Engine. (line 71) * SP_deinitialize() (C function): Initializing the Prolog Engine. (line 36) * SP_errno (C macro): CPL Notes. (line 41) * SP_ERROR (C macro): CPL Notes. (line 34) * SP_error_message() (C function): CPL Notes. (line 46) * SP_event() (C function): Calling Prolog Asynchronously. (line 50) * SP_exception_term() (C function): Exception Handling in C. (line 16) * SP_FAILURE (C macro): CPL Notes. (line 34) * SP_fclose() (C function): Prolog Streams. (line 22) * SP_fflush() (C function): Prolog Streams. (line 22) * SP_fgetc() (C function): Prolog Streams. (line 22) * SP_force_interactive() (C function): Initializing the Prolog Engine. (line 51) * SP_foreign_stash() (C function): Miscellaneous C API Functions. (line 13) * SP_fprintf() (C function): Prolog Streams. (line 22) * SP_fputc() (C function): Prolog Streams. (line 22) * SP_fputs() (C function): Prolog Streams. (line 22) * SP_free() (C function): OS Memory Allocation. (line 30) * SP_FreeHook() (C function): Initializing the Prolog Engine. (line 71) * SP_from_os() (C function): WCX Utility Functions. (line 77) * SP_get_address() (C function): Accessing Prolog Terms. (line 12) * SP_get_arg() (C function): Accessing Prolog Terms. (line 12) * SP_get_atom() (C function): Accessing Prolog Terms. (line 12) * SP_get_float() (C function): Accessing Prolog Terms. (line 12) * SP_get_functor() (C function): Accessing Prolog Terms. (line 12) * SP_get_integer() (C function): Accessing Prolog Terms. (line 12) * SP_get_integer_bytes() (C function): Accessing Prolog Terms. (line 12) * SP_get_list() (C function): Accessing Prolog Terms. (line 12) * SP_get_list_chars() (C function): Accessing Prolog Terms. (line 12) * SP_get_list_n_bytes() (C function): Accessing Prolog Terms. (line 12) * SP_get_list_n_chars() (C function): Accessing Prolog Terms. (line 12) * SP_get_number_chars() (C function): Accessing Prolog Terms. (line 12) * SP_get_string() (C function): Accessing Prolog Terms. (line 12) * SP_getc() (C function): Prolog Streams. (line 22) * SP_getcwd() (C function): OS File System. (line 18) * SP_InitAllocHook() (C function): Initializing the Prolog Engine. (line 71) * SP_initialize() (C function): Initializing the Prolog Engine. (line 15) * SP_is_atom() (C function): Testing Prolog Terms. (line 9) * SP_is_atomic() (C function): Testing Prolog Terms. (line 9) * SP_is_compound() (C function): Testing Prolog Terms. (line 9) * SP_is_float() (C function): Testing Prolog Terms. (line 9) * SP_is_integer() (C function): Testing Prolog Terms. (line 9) * SP_is_list() (C function): Testing Prolog Terms. (line 9) * SP_is_number() (C function): Testing Prolog Terms. (line 9) * SP_is_variable() (C function): Testing Prolog Terms. (line 9) * SP_latin1_chartype() (C function): WCX Utility Functions. (line 70) * SP_LIBRARY_DIR (environment): Environment Variables. (line 84) * SP_load() (C function): Loading Prolog Code. (line 9) * SP_make_stream() (C function): Installing a New Stream. (line 6) * SP_make_stream_context() (C function): Installing a New Stream. (line 6) * SP_malloc() (C function): OS Memory Allocation. (line 15) * SP_MUTEX_INITIALIZER (C macro): OS Threads. (line 13) * SP_mutex_lock() (C function): OS Threads. (line 13) * SP_mutex_unlock() (C function): OS Threads. (line 13) * SP_new_term_ref() (C function): Creating and Manipulating SP_term_refs. (line 44) * SP_next_solution() (C function): Finding Multiple Solutions of a Call. (line 33) * SP_on_fault() (C macro): Loading Prolog Code. (line 27) * SP_open_query() (C function): Finding Multiple Solutions of a Call. (line 21) * SP_PATH (environment) <1>: CPL Notes. (line 10) * SP_PATH (environment): Environment Variables. (line 22) * SP_pred() (C function): Calling Prolog from C. (line 28) * SP_predicate() (C function): Calling Prolog from C. (line 15) * SP_printf() (C function): Prolog Streams. (line 22) * SP_put_address() (C function): Creating Prolog Terms. (line 14) * SP_put_atom() (C function): Creating Prolog Terms. (line 14) * SP_put_float() (C function): Creating Prolog Terms. (line 14) * SP_put_functor() (C function): Creating Prolog Terms. (line 14) * SP_put_integer() (C function): Creating Prolog Terms. (line 14) * SP_put_integer_bytes() (C function): Creating Prolog Terms. (line 14) * SP_put_list() (C function): Creating Prolog Terms. (line 14) * SP_put_list_chars() (C function): Creating Prolog Terms. (line 14) * SP_put_list_n_bytes() (C function): Creating Prolog Terms. (line 14) * SP_put_list_n_chars() (C function): Creating Prolog Terms. (line 14) * SP_put_number_chars() (C function): Creating Prolog Terms. (line 14) * SP_put_string() (C function): Creating Prolog Terms. (line 14) * SP_put_term() (C function): Creating and Manipulating SP_term_refs. (line 50) * SP_put_variable() (C function): Creating Prolog Terms. (line 14) * SP_putc() (C function): Prolog Streams. (line 22) * SP_puts() (C function): Prolog Streams. (line 22) * SP_qid (C type): Finding Multiple Solutions of a Call. (line 21) * SP_query() (C function): Finding One Solution of a Call. (line 14) * SP_query_cut_fail() (C function): Finding One Solution of a Call. (line 24) * SP_raise_exception() (C function): Exception Handling in C. (line 24) * SP_raise_fault() (C function): Loading Prolog Code. (line 58) * SP_read_from_string() (C function): Creating Prolog Terms. (line 14) * SP_realloc() (C function): OS Memory Allocation. (line 22) * SP_register_atom() (C function): Creating and Manipulating SP_term_refs. (line 87) * SP_reinstall_signal() (C function): Signal Handling. (line 55) * SP_restore() (C function): Loading Prolog Code. (line 15) * SP_RT_DIR (environment): Environment Variables. (line 78) * SP_set_interrupt_hook() (C function): Hooks. (line 11) * SP_set_memalloc_hooks() (C function): Initializing the Prolog Engine. (line 71) * SP_set_read_hook() (C function): Hooks. (line 11) * SP_set_reinit_hook() (C function): Hooks. (line 11) * SP_set_tty() (C function): Internal Representation. (line 27) * SP_set_user_stream_hook() (C function): Hookable Standard Streams. (line 10) * SP_set_user_stream_post_hook() (C function): Hookable Standard Streams. (line 13) * SP_SIG_DFL: Signal Handling. (line 35) * SP_SIG_ERR: Signal Handling. (line 35) * SP_SIG_IGN: Signal Handling. (line 35) * SP_signal() (C function): Signal Handling. (line 30) * SP_strdup() (C function): OS Memory Allocation. (line 35) * SP_stream (C type): Prolog Streams. (line 16) * SP_string_from_atom() (C function): Creating and Manipulating SP_term_refs. (line 67) * SP_SUCCESS (C macro): CPL Notes. (line 34) * SP_term_ref <1>: Glossary. (line 728) * SP_term_ref: Mixing C and Prolog. (line 14) * SP_term_ref (C type) <1>: Creating and Manipulating SP_term_refs. (line 6) * SP_term_ref (C type): Mixing C and Prolog. (line 14) * SP_term_type() (C function): Testing Prolog Terms. (line 9) * SP_to_os() (C function): WCX Utility Functions. (line 77) * SP_TYPE_ATOM (C macro): Testing Prolog Terms. (line 9) * SP_TYPE_COMPOUND (C macro): Testing Prolog Terms. (line 9) * SP_TYPE_FLOAT (C macro): Testing Prolog Terms. (line 9) * SP_TYPE_INTEGER (C macro): Testing Prolog Terms. (line 9) * SP_TYPE_VARIABLE (C macro): Testing Prolog Terms. (line 9) * SP_ULIMIT_DATA_SEGMENT_SIZE: Environment Variables. (line 66) * SP_unify() (C function): Unifying and Comparing Terms. (line 6) * SP_unregister_atom() (C function): Creating and Manipulating SP_term_refs. (line 95) * SP_wci_code() (C function): WCX Utility Functions. (line 21) * SP_wci_len() (C function): WCX Utility Functions. (line 49) * space_out/3 (spaceout): Spaceout. (line 13) * spdet, the determinacy checker: The Determinacy Checker. (line 6) * spec, breakpoint: Creating Breakpoints. (line 6) * spec, mode <1>: Mode Spec. (line 6) * spec, mode: Glossary. (line 480) * spec, predicate: Glossary. (line 587) * specific breakpoint: Specific and Generic Breakpoints. (line 6) * specification, file <1>: Glossary. (line 287) * specification, file: Input Output. (line 82) * spld: The Application Builder. (line 12) * splfr: The Foreign Resource Linker. (line 6) * split (Tcl command): Lists (Tcl). (line 123) * spxref: Xref Introduction. (line 6) * spy this (debugger command): Debug Commands. (line 226) * spy this conditionally (debugger command): Debug Commands. (line 233) * spy/[1,2] <1>: Breakpoint Predicates. (line 54) * spy/[1,2] <2>: Debug Pred. (line 49) * spy/[1,2]: Plain Spypoint. (line 28) * spypoint <1>: Glossary. (line 731) * spypoint: Debug Intro. (line 17) * spypoint, conditional: Creating Breakpoints. (line 26) * spypoint, plain <1>: Creating Breakpoints. (line 16) * spypoint, plain: Plain Spypoint. (line 6) * spypoints, CHR: CHR Spypoints. (line 6) * sqrt/1, square root: Arithmetic. (line 238) * stack_shifts (statistics/2 option): State Info. (line 480) * stand-alone executable <1>: Glossary. (line 742) * stand-alone executable: Stand-alone Executables. (line 6) * standard order: Term Compare. (line 6) * start/[0,1] (prologbeans): PB Prolog Server Interface. (line 14) * startServer on SICStus: Java Threads. (line 36) * state, program <1>: Saving. (line 6) * state, program: State Info. (line 6) * state, saved: Saving. (line 6) * static object <1>: Dynamically Declared Objects. (line 6) * static object: Obj Intro. (line 23) * static predicate: Glossary. (line 750) * static resource: Foreign Resources. (line 33) * static/0 (object method): The Proto-Object. (line 28) * static/1 (object method): The Proto-Object. (line 34) * static_methods/1 (utility method): The Utility Object. (line 31) * static_objects/1 (utility method): The Utility Object. (line 22) * static_sets/1 (cumulative/5 option): Combinatorial Constraints. (line 378) * static_sets/1 (serialized/3 option): Combinatorial Constraints. (line 378) * statistics/[0,2]: State Info. (line 418) * std/0 (exec/3 stream spec): System Utilities. (line 70) * step (labeling/2 option): Enumeration Predicates. (line 89) * stopServer on SICStus: Java Threads. (line 42) * store, consistent: Definitions. (line 10) * store, constraint: Definitions. (line 10) * store, contradictory: Definitions. (line 10) * stream <1>: Glossary. (line 754) * stream: Input Output. (line 6) * stream (load_context/2 key): State Info. (line 411) * stream alias <1>: Input Output. (line 70) * stream alias: Glossary. (line 757) * stream position: Glossary. (line 763) * stream, binary: Input Output. (line 34) * stream, end of: Stream Pred. (line 531) * stream, text: Input Output. (line 34) * stream_code/2: Prolog Streams. (line 11) * stream_position/2: Stream Pred. (line 445) * stream_position_data/3: Stream Pred. (line 451) * stream_property/2: Stream Pred. (line 456) * string <1>: Compound Terms. (line 91) * string: Glossary. (line 772) * string first (Tcl command): Commands over Strings. (line 159) * string index (Tcl command): Commands over Strings. (line 137) * string last (Tcl command): Commands over Strings. (line 168) * string length (Tcl command): Commands over Strings. (line 177) * string match (Tcl command): Commands over Strings. (line 98) * String on PrologSession: PB Java Client Interface. (line 47) * String on QueryAnswer: PB Java Client Interface. (line 111) * String on Term: PB Java Client Interface. (line 155) * string range (Tcl command): Commands over Strings. (line 145) * string string (Tcl command): Commands over Strings. (line 202) * string tolower (Tcl command): Commands over Strings. (line 189) * string toupper (Tcl command): Commands over Strings. (line 183) * string trim (Tcl command): Commands over Strings. (line 196) * string trimright (Tcl command): Commands over Strings. (line 210) * string, encoded <1>: Glossary. (line 250) * string, encoded: CPL Notes. (line 49) * SU_initialize() (C function): The Application Builder. (line 282) * sub/1 (object method) <1>: The Proto-Object. (line 14) * sub/1 (object method): Super and Sub. (line 6) * sub_atom/5: Meta Logic. (line 208) * sublist/2 (lists): Lists. (line 141) * subs/1 (utility method): The Utility Object. (line 10) * substitute/4 (lists): Lists. (line 144) * subsumes/2 (terms): Term Utilities. (line 38) * subsumes_chk/2 (terms): Term Utilities. (line 17) * subsumption: Term Utilities. (line 6) * subterm selector <1>: Queries. (line 64) * subterm selector <2>: Glossary. (line 783) * subterm selector: Breakpoint Tests. (line 263) * suffix/2 (lists): Lists. (line 154) * sum/3 (clpfd): Arithmetic Constraints. (line 35) * sum_list/2 (lists): Lists. (line 151) * sup/[2,4] (clpqr): Solver Predicates. (line 92) * super (keyword): The Keyword Super. (line 6) * super/1 (object method): The Proto-Object. (line 9) * super/2 (universal method) <1>: Universal Methods. (line 8) * super/2 (universal method): Inheritance. (line 6) * supers/1 (utility method): The Utility Object. (line 13) * suppressing messages: Exception. (line 6) * switch (Tcl command): Control Flow. (line 89) * symmetric_closure/2 (ugraphs): UGraphs. (line 93) * symmetric_closure/2 (wgraphs): WGraphs. (line 91) * synchronization: Linda Library. (line 6) * synchronization/1 (disjoint2/2 option): Combinatorial Constraints. (line 603) * syntactic rewriting: Input Output. (line 86) * syntax: Glossary. (line 790) * syntax error: Syntax Errors. (line 6) * syntax_error/[1,5] (error class): Exception. (line 92) * syntax_errors (prolog flag) <1>: State Info. (line 301) * syntax_errors (prolog flag) <2>: Exception. (line 95) * syntax_errors (prolog flag) <3>: Syntax Errors. (line 32) * syntax_errors (prolog flag): Term I/O. (line 42) * syntax_errors/1 (read_term/[2,3] option): Term I/O. (line 40) * system encoding: WCX Concepts. (line 54) * system encoding (of wide characters): Glossary. (line 794) * system, development <1>: Development and Runtime Systems. (line 6) * system, development: Glossary. (line 228) * system, extended runtime: Glossary. (line 261) * system, module: Module Intro. (line 6) * system, operating: System Utilities. (line 6) * system, runtime <1>: Development and Runtime Systems. (line 6) * system, runtime <2>: Stand-alone Executables. (line 6) * system, runtime: Glossary. (line 678) * system/[0,1,2] (system): System Utilities. (line 179) * system_error/[0,1] (error class): Exception. (line 122) * system_type (prolog flag, volatile): State Info. (line 318) * tab/[1,2]: Char I/O. (line 133) * tables, data: Data Tables. (line 6) * tan/1, function: Arithmetic. (line 190) * tanh/1, function: Arithmetic. (line 202) * task_intervals/1 (cumulatives/3 option): Combinatorial Constraints. (line 455) * taut/2 (clpb): CLPB Interface. (line 19) * tcl_delete/1 (tcltk) <1>: Predicates for Prolog to Interact with Tcl Interpreters. (line 10) * tcl_delete/1 (tcltk): Removing a Tcl Interpreter. (line 9) * tcl_eval/3 (tcltk) <1>: Evaluating Tcl Expressions from Prolog. (line 9) * tcl_eval/3 (tcltk): Predicates for Prolog to Interact with Tcl Interpreters. (line 14) * tcl_event/3 (tcltk) <1>: Evaluate a Tcl Expression And Get Prolog Events. (line 9) * tcl_event/3 (tcltk): Predicates for Prolog to Interact with Tcl Interpreters. (line 19) * tcl_new/1 (tcltk) <1>: Creating a Tcl Interpreter. (line 10) * tcl_new/1 (tcltk): Predicates for Prolog to Interact with Tcl Interpreters. (line 6) * tell/1: File Pred. (line 26) * telling/1: File Pred. (line 35) * term <1>: Glossary. (line 798) * term: Terms. (line 6) * term comparison: Term Compare. (line 6) * term conversions: Support Functions. (line 6) * term I/O: Term I/O. (line 6) * term names <1>: FDBG Names of Terms. (line 6) * term names: FDBG Naming Terms. (line 6) * Term on QueryAnswer: PB Java Client Interface. (line 97) * Term on Term: PB Java Client Interface. (line 165) * term reference: Mixing C and Prolog. (line 14) * term, atomic: Glossary. (line 51) * term, callable: Glossary. (line 100) * term, compound <1>: Terms. (line 6) * term, compound <2>: Compound Terms. (line 6) * term, compound: Glossary. (line 160) * term, cyclic <1>: Term I/O. (line 59) * term, cyclic: Occur. (line 6) * term, exception: Exception Handling in C. (line 6) * term, indexed: The DB-Spec Informal Description. (line 15) * term, layout: Term I/O. (line 66) * term, mutable <1>: Modify Term. (line 21) * term, mutable: Glossary. (line 506) * term, simple: Glossary. (line 710) * term_expansion/[2,4] (user): Term and Goal Expansion. (line 195) * term_hash/[2,4] (terms): Term Utilities. (line 61) * term_position (load_context/2 key): State Info. (line 414) * term_subsumer/3 (terms): Term Utilities. (line 48) * term_variables/2 (terms): Term Utilities. (line 101) * term_variables_bag/2 (terms): Term Utilities. (line 104) * terminating a backtracking loop: Terminating a Backtracking Loop. (line 14) * terms: Term Utilities. (line 6) * terse (gc_trace flag value): State Info. (line 217) * test condition, breakpoint: Goal Tests. (line 6) * test, breakpoint: Creating Breakpoints. (line 39) * text (Tk widget): Types of Widget. (line 54) * text stream: Input Output. (line 34) * thread, main: Calling Prolog Asynchronously. (line 6) * threads: OS Threads. (line 11) * threads, calling Prolog from: Calling Prolog Asynchronously. (line 6) * throw/1: Exception. (line 15) * time_out/2 (labeling/2 option): Enumeration Predicates. (line 164) * time_out/3 (timeout): Timeout. (line 13) * tk_all_events (tk_do_one_event/1 option): Servicing Tk Events. (line 81) * tk_destroy_window/1 (tcltk) <1>: Housekeeping. (line 19) * tk_destroy_window/1 (tcltk): Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 81) * tk_do_one_event/[0,1] (tcltk) <1>: Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 32) * tk_do_one_event/[0,1] (tcltk): Servicing Tk Events. (line 52) * tk_dont_wait (tk_do_one_event/1 option): Servicing Tk Events. (line 65) * tk_file_events (tk_do_one_event/1 option): Servicing Tk Events. (line 72) * tk_idle_events (tk_do_one_event/1 option): Servicing Tk Events. (line 78) * tk_main_loop/0 (tcltk) <1>: Passing Control to Tk. (line 10) * tk_main_loop/0 (tcltk): Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 73) * tk_main_window/2 (tcltk) <1>: Housekeeping. (line 12) * tk_main_window/2 (tcltk): Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 77) * tk_make_window_exist/1 (tcltk) <1>: Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 84) * tk_make_window_exist/1 (tcltk): Housekeeping. (line 26) * tk_new/2 (tcltk) <1>: Creating a Tcl Interpreter Extended with Tk. (line 9) * tk_new/2 (tcltk): Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 6) * tk_next_event/[2,3] (tcltk) <1>: Servicing Tk Events. (line 113) * tk_next_event/[2,3] (tcltk) <2>: Evaluate a Tcl Expression And Get Prolog Events. (line 34) * tk_next_event/[2,3] (tcltk): Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 66) * tk_num_main_windows/1 (tcltk) <1>: Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions. (line 87) * tk_num_main_windows/1 (tcltk): Housekeeping. (line 38) * tk_timer_events (tk_do_one_event/1 option): Servicing Tk Events. (line 75) * tk_window_events (tk_do_one_event/1 option): Servicing Tk Events. (line 69) * tk_x_events (tk_do_one_event/1 option): Servicing Tk Events. (line 68) * TMPDIR (environment): Environment Variables. (line 28) * tmpnam/1 (system): System Utilities. (line 192) * token: Full Syntax. (line 14) * told/0: File Pred. (line 40) * top-level: Start. (line 110) * top_level_events/0 (tk_new/2 option): Creating a Tcl Interpreter Extended with Tk. (line 22) * top_sort/2 (ugraphs): UGraphs. (line 98) * top_sort/2 (wgraphs): WGraphs. (line 97) * toplevel (Tk widget): Types of Widget. (line 58) * toplevel_print_options (prolog flag) <1>: Message Phases. (line 31) * toplevel_print_options (prolog flag) <2>: State Info. (line 322) * toplevel_print_options (prolog flag): Queries. (line 61) * touching a variable: How CHR Work. (line 20) * trace: Glossary. (line 802) * trace (debugging flag value): State Info. (line 137) * trace (unknown flag value) <1>: Undefined Predicates. (line 20) * trace (unknown flag value) <2>: State Info. (line 337) * trace (unknown flag value): Debug Pred. (line 17) * trace/0 <1>: Debug Pred. (line 35) * trace/0: Basic Debug. (line 28) * trace/0 (debugger mode control): Action Variables. (line 135) * trail (statistics/2 option): State Info. (line 440) * TRAILSTKSIZE (environment): Environment Variables. (line 41) * transitive_closure/2 (ugraphs): UGraphs. (line 90) * transitive_closure/2 (wgraphs): WGraphs. (line 87) * transpose/2 (ugraphs): UGraphs. (line 73) * transpose/2 (wgraphs): WGraphs. (line 77) * tree_size/2 (trees): Trees. (line 42) * tree_to_list/2 (trees): Trees. (line 45) * trees, binary: Trees. (line 6) * trimcore/0: State Info. (line 498) * true/0: Control. (line 97) * true/0 (debugger condition): Other Tests. (line 35) * true/1 (debugger condition) <1>: Breakpoint Tests. (line 35) * true/1 (debugger condition): Other Tests. (line 20) * truncate/1, function: Arithmetic. (line 165) * trying a CHR: How CHR Work. (line 6) * ttyflush/0: Char I/O. (line 146) * ttyget/1: Char I/O. (line 152) * ttyget0/1: Char I/O. (line 149) * ttynl/0: Char I/O. (line 143) * ttyput/1: Char I/O. (line 155) * ttyskip/1: Char I/O. (line 158) * ttytab/1: Char I/O. (line 161) * type-in module <1>: State Info. (line 331) * type-in module <2>: Glossary. (line 806) * type-in module: Basic Concepts. (line 19) * type/1 (file_property/2 property): System Utilities. (line 102) * type/1 (open/4 option): Stream Pred. (line 351) * type/1 (stream property): Stream Pred. (line 494) * type_error/[2,4] (error class): Exception. (line 67) * typein_module (prolog flag): State Info. (line 329) * ugraph: UGraphs. (line 6) * ugraph_to_wgraph/2 (wgraphs): WGraphs. (line 46) * unblock/0 (debugger port value): Port Tests. (line 13) * unblocked goal: Glossary. (line 809) * unbound: Glossary. (line 812) * unconstrained/1 (chr): CHR Built-In Predicates. (line 57) * undefined predicate <1>: Undefined Predicates. (line 6) * undefined predicate <2>: Exception. (line 130) * undefined predicate: State Info. (line 334) * undo/1: Misc Pred. (line 36) * unification <1>: Glossary. (line 815) * unification: Procedural. (line 66) * unifier, most general: Procedural. (line 66) * unify (debugger command): Debug Commands. (line 303) * unify_with_occurs_check/2: Misc Pred. (line 13) * unit clause <1>: Programs. (line 24) * unit clause: Glossary. (line 835) * unknown (prolog flag) <1>: Debug Pred. (line 14) * unknown (prolog flag) <2>: Exception. (line 134) * unknown (prolog flag) <3>: State Info. (line 334) * unknown (prolog flag) <4>: Exception. (line 80) * unknown (prolog flag): Undefined Predicates. (line 17) * unknown/2 <1>: Undefined Predicates. (line 6) * unknown/2: Debug Pred. (line 9) * unknown_predicate_handler/3 (user) <1>: Exception. (line 130) * unknown_predicate_handler/3 (user): Undefined Predicates. (line 6) * unleash/0 (debugger condition): Condition Macros. (line 10) * unload_foreign_resource/1: Interface Predicates. (line 19) * unreachable code: Xref Introduction. (line 6) * unregister_event_listener/1 (prologbeans): PB Prolog Server Interface. (line 152) * unset (Tcl command): Commands to Do with Variables. (line 19) * unweighted graphs: UGraphs. (line 6) * up (labeling/2 option): Enumeration Predicates. (line 126) * update/1 (object method): The Proto-Object. (line 92) * update_mutable/2: Modify Term. (line 41) * uplevel (Tcl command): User Defined Procedures. (line 129) * upvar (Tcl command): User Defined Procedures. (line 101) * use_module/[1,2,3]: Read In. (line 136) * user: Inserting Clauses. (line 6) * user:breakpoint_expansion/2 <1>: Condition Macros. (line 23) * user:breakpoint_expansion/2: Hooks Related to Breakpoints. (line 8) * user:debugger_command_hook/2 <1>: Debug Pred. (line 91) * user:debugger_command_hook/2 <2>: Hooks Related to Breakpoints. (line 72) * user:debugger_command_hook/2: Breakpoint Predicates. (line 111) * user:error_exception/1 <1>: Exceptions Debug. (line 15) * user:error_exception/1: Debug Pred. (line 96) * user:file_search_path/2 <1>: Stream Pred. (line 295) * user:file_search_path/2: Input Output. (line 92) * user:generate_message_hook/3: Message Handling Predicates. (line 46) * user:goal_expansion/3: Term and Goal Expansion. (line 220) * user:library_directory/1: Stream Pred. (line 317) * user:message_hook/3: Message Handling Predicates. (line 60) * user:method_expansion/3: Object Declaration. (line 36) * user:portray/1: Term I/O. (line 196) * user:portray_message/2: Message Handling Predicates. (line 40) * user:query_class_hook/5: Query Handling Predicates. (line 83) * user:query_hook/6: Query Handling Predicates. (line 77) * user:query_input_hook/3: Query Handling Predicates. (line 137) * user:query_map_hook/4: Query Handling Predicates. (line 151) * user:term_expansion/[2,4]: Term and Goal Expansion. (line 195) * user:unknown_predicate_handler/3 <1>: Undefined Predicates. (line 6) * user:unknown_predicate_handler/3: Exception. (line 130) * user:user_help/0: Misc Pred. (line 189) * user_error (prolog flag, volatile) <1>: State Info. (line 363) * user_error (prolog flag, volatile) <2>: Prolog Streams. (line 74) * user_error (prolog flag, volatile): Input Output. (line 64) * user_error (stream alias): Input Output. (line 64) * user_help/0 (user): Misc Pred. (line 189) * user_input (prolog flag, volatile) <1>: Prolog Streams. (line 64) * user_input (prolog flag, volatile) <2>: Input Output. (line 54) * user_input (prolog flag, volatile): State Info. (line 353) * user_input (stream alias): Input Output. (line 54) * user_main() (C function): User-defined Main Programs. (line 10) * user_output (prolog flag, volatile) <1>: State Info. (line 358) * user_output (prolog flag, volatile) <2>: Prolog Streams. (line 69) * user_output (prolog flag, volatile): Input Output. (line 59) * user_output (stream alias): Input Output. (line 59) * UTF-8 encoding: Glossary. (line 838) * utility (built-in object): The Utility Object. (line 6) * val/1 (case/4 spec): Combinatorial Constraints. (line 149) * val/1 (fd_global/3 spec): The Global Constraint Programming Interface. (line 94) * value/1 (labeling/2 option): Enumeration Predicates. (line 102) * var/1: Meta Logic. (line 12) * variable <1>: Variables. (line 6) * variable <2>: Terminology. (line 66) * variable <3>: Terms. (line 6) * variable: Glossary. (line 841) * variable, anonymous <1>: Variables. (line 11) * variable, anonymous: Glossary. (line 28) * variable, domain: CLPFD Interface. (line 15) * variable, instance: Inheritance and Delegation. (line 12) * variable, touching a: How CHR Work. (line 20) * variable/1 (labeling/2 option): Enumeration Predicates. (line 72) * variable_names/1 (read_term/[2,3] option): Term I/O. (line 49) * variables, attributed: Attributes. (line 6) * variables, list of: FDBG Legend. (line 6) * variables/1 (read_term/[2,3] option): Term I/O. (line 45) * variant/2 (terms): Term Utilities. (line 44) * vbsp, file search path: Loading the Prolog Code. (line 24) * verbose (gc_trace flag value): State Info. (line 214) * verify_attributes/3 (Module): Attributes. (line 73) * version (prolog flag, volatile): State Info. (line 368) * version/[0,1]: Misc Pred. (line 162) * vertices/2 (ugraphs): UGraphs. (line 53) * vertices/2 (wgraphs): WGraphs. (line 57) * vertices_edges_to_ugraph/3 (ugraphs): UGraphs. (line 46) * vertices_edges_to_wgraph/3 (wgraphs): WGraphs. (line 50) * view/1 (gauge): Gauge. (line 16) * visualizer: FDBG Visualizers. (line 6) * void on Bindings: PB Java Client Interface. (line 180) * void on PrologSession: PB Java Client Interface. (line 58) * volatile: Glossary. (line 858) * volatile declaration: Volatile Declarations. (line 6) * volatile/1 (declaration): Volatile Declarations. (line 6) * wait/2 (system): System Utilities. (line 196) * walltime (statistics/2 option): State Info. (line 471) * WAM: Intro. (line 19) * warning (unknown flag value) <1>: Debug Pred. (line 24) * warning (unknown flag value) <2>: Undefined Predicates. (line 28) * warning (unknown flag value): State Info. (line 345) * wcx (prolog flag, volatile): State Info. (line 373) * WCX (Wide Character eXtension) component: Input Output. (line 34) * WCX box: WCX Hooks. (line 7) * WCX mode: WCX Concepts. (line 78) * wcx/1 (load_files/2 option): Read In. (line 106) * wcx/1 (open/4 option): Stream Pred. (line 379) * wcx/1 (stream property): Stream Pred. (line 497) * weighted graphs: WGraphs. (line 6) * wgraph: WGraphs. (line 6) * wgraph_to_ugraph/2 (wgraphs): WGraphs. (line 42) * when/1 (load_files/2 option): Read In. (line 73) * when/2: Coroutining. (line 11) * while (Tcl command): Control Flow. (line 26) * wide character code: WCX Concepts. (line 9) * wide characters: Input Output. (line 34) * windowed executable: Glossary. (line 862) * with_output_to_chars/[2,3,4] (charsio): Chars I/O. (line 80) * working_directory/2 (system): System Utilities. (line 201) * wrap/2 (disjoint1/2 option): Combinatorial Constraints. (line 528) * wrap/4 (disjoint2/2 option): Combinatorial Constraints. (line 570) * write (debugger command): Debug Commands. (line 177) * write (open/[3,4] mode): Stream Pred. (line 336) * write/0 (debugger show control): Action Variables. (line 26) * write/[1,2]: Term I/O. (line 138) * write_canonical/[1,2]: Term I/O. (line 150) * write_term/1 (debugger show control): Action Variables. (line 29) * write_term/[2,3]: Term I/O. (line 210) * write_term_to_chars/[3,4] (charsio): Chars I/O. (line 37) * write_to_chars/[2,3] (charsio): Chars I/O. (line 30) * writeq/[1,2]: Term I/O. (line 159) * XEmacs: Emacs Interface. (line 6) * xml_parse/[2,3] (xml): XML. (line 62) * xml_pp/1 (xml): XML. (line 93) * xml_subterm/2 (xml): XML. (line 88) * zip: Glossary. (line 866) * zip (debugger command): Debug Commands. (line 64) * zip (debugging flag value): State Info. (line 143) * zip/0 <1>: Debug Pred. (line 38) * zip/0: Basic Debug. (line 23) * zip/0 (debugger mode control): Action Variables. (line 141) * {}/1 (clpqr): Solver Predicates. (line 10) * ~ /1, boolean not: CLPB. (line 33)