object

# logtalk

> Built-in object providing message printing, debugging, library, source file, and hacking methods.

author:
  `Paulo Moura`
version:
  `1.3`
date:
  `2016/5/25`

compilation flags:
  `static, built_in, context_switching_calls, threaded`

(no dependencies on other files)

## Public interface

### print_message/3

> Prints a message of the given kind for the specified component.

compilation flags:
  `static`
template:
  `print_message(Kind,Component,Message)`
mode – number of proofs:
  `print_message(+nonvar,+nonvar,+nonvar) – one`

### print_message_tokens/3

> Print the messages tokens to the given stream, prefixing each line with the specified atom.

compilation flags:
  `static`
template:
  `print_message_tokens(Stream,Prefix,Tokens)`
mode – number of proofs:
  `print_message_tokens(@stream_or_alias,+atom,@list(nonvar)) – one`

### print_message_token/4

> User-defined hook predicate for printing a message token (at_same_line, nl, flush, Format-Arguments, term(Term,Options), ansi(Attributes,Format,Arguments), begin(Kind,Variable), and end(Variable)).

compilation flags:
  `dynamic, multifile`
template:
  `print_message_token(Stream,Prefix,Token,Tokens)`
mode – number of proofs:
  `print_message_token(@stream_or_alias,@atom,@nonvar,@list(nonvar)) – zero_or_one`

### message_tokens//2

> User-defined hook grammar rule for converting a message into a list of tokens (at_same_line, nl, flush, Format-Arguments, term(Term,Options), ansi(Attributes,Format,Arguments), begin(Kind,Variable), and end(Variable)).

compilation flags:
  `dynamic, multifile`
template:
  `message_tokens(Message,Component)`

### message_prefix_stream/4

> Message line prefix and output stream to be used when printing a message given its kind and component.

compilation flags:
  `dynamic, multifile`
template:
  `message_prefix_stream(Kind,Component,Prefix,Stream)`
mode – number of proofs:
  `message_prefix_stream(?nonvar,?nonvar,?atom,?stream_or_alias) – zero_or_more`

### message_hook/4

> User-defined hook predicate for intercepting message printing calls.

compilation flags:
  `dynamic, multifile`
template:
  `message_hook(Message,Kind,Component,Tokens)`
mode – number of proofs:
  `message_hook(+nonvar,+nonvar,+nonvar,+list(nonvar)) – zero_or_one`

### ask_question/5

> Asks a question and reads the answer until the check predicate is true.

compilation flags:
  `static`
template:
  `ask_question(Kind,Component,Question,Check,Answer)`
meta-predicate template:
  `ask_question(*,*,*,1,*)`
mode – number of proofs:
  `ask_question(+nonvar,+nonvar,+nonvar,+callable,-term) – one`

### question_hook/6

> User-defined hook predicate for intercepting question asking calls.

compilation flags:
  `dynamic, multifile`
template:
  `question_hook(Question,Kind,Component,Tokens,Check,Answer)`
meta-predicate template:
  `question_hook(*,*,*,*,1,*)`
mode – number of proofs:
  `question_hook(+nonvar,+nonvar,+nonvar,+list(nonvar),+callable,-term) – zero_or_one`

### question_prompt_stream/4

> Prompt and input stream to be used when asking a question given its kind and component.

compilation flags:
  `dynamic, multifile`
template:
  `question_prompt_stream(Kind,Component,Prompt,Stream)`
mode – number of proofs:
  `question_prompt_stream(?nonvar,?nonvar,?atom,?stream_or_alias) – zero_or_more`

### trace_event/2

> Trace event handler. The runtime calls all trace event handlers using a failure-driven loop before calling the debug event handler.

compilation flags:
  `dynamic, multifile`
template:
  `trace_event(Event,ExecutionContext)`
mode – number of proofs:
  `trace_event(@callable,@execution_context) – zero`

### debug_handler_provider/1

> Declares an object as the debug handler provider. There should be at most one debug handler provider loaded at any given moment.

compilation flags:
  `static, multifile`
template:
  `debug_handler_provider(Provider)`
mode – number of proofs:
  `debug_handler_provider(?object_identifier) – zero_or_one`

### debug_handler/2

> Debug event handler. The defined events are unification events - fact(Entity,Fact,Clause,Line) and rule(Entity,Head,Clause,Line) - and goal events - top_goal(Goal,CompiledGoal) and goal(Goal,CompiledGoal).

compilation flags:
  `static, multifile`
template:
  `debug_handler(Event,ExecutionContext)`
mode – number of proofs:
  `debug_handler(?entity_identifier,?atom) – zero_or_more`

### expand_library_path/2

> Expands a library name into its full path. Uses a depth bound to prevent loops.

compilation flags:
  `static`
