The Predicates that Read Source Files

Detailed Description

Modules
	Directing and Configuring the Compiler
	The YAP system also includes a number of primitives designed to set compiler parameters and to track the state of the compiler.
	Conditional Compilation
	Conditional compilation builds on the same principle as term_expansion/2 , goal_expansion/2 and the expansion of grammar rules to compile sections of the source-code conditionally.

---

Class Documentation

load_files/2

class load_files/2

load_files(+_Files_, +_Options_)

Implementation of the consult/1 family Execution is controlled by the following flags:

• consult(+ Mode)

  This extension controls the type of file to load If Mode is:

  consult, clauses are added to the data-base, unless from the same file; reconsult, clauses are recompiled, db, these are facts that need to be added to the data-base, exo, these are facts with atoms and integers that can be stored in a compact representation (see load_exo/1 )

• silent(+ Bool)

  If true, load the file without printing a message The specified value is the default for all files loaded as a result of loading the specified files

• stream(+ Input)

  This SWI-Prolog extension compiles the data from the stream Input If this option is used, Files must be a single atom which is used to identify the source-location of the loaded clauses as well as remove all clauses if the data is re-consulted

  This option is added to allow compiling from non-file locations such as databases, the web, the user (see consult/1 ) or other servers

• compilation_mode(+ Mode)

  This extension controls how procedures are compiled If Mode is compact clauses are compiled and no source code is stored; if it is source clauses are compiled and source code is stored; if it is assert_all clauses are asserted into the data-base

• encoding(+ Encoding)

  Character encoding used in consulting files Please (see Encoding) for supported encodings

• expand(+ Bool)

  If true, run the filenames through expand_file_name/2 and load the returned files Default is false, except for consult/1 which is intended for interactive use

• if(+ Condition)

  Load the file only if the specified Condition is satisfied The value true the file unconditionally, changed loads the file if it was not loaded before, or has been modified since it was loaded the last time, not_loaded loads the file if it was not loaded before

• imports(+ ListOrAll)

  If all and the file is a module file, import all public predicates Otherwise import only the named predicates Each predicate is referred to as \<name\>/\<arity\> This option has no effect if the file is not a module file

• must_be_module(+ Bool)

  If true, raise an error if the file is not a module file Used by use_module/1 and use_module/2

• qcompile(+ Value)

  SWI-Prolog flag that controls whether loaded files should be also compiled into qly files The default value is obtained from the flag qcompile:

  never, no qly file is generated unless the user calls qsave_file/1 and friends, or sets the qcompile option in load_files/2 ;

  auto, all files are qcompiled

  large, files above 100KB are qcompiled

  part, not supported in YAP

• autoload(+ Autoload)

SWI-compatible option where if Autoload is true undefined predicates are loaded on first call

• derived_from(+ File)

  SWI-compatible option to control make/0 Currently not supported

ensure_loaded/1

class ensure_loaded/1

ensure_loaded(+ F)

defined in the ISO standard

When the files specified by F are module files, ensure_loaded/1 loads them if they have note been previously loaded, otherwise advertises the user about the existing name clashes and prompts about importing or not those predicates Predicates which are not public remain invisible

When the files are not module files, ensure_loaded/1 loads them eh if they have not been loaded before, and does nothing otherwise

F must be a list containing the names of the files to load

consult/1

class consult/1

consult(+ F)

Adds the clauses written in file F or in the list of files F to the program

In YAP consult/1 does not remove previous clauses for the procedures defined in other files than F, but since YAP-6.4.3 it will redefine all procedures defined in F

All code in YAP is compiled, and the compiler generates static procedures by default In case you need to manipulate the original code, the expanded version of the original source code is available by calling source/0 or by enabling the source flag

reconsult/1

class reconsult/1

reconsult(+ F )

compile/1

class compile/1

compile(+ F )

Updates the program by replacing the previous definitions for the predicates defined in F It differs from consult/1 in that it only multifile/1 predicates are not reset in a reconsult Instead, consult/1 sees all predicates as multifile

YAP also offers no difference between consult/1 and compile/1 The two are implemented by the same exact code

Example:

?- [file1, -file2, -file3, file4].

will consult file1 file4 and reconsult file2 and file3 That is, it could be written as:

?- consult(file1),
   

load_db/1

class load_db/1

load_db(+ Files)

load_db( +Files )

Load a database of ground facts All facts must take up the same amount of storage, so that a fact $I$ can be accessed at position P[I-1] This representation thus stores the facts as a huge continuous array, the so-called mega clause

See [for] a motivation for this technique YAP implements this optimization by default whenever it loads a large number of facts (see Yap_BuildMegaClause(PredEntry *ap) ) for the details On the other hand, loading the data-base will cause fragmentation because individual facts facts need extra headers ands tails, and because often new atoms will be stored in the Symbol Table, see LookupAtom(const char *atom) The main advantage of load_db/1 is that it allocates the necessary memory only once Just doing this may halve total memory usage in large in-memory database-oriented applications

Note

Implementation

YAP implements load_db/1 as a two-step non-optimised process First, it counts the nmuber of facts and checks their size Second, it allocates and fills the memory The first step of the algorithm is implemented by dbload_get_space(), and the second by dbload_add_facts()

db_files/1 itself is just a call to load_files/2

properties: deterministic

Load files each one containing as single predicare composed of facts with the same size

prolog_load_context/2

class prolog_load_context/2

prolog_load_context(? Key, ? Value)

Obtain information on what is going on in the compilation process The following keys are available:

• directory (prolog_load_context/2 option)

Full name for the directory where YAP is currently consulting the file

• file (prolog_load_context/2 option)

Full name for the file currently being consulted Notice that included filed are ignored

• module (prolog_load_context/2 option)

Current source module

• source (prolog_load_context/2 option)

Full name for the file currently being read in, which may be consulted, reconsulted, or included

• stream (prolog_load_context/2 option)

Stream currently being read in

• term_position (prolog_load_context/2 option)

Stream position at the stream currently being read in For SWI compatibility, it is a term of the form '$stream_position'(0,Line,0,0)

• source_location(? _File Name_, ? _Line_) (prolog_load_context/2 option)

SWI-compatible predicate If the last term has been read from a physical file (i.e., not from the file user or a string), unify File with an absolute path to the file and Line with the line-number in the file Please use prolog_load_context/2

• source_file(? _File_) (prolog_load_context/2 option)

SWI-compatible predicate True if File is a loaded Prolog source file

• source_file(? _ModuleAndPred_ ,? _File_) (prolog_load_context/2 option)

SWI-compatible predicate True if the predicate specified by ModuleAndPred was loaded from file File, where File is an absolute path name (see absolute_file_name/2 )

Definition at line 1 of file consult.yap.