template:
  `expand_library_path(Library,Path)`
mode – number of proofs:
  `expand_library_path(+atom,?atom) – zero_or_one`

### loaded_file/1

> Enumerates, by backtracking, all loaded files, returning their full paths.

compilation flags:
  `static`
template:
  `loaded_file(Path)`
mode – number of proofs:
  `loaded_file(?atom) – zero_or_more`

### loaded_file_property/2

> Enumerates, by backtracking, all loaded file properties. Valid properties are: basename/1, directory/1, mode/1, flags/1, text_properties/1 (encoding/1 and bom/1), target/1, modified/1, parent/1, library/1, object/1, protocol/1, and category/1.

compilation flags:
  `static`
template:
  `loaded_file_property(Path,Property)`
mode – number of proofs:
  `loaded_file_property(?atom,?compound) – zero_or_more`

### compile_aux_clauses/1

> Compiles a list of auxiliary clauses.

compilation flags:
  `static`
template:
  `compile_aux_clauses(Clauses)`
mode – number of proofs:
  `compile_aux_clauses(@list(clause)) – one`

### entity_prefix/2

> Converts between an entity identifier and the entity prefix that is used for its compiled code. When none of the arguments is instantiated, it returns the identifier and the prefix of the entity under compilation, if any.

compilation flags:
  `static`
template:
  `entity_prefix(Entity,Prefix)`
mode – number of proofs:
  `entity_prefix(?entity_identifier,?atom) – zero_or_one`

### compile_predicate_heads/4

> Compiles clause heads. The heads are compiled in the context of the entity under compilation when the entity argument is not instantiated.

compilation flags:
  `static`
template:
  `compile_predicate_heads(Heads,Entity,CompiledHeads,ExecutionContext)`
mode – number of proofs:
  `compile_predicate_heads(@list(callable),?entity_identifier,-list(callable),@execution_context) – zero_or_one`
  `compile_predicate_heads(@conjunction(callable),?entity_identifier,-conjunction(callable),@execution_context) – zero_or_one`
  `compile_predicate_heads(@callable,?entity_identifier,-callable,@execution_context) – zero_or_one`

### compile_predicate_indicators/3

> Compiles predicate indicators. The predicate are compiled in the context of the entity under compilation when the entity argument is not instantiated.

compilation flags:
  `static`
template:
  `compile_predicate_indicators(PredicateIndicators,Entity,CompiledPredicateIndicators)`
mode – number of proofs:
  `compile_predicate_indicators(@list(predicate_indicator),?entity_identifier,-list(predicate_indicator)) – zero_or_one`
  `compile_predicate_indicators(@conjunction(predicate_indicator),?entity_identifier,-conjunction(predicate_indicator)) – zero_or_one`
  `compile_predicate_indicators(@predicate_indicator,?entity_identifier,-predicate_indicator) – zero_or_one`

### decompile_predicate_heads/4

> Decompiles clause heads. All compiled clause heads must belong to the same entity, which must be loaded.

compilation flags:
  `static`
template:
  `decompile_predicate_heads(CompiledHeads,Entity,Type,Heads)`
mode – number of proofs:
  `decompile_predicate_heads(@list(callable),-entity_identifier,-atom,-list(callable)) – zero_or_one`
  `decompile_predicate_heads(@conjunction(callable),-entity_identifier,-atom,-conjunction(callable)) – zero_or_one`
  `decompile_predicate_heads(@callable,-entity_identifier,-atom,-callable) – zero_or_one`

### decompile_predicate_indicators/4

> Decompiles predicate indicators. All compiled predicate indicators must belong to the same entity, which must be loaded.

compilation flags:
  `static`
template:
  `decompile_predicate_indicators(CompiledPredicateIndicators,Entity,Type,PredicateIndicators)`
mode – number of proofs:
  `decompile_predicate_indicators(@list(predicate_indicator),-entity_identifier,-atom,-list(predicate_indicator)) – zero_or_one`
  `decompile_predicate_indicators(@conjunction(predicate_indicator),-entity_identifier,-atom,-conjunction(predicate_indicator)) – zero_or_one`
  `decompile_predicate_indicators(@predicate_indicator,-entity_identifier,-atom,-predicate_indicator) – zero_or_one`

### execution_context/7

> Execution context term data. Execution context terms should be considered opaque terms subject to change without notice.

compilation flags:
  `static`
template:
  `execution_context(ExecutionContext,Entity,Sender,This,Self,MetaCallContext,Stack)`
mode – number of proofs:
  `execution_context(?nonvar,?entity_identifier,?object_identifier,?object_identifier,?object_identifier,@list(callable),@list(callable)) – zero_or_one`

## Protected interface

(none)

## Private predicates

(none)

## Operators

### (none)

## Remarks

### (none)

## See also

### (none)