Quintus Prolog Manual

n-1: Command Line Utilities

The reference pages for the Quintus supplied command line utilities follow, in alphabetical order.

     prolog(1)



     qcon(1)



     qgetpath(1)



     qld(1)



     qnm(1)



     qpc(1)



     qplm(1)



     qsetpath(1)



     qui(1)

Once these files are installed in library(q3.3), you can access them on-line by typing, for example,

        % man qpc

Refer to {manual(a-3)} for the location of these reference pages in the Quintus directory hierarchy.

n-1-0:

prolog - Quintus Prolog Development System

Synopsis:

          prolog [ +f ] [ +l file ] [ +L file ] 

          

               [ +p [path-name] ] [ +P [path-name] ] [+tty ]

               [ +z user's-arguments | + [emacs-arguments] ] 

          

Description:

• prolog is the command to invoke the Quintus Prolog Develop- ment System. The prompt | ?- indicates that the execution of Quintus Prolog Development System is in top-level mode. In this mode, Prolog queries may be issued and executed interactively. A program written in the Prolog programming language can be compiled during the execution of prolog as additional information for subsequent execution. The Prolog command halt/[0,1] is used to exit from prolog; under the GNU Emacs editor, exit is ^x^c.
• Compiled programs can be saved into a file as a saved-state. The file can be restored either through Quintus Prolog built-in restore command or issued as a command the under Unix shell. The Unix command head -1 saved-state displays how the saved-state file is restored in the latter case. The saved-state file can also be passed to qld(1) to be linked into an executable program.
• prolog depends on preset paths to locate the license files, Prolog libraries, system-dependent foreign object files, and certain executables. There are three main paths, <quintus-directory>, <runtime-directory> and <host-type>, which are set during the installation of the Quintus Prolog Development System. The paths can be checked with qgetpath(1), and changed with qsetpath(1). Upon startup, prolog checks the files in <quintus-directory>/license<quintus-version> for authorization of execution. prolog locates its libraries under the directory <quintus-directory>/generic/qplib<quintus-version> where <quintus-version> is the Quintus Prolog release number built into the executables. prolog searches the system dependent foreign object files in directories based on <host-type>. The default Emacs editor is located under <quintus-directory>/ bin<quintus-version>/<host-type>.
• Quintus Prolog Development System can be linked with other Quintus products, and user's application programs. For mre detail, see qld(1), qpc(1), and the add-on products QUI, ProXT, and ProXL which are shipped with Quintus Prolog.

Options:

Any argument which does not match options described in this section and does not start with a + is regarded as a user's argument. The user's arguments may be obtained using the prolog command unix(argv(ListOfArgs)). If a user's argument needs to begin with a +, it should be issued as ++ instead or given after the +z option. Double pluses will be translated into a single plus, so the user's code will not see the ++. Arguments beginning with + are reserved for prolog, and an unrecognized argument starting with a + is treated as an error.

+ emacs-arguments

Invoke Quintus Prolog with the Emacs interface. Any arguments following + are taken as arguments to the Emacs editor. If the environment variable QUINTUS_EDITOR_PATH is set then that Emacs invoked. Otherwise, by default, GNU emacs is assumed to be in the path as "emacs".

+f

Fast start. The initialization file $HOME/prolog.ini will not be read upon startup.

+l file

Load the specified file upon startup. file can be a Prolog or a QOF file, and it may be specified either as a string (eg. 'file', '~/prolog/file.pl) or as a file search path specification (eg. 'library(file)', 'home(language(file))'). Note, however, that the latter needs to be quoted to escape the shell interpretation of the parentheses. Giving the extension is not necessary; if both source (.pl) and QOF (.qof) files exist, the more recent of the two will be loaded.

+L file

Similar to +l but the user's environment variable PATH will be searched for the specified file.

+p [path-name]

Print the Prolog file search path definitions that begin with the string path-name (eg. library if "+p lib" is specified); path-name is optional, and if not given, all file search path definitions are printed; prolog exits after producing the required output to stdout.

+P [path-name]

Similar to +p, but the absolutized versions of the file search path definitions are printed.

+tty

Force the three standard stream associated with a Prolog process to act as tty streams. A tty stream is usually line buffered and handles prompt automatically.

+z user's-arguments

Any arguments following +z are taken as user's arguments. User's arguments can then be obtained through unix(argv(ListOfArgs)).

Environment:

HOME

Login home directory of user.

PAGER

A program to use for interactively delivering the help-system's output to the screen. The default is either more or pg depending on the host operating system.

PATH

Directories to search for the executables and saved-states.

QUINTUS_LISP_PATH

Full pathname for the emacslisp directories. The default is: <quintus-directory>/editor3.3/gnu.

QUINTUS_EDITOR_PATH

Full pathname of the GNU Emacs executable. By default the command "emacs" is looked for in your path.

SHELL

Default shell interpreter to be used for Prolog commands unix(shell) and unix(shell(<command>)).

Files:

file.pl

Prolog source file

file.qof

Quintus Object File (QOF) files

$HOME/prolog.ini

Quintus Prolog initialization file

/

Temporary files for loading foreign object files and for Emacs editor interface.

<quintus-directory>/license<quintus-version>

Location of license files

See Also:

qgetpath(1), qld(1), qpc(1), qsetpath(1), unix/1, QP_initialize()

{manual(g-3)}

qcon - QOF consolidator

Synopsis:

           qcon [ -wx ] -o output-filename    

          

Description:

• qcon consolidates the specified QOF file filename into a machine specific object file. There is no default name for the output file. Therefore, the -o option must be speci- fied. qcon is normally called from qld(1) and is not intended to be called by the user directly.

Options:

-w

Normally, qcon issues warning messages for undefined procedures. This option instructs qcon to suppress such messages.

-x

This option instructs qcon to issue warnings regarding procedures that are either not called or not defined. -x overrides the -w option.

-o output-filename

This option is used to specify a name for the object file.

See Also:

qld(1), qnm(1), qpc(1), qsetpath(1)

qgetpath - Get parameters of Quintus utilities and runtime applications

Synopsis:

qgetpath [ -abhqr ] filename ...

Description:

• qgetpath displays preset parameters defined in the Quintus Prolog executable files, printing the result to the standard output. The executable files specified must be Quintus Pro- log utilities, such as qpc and qld, runtime applications built using the Quintus Prolog Runtime Generator, prolog(1), or executables generated with qld(1).
• There are five paths, <add-ons string>, <runtime directory>, <quintus directory>, <host type> and <banner message>. <add-ons string> identifies the Quintus add-on products that are included in the executable. <runtime directory> and <quintus directory> are used in the executable to find certain files relative to those paths. <host type> identifies the platform of the executable. <banner message> is the banner displayed upon the start-up of the executable. The paths except <banner message> can be obtained through prolog command prolog_flag(<path flag>, <Variable>) where <path flag> is add_ons for <add-ons string> , runtime_directory for <runtime directory>, quintus_directory for <quintus directory>, and host_type for <host type>.

Options:

-a

Display the <add-ons string> in the specified executables.

-r

Display the <runtime directory> in the specified executables.

-q

Display the <quintus directory> in the specified executables.

-h

Display the <host type> in the specified executables.

-b

Display the <banner message> in the specified executables

See Also:

prolog(1), qsetpath(1)

qld - QOF link editor

Synopsis:

          qld [-cCdDEghkNqrRsSvwWx] [ -o output ] [ -llibrary ]

          

              [ -L library-directory ] [ -a quintus-product ]

              [ -f path-name:path-spec ]

              [ -F path-name:path-spec ]

              [ -p path-name ]

              [ -P path-name ]

              filename ... [ -LD ld-options ]

          

          

Description:

• qld links the specified QOF files together with the Kernel QOF file. This results in a single QOF file which is then consolidated into a machine object (".o") file. Finally, cc(1) is invoked to link this object file with the Kernel object file and produce an executable image called a.out. The default Kernel QOF file is <runtime directory>/qprte.qof and the default Kernel object file is <runtime directory>/qprte.o (see qsetpath(1) and qgetpath(1)).
• If any of the specified files depends on a foreign file, then that file will be included in the call to cc(1) if the '-d' options is specified. A QOF file depends on a foreign file if its source contains an embedded load_foreign_files/2 or load_foreign_executable/1 command for that file (the -D option of qnm(1) shows the dependencies of a QOF file, see qnm(1)).
• A file name in the command line could be either a QOF file with ".qof" suffix or a machine object file with ".o", ".so", or ".a" suffix. If the file name specified is a machine object file, it will be passed as an argument to cc(1). If the command line file does not exist, the same file with a ".qof" suffix is tried.
• File names may be specified either as regular paths (eg. file.qof, ~/home/file.o) or as Prolog file search paths, such as "library(file)", "home(system(file.o))", etc. Note that the file search path specifications need to be quoted to escape the shell's interpretation of the parentheses.
• The intermediate QOF and object files are deleted when qld exits (unless the -k options is specified, see below). By default, these files are stored in the directory /tmp. The environment variable TMPDIR may be set to specify another directory to be used instead for temporary files. If TMPDIR is set to a non-existent directory or to a directory to which the user does not have read and write permissions then the default value of TMPDIR is used for temporary files.

Options:

-a quintus-product

Specifies that the libraries for a particular Quintus product which is sold separately are to be used. These Quintus products are normally installed in the 'quintus-directory'. List this directory to find the valid directory names for these products. This option is equivalent to one or more -L switches. Note that the libraries shipped with Quintus Prolog (qui, proxt, and proxl) are automatically available in the system, and, therefore, require no -a flag.

-c

If this option is specified, qld terminates after producing a machine object (".o") file. It does not call cc(1) to produce an executable image. If an output file name is not specified with the -o option, the file is named a.o. No foreign files, eg. foreign dependencies, are included in the output file. The resulting object file may be passed to qld again on a different command (with -N), or it may be passed directory to the linker.

-d

This flag is always used when qpc(1) calls qld. It causes all QOF files on which any of the specified files depends to be linked in as well, and any machine object files on which any of the linked QOF files depends to be passed to cc(1). A QOF file depends on another QOF file if the source for the first contains an embedded command to load the source of the second. A QOF file depends on an object file if its source contains an embedded load_foreign_files/2 or load_foreign_executable/1 command of the object file.

-f path-name:path-spec

Similar to the -L option, but path-name:path-spec defines a general file search path which instructs qld to look for a file in directory path-spec whenever a file specification of the form path-name(file-spec) is encountered in QOF file dependencies or on the command line. The path-name and the directory, path-spec, are separated by a colon (':'), and, therefore, path-name cannot contain a colon. If path-spec is given in the file search path form (as in "library:mylib(library)"), then the argument must be quoted to escape the shell's interpretation of the parentheses. path-spec may be '.' or null, in which case '.' is assumed. There may be a list of path definitions (ie. -f or -F options) for the same path-name. Qld searches the list, just like prolog and qpc, whenever it needs to expand a file search path specification. The -f options appends (like assertz in prolog and qpc) the new path to the end of the list of paths for path-name, while -F prepends (like asserta in prolog and qpc).

-g

This option is not used by qld, but is intended for the linker. If some of the specified object files or object dependency files are compiled with the debug flag, this option should be specified to preserve the debugging information in the executable.

-h

Hides or "locks" the predicates in the file so that they are not visible to the debugger. Such predicates will have predicate_property "locked" when they are linked or loaded into a Prolog system.

-k

With this option, the intermediate files are not deleted.

-llibrary

This option is not used by qld, but is intended for the linker, which is called to link with the specified library to product the executable.

-o output

The default output file names may be overridden using this option. For executable files, the default name is a.out. With the -r or -R options, the default name is a.qof. With the -c or -C options, the default name is a.o.

-p path-name

The files search path definitions for path-name are printed. If path-name is * then all file search path definitions are printed.

-q

Like the -r option but also adds a Kernel QOF file qprte.qof or qprel.qof. This option should very rarely be necessary.

-r

If this option is specified, qld terminates after linking together all the specified QOF files to make a new QOF file. No Kernel QOF file is not linked in. If an output file name is not specified with the -o option, the file is named a.qof. If -d is not used in conjunction with this option, then it is recommended that the output file, as specified by the -o option, be in the current working directory. This way, any dependencies of the output QOF file on other files will be correct. Otherwise, the dependencies would only be correct when absolute, as opposed to relative, paths had been specified in the sources. This matters only if this file is to be used in a future call to qld with the -d option specified.

-s

This option is not used by qld, but is intended for the linker, which is called to actually generate the executable. The -s option instructs the linker to strip the executable. NOTE: that once the executable is stripped then the dynamic foreign interface including the Prolog builtins load_foreign_files/2 and load_foreign_executables/1 cannot work.

-v

When this option is specified, qld echoes its activities, including calls to subcomponents and ld.sh

-w

This option suppresses warnings regarding undefined procedures.

-x

When this option is specified, qld gives warnings about the predicates which are not called, as well as those which are undefined. Also, a warning message will be printed if either of the user-definable predicates (portray/1 and user_error_handler/4) is undefined. (Such warnings are normally suppressed for these predicates.) The -x option overrides the -w option.

-C

Same as -c, except that the object dependencies of qof files are also linked into the created object file. The object file so produced can be directly passed to cc(1), ld(1), or qld (with the -N option) to generate the executable.

-D

If this option is used, qld links the specified files with the Quintus Kernel rather than the Quintus Runtime Kernel. The Development Kernel QOF file, <runtime directory> /qprel.qof, is linked with the specified QOF file, and the Development Kernel object file, <runtime directory>/qprel.o, is passed to cc(1). The -D option may not be used in conjunction with the -E option.

-E

This option tells qld to link the specified files with the Quintus Extended Runtime Kernel rather than the Quintus Runtime Kernel. The Extended Runtime Kernel is an add-on product available separately from Quintus that allows the Quintus Prolog compiler and dynamic foreign interface to be used in runtime systems. The Extended Runtime Kernel QOF file, <runtime directory>/qprex.qof, is linked with the specified QOF file, and the default Kernel object file, <runtime directory/qprte.o, is passed to cc(1). The -E option may not be used in conjuction with the -D option.

-F path-name:path-spec

Similar to -f, but the path is added at the front of the list of paths for path-name. Note that '-F library:library-directory' is identical to '-L library-directory'.

-L library-directory

File specifications of the form library(Filespec) are searched for in the library search paths when that file is linked. The initial search paths are the same as in the Development System (see prolog(1)). Additional directories may be prepended to the list of library search paths with this option. Note that the command line is parsed from left to right. Also note that the -L must be followed by a space; otherwise, qld assumes that the option specifies a library directory for the linker. Library directories may also be specified with the -f and -F options. Note that library-directory may be a path to a directory (eg. dir, ~/dir) or a file search path specification of the form "mylib(library)". In the latter case, the path-name "mylib" must be defined by a -f or -F option.

-Ldirectory

UNIX only. Same as the -L option of cc(1) and ld(1), and specifies a directory in which the linker looks for library files. This option is simply passed to the linker.

-LD

All remaining options are simply passed to the linker.

-N

Don't link in any Kernel files (qprel.qof/qprel.o, qprex.qof/qprte.o or qprte.qof/qprte.o) from the runtime directory. This option is only useful for producing an executable image from a machine object (".o") file that was created from QOF files using qld (see -C).

-P path-name

Similar to -p, but the absolutized versions of the file search paths are also printed.

-R

Similar to -r, but it does not include the resulting dependencies. This flag is mainly useful for clearing the dependencies from the QOF file (for example, when they get absolutized by save_program/[1,2] or save_modules/2).

-S

Use static object files instead of shared object files. Where a qof file contains a dependency on a shared object file with a .so extension, if an archive file exists with the same name but with a .a extension, then this is substituted for the shared object file in the call to the linker. Note that if the shared object file that is being substituted contains dependencies to other shared libraries then these have to be included in the qld command line. Running ldd(1) on a shared object file will indicate whether it has such dependencies.

-W

Windows NT only. Pass the argument -subsystem:windows, instead of -subsystem:console, to the linker so that a Windows based executable is generated rather than a Console-based executable.

Environment:

TMPDIR

Directory for creating temporary files. The default is / usr/tmp.

Files:

file.qof

Quintus Object File (QOF) files

$TMPDIR/

.{qof,o} intermediate QOF and object files

<runtime directory>/qcon

the QOF consolidator

<runtime directory>/qprel.o

Development Kernel object code

<runtime directory>/qprte.o

Runtime Kernel object code

<runtime directory>/qprel.qof

Development Kernel QOF code

<runtime directory>/qprte.qof

Runtime Kernel QOF code

<runtime directory>/qprex.qof

Extended Runtime Kernel QOF code

<runtime directory>/ld.sh

Front End script to ld(1) (UNIX only)

See Also:

cc(1), ld(1), qcon(1), qgetpath(1), qnm(1), qpc(1), qsetpath(1)

qnm - print QOF file information

Synopsis:

          qnm [-PADFMU] [ [-m module] [-n name] [-a arity]]    

          

            [-p proc#] [-o] filename ...

          

          

Description:

• qnm prints information about each QOF file named in the argument list. The command line options specify the information required. The default behavior, if no command line option is given, is identical to the behavior of the -P option. Except where noted, only the first valid command line option is accepted per invocation of qnm; subsequent options are ignored. Each filename must be a QOF file.

Options:

-P

Print information about all procedures that are defined or called in each QOF file.

Information for a procedure is preceded by a decimal number that is unique for that QOF file. This is followed by letter codes indicating the procedure state and properties. The letter codes are:

U

undefined

S

static

D

dynamic

M

multifile

F

foreign

V

volatile

L

locked

If the procedure is neither foreign nor multifile, the second letter is omitted.

The state and property information is followed by the module, name and arity of the procedure, in the format "module:name/arity". Procedure information is sorted alphabetically by procedure name. Internal procedure names and modules that have been made anonymous are printed as "$anon".

-A

Print all atoms referenced in each QOF file. Each atom is preceded by a number that is unique for that QOF file. Atoms are sorted alphabetically. Internal atoms that have been made anonymous are printed as "$anon".

-D

Print the names of all QOF or object files and UNIX library directories on which each QOF file depends.

-F

Print the number of source files contained in the QOF file.

-M

Print information about modules contained in the QOF file. This information consists of the name of each module, its export list, and its meta-predicates.

-U

Print information about all procedures that are called but not defined in each QOF file. Information about undefined procedures is in the same format as when using the -P flag.

-m module

Print information about procedures in module module. This option may be used in conjunction with the -n and -a options.

-n name

Print information about procedures named name. This option may be used in conjunction with the -m and -a options.

-a arity

Print information about procedures with arity arity. This option may be used in conjunction with the -m and -n options.

-p proc#

Print information about the procedure numbered proc#. Procedure numbers are as given by the -P option.

-o

Prepend to each output line the name of its QOF file. The -o flag may be used in addition to any valid combination of options.

See Also:

nm(1), qpc(1), qld(1)

qpc - Quintus Prolog compiler

Synopsis:

          qpc [-cvhDHMN] [-o output] [-i initialization-file]  

          

               [ -L library-directory ] [ -a quintus-product ]

               [ -f path-name:path-spec ]

               [ -F path-name:path-spec ]

               [ -p path-name ]

               filename ...  [ -QLD qld-options ]

          

          

Description:

• qpc compiles the specified Prolog files into QOF (Quintus Object Format) files. It then invokes qld(1) to link them together and produce an executable image (unless the -c option is given). The QOF files are not deleted after processing terminates.
• Each filename must be the name of a valid Prolog source file or a QOF file. Either absolute or relative path names may be specified. If filename does not name an existing file, and if it does not already have an extension, then .pl and .qof extensions are sought in that order.
• File names may be specified as simple paths (eg. file.pl, ~/library/file) or as file search paths of the form "library(file)", "mylib(language(file))", etc. In the latter case, the path specification must be quoted to escape the shell's interpretation of the parentheses.
• Unless the -o option is given, the name of the output file is the name of the input file with the trailing '.pl', if any, replaced by '.qof'. If the input file name does not have a '.pl' extension, then a '.qof' extension is appended. The argument to -o may also be specified the file search path form (see above).
• Source files specified on the qpc command line are always recompiled even if the corresponding QOF files are up to date (unless the -M switch is specified). QOF files, on the other hand, are only recompiled if they are out of date compared to the corresponding source files.
• All the "dependencies" of a file, that is all the files named in embedded load commands in that file (or in its source if it is a QOF file), are checked to ensure that they are up-to-date, and they are recompiled if necessary. This checking and recompiling of dependencies can be disabled using the -N option.
• A filename of '-' can be used to specify that Prolog source code is to be read from the standard input. The corresponding QOF file will be called a.qof.
• Command line options may alter the above behavior as indicated below. Unrecognized options and their arguments, if any, are passed to qld(1). Furthermore, the arguments following a -QLD option are not processed by qpc but are passed to qld(1). Note also that the command line is parsed from left to right. This will affect how the file search path or library directory definitions are added if -f, -F, -L, or -a options are used.

Options:

-a quintus-product

Specifies that the libraries for a particular Quintus product which is sold separately are to be used. These Quintus products are normally installed in the 'quintus-directory'. List this directory to find the valid directory names for these products. This option is equivalent to one or more -L switches. Note that the libraries shipped with Quintus Prolog (qui, proxt, and proxl) are automatically available in the system, and, therefore, require no -a flag.

-c

The input files are simply compiled into QOF format, and no further processing takes place.

-f path-name:path_spec

Similar to the -L option, but path-name:path-spec defines a general file search which instructs qpc to look for a file in directory path-spec whenever a file specification of the form path-name(file-spec) is encountered (in embedded load commands, in QOF file dependencies, or on the command line). The path-name and the directory, path-spec, are separated by ':', and, therefore, path-name cannot contain a colon. If path-spec is given in the file search path form (as in "library:mylib(library)"), then the argument must be quoted to escape the shell's interpretation of the parentheses. path-spec may be '.' or null, in which case '.' is assumed. There may be a list of path definitions (ie. -f or -F options) for the same path-name. Qpc searches the list, just like prolog, whenever it needs to expand a file search path specification. The -f options appends (like assertz in prolog) the new path to the end of the list of paths for path-name, while -F prepends (like asserta in prolog). File search paths may also be defined using asserts in the Prolog source being compiled or in initializaiton files (see -i). The -f, -F, -L, and -a options given on the qpc command line, and file_search_path and library_directory definitions asserted in source files or initialization files, are passed on to qld(1).

-h

Hides or "locks" the predicates in the file so that they are not visible to the debugger. Such predicates will have predicate_property "locked" when they are linked or loaded into a Prolog system.

-i initialization-file

Specifies an initialization file. The initialization file may be a source (.pl) or QOF (.qof) file. Currently, source files cannot load foreign code; in other words, they cannot contain calls to load_foreign_files/2 or load_foreign_executable/1. The definitions in the initialization file apply during the compilation of all files specified to the right of the -i switch on the command line. The definitions in the initialization file apply only during compile time. Therefore, no QOF file is generated from an initialization file and its content is not included in any of the generated QOF files. The initialization file may be specified in the file search path form (eg. '-i "library(basics)"').

-o output

Specifies a name for the output file. If used with the -c option, the qof file will be produced into the given file. In this case, there may be several -o options for each qof file. If the -o names a directory, all qof files will be placed in the given directory. If the -c option is not used, the -o is passed onto qld.

-p path-name

This option is just passed to qld along with its argument, asking qld to print out the file search definition for path-name.

-v

When this option is specified, qpc echoes its activities, including the call to qld(1), to the standard output. This flag is also passed on to qld.

-D

This option is just passed to the linker qld indicating that the Quintus Development System should be linked in.

-F path-name:path-spec

Similar to -f, but the path is added at the front of the list of paths for path-name. Note that '-F library:library-directory' is identical to '-L library-directory'.

-H

Like -h but in this case the hiding (locking) is done also to any files that are compiled because of embedded load commands in the file.

-L library-directory

File specifications of the form library(Filespec) encountered in embedded load commands are searched for in the library search paths. The initial search paths are the same as in the Development System (see prolog(1)). Additional directories may be prepended to the list of library search paths with this option. Note that the command line is parsed from left to right. Also note that the -L must be followed by a space; otherwise, qpc assumes that the option specifies a library directory for ld(1). Library directories may also be specified with the -f and -F options. library-directory may be a path to a directory (eg. dir, ~/dir) or a file search path specification of the form "mylib(library)". In the latter case, the path-name "mylib" must be defined either in the Prolog source code being compiled or by -f or -F options.

-M

Specifies that files on the command line are not to be compiled if their corresponding QOF files are more recent than they are.

-N

Specifies that files specified in embedded load com- mands are not to be compiled. (By default they would be compiled unless their QOF files are already up-to- date.)

-QLD

All remaining options are simply passed to qld.

Environment:

TMPDIR

Directory for creating temporary files. The default is / usr/tmp

Files:

a.out

Executable output file

a.qof

Output QOF file if filename is '-'

file.pl

Prolog source file

file.qof

Quintus QOF file

$TMPDIR/

Compiler temporary files

<runtime directory>/qld

QOF link editor

<runtime directory>/qcon

QOF consolidator

See Also:

prolog(1), qcon(1), qgetpath(1), qld(1), qnm(1)

qplm - Quintus Prolog license manager

Synopsis:

          qplm -i SiteName

          

          qplm -a Product Users [ Expiration ] Code

          

          qplm -d User Product

          

          qplm -p

          

Description:

• qplm initializes and maintains the license files for Quintus products.
• A code is supplied for each Quintus product that is based on the name of the site or company name, product name, number of users and optionally an expiration date.
• Users are distinguished as either occasional users, if they have used the product less than 5 times, or else regular users. When determining whether the number of users is within that allowed by the license, only regular users are counted.
• Expiration dates are specified with the format YY-MM-DD.

Options:

-i SiteName

Initializes the license files for SiteName, where SiteName is a number of arguments comprising the site or company name. This command must be executed before any products are added.

-a Product Users Expiration Code

Adds a products to the license file. The product is typically of the form <name>/<arch>/<version>, Users is the number of users allowed to use the product. Expiration is an optional argument specifying when the license will expire. The final Code argument is a 16 character code that is based on the SiteName, Product, Users and Expiration.

-d User Product

Deletes User from the list of users who use Product. When a user no longer uses Product, he or she can be removed from the license file with this option.

-p

Print the information in the license file. This prints the site name followed by all of the products licensed. This also prints the list of users using each product. For occasional users, the number of times they have used the product is also shown.

Example:

To initialize the license file:

              qplm -i Hallatrow Designers Inc.



           

To add a 2 user license for Prolog that expires on 17 May 1994,

    qplm -a prolog/hppa/3.3 2 94-05-17 thiscodewontwork



          

Files:

license.qof

Contains the site name and product codes

users.qof

Records the users using the products

The license files are maintained in the license<version> subdirectory of <quintus-directory>. The users.qof file must be writable by all users, therefore if the <quintus-directory> is stored on a read-only file system then the license subdirectory should be made into a symbolic link to a writable directory.

See Also:

prolog(1),

qsetpath - Set parameters of Quintus utilities and runtime applications

Synopsis:

          qsetpath [ -aadd-ons ] [ -rruntime-directory ]    

          

          [ -qquintus-directory ] [ -hhost-type ]

                    [ -bbanner-message ] filename ...

          

          

Description:

• qsetpath sets parameters for the executable files. The executable files specified must be Quintus Prolog utilities, such as qpc and qld, runtime applications built using the Quintus Prolog Runtime Generator, prolog(1), or executables generated with qld(1). There are five settable paths, <add-ons string>, <runtime directory>, <quintus directory>, <host type> and <banner message>. <add-ons string> identifies the Quintus add-on products that are included in the executable. <runtime directory> and <quintus directory> are used in the executable to find certain files relative to the those paths. <host type> identifies the platform of the installation. <banner message> is the banner displayed upon the start-up of the executable. The paths except <banner message> can be obtained through prolog command prolog_flag(<path flag>, <Variable>) where <path flag> is add_ons for <add-ons string>, runtime_directory for <runtime directory>, quintus_directory for <quintus directory>, and host_type for <host type>.

Options:

-aadd-ons

Set the add-ons identification string of the specified executables to <add-ons string>.

-rruntime-directory

Set the <runtime directory> of the specified executables to runtime-directory. The specified runtime- directory must be an absolute path.

-qquintus-directory

Set the <quintus directory> of the specified executables to quintus-directory. The specified quintus- directory must be an absolute path.

-h/host-type

Set the <host type> of the specified executables to host-type. There must be a "/" proceeding host-type. A host-type should be in the form of <machine type>, <machine type>-<major O.S. version>, or <machine type-<major O.S. version>.<minor O.S. version>.

-bbanner-message

Set the displayed banner message for the specified executables to banner-message.

Errors:

• Setting banner message has partial or no effects on certain executables.
• Argument specification must following the option immediately. There is no white space allowed between an option and its argument.

See Also::

prolog(1), qgetpath(1), qld(1)

qui - Quintus User Interface

Synopsis:

          qui [ +f ] [ +l file ] [ +L file ] 

          

              [ +p [path-name] ] [ +P [path-name] ]

                    [ X-window arguments ]

                    [ +z users arguments ] 

          

Description:

• The Quintus User Interface (QUI) is a Motif-based window interface to the Quintus Prolog Development System. It includes a query interpreter window with history menu, a source linked debugger, a help window for accessing the on-line manuals and an edit window as well as an interface to the GNU Emacs editor.

Options:

Any argument which does not match options described in this section and does not start with a + is regarded as a user's argument. The user's arguments may be obtained using the prolog command unix(argv(ListOfArgs)). If a user's argument needs to begin with a +, it should be issued as ++ instead or given after the +z option. Double pluses will be translated into a single plus, so the user's code will not see the ++. Arguments beginning with + are reserved for prolog, and an unrecognized argument starting with a + is treated as an error.

+f

Fast start. The initialization file $HOME/prolog.ini will not be read upon startup.

+l file

Load the specified file upon startup. file can be a Prolog or a QOF file, and it may be specified either as a string (eg. 'file', '~/prolog/file.pl') or as a file search path specification (eg. 'library(file)', 'home(language(file))'). Note, however, that the latter needs to be quoted to escape the shell interpretation of the parentheses. Giving the extension is not necessary; if both source (.pl) and QOF (.qof) files exist, the more recent of the two will be loaded.

+L file

Similar to +l but the user's environment variable PATH will be searched for the specified file.

+p [path-name]

Print the Prolog file search path definitions that begin with the string path-name (eg. library if "+p lib" is specified); path-name is optional, and if not given, all file search path definitions are printed; prolog exits after producing the required output to stdout.

+P [path-name]

Similar to +p, but the absolutized versions of the file search path definitions are printed.

X-Window arguments

Any arguments recognized as standard X options are passed to the X-Window system. Examples of these include -display displayname, -fg color, -bg color.

+z user's-arguments

Any arguments following +z are taken as user's arguments. User's arguments can then be obtained through unix(argv(ListOfArgs)).

Environment:

QUINTUS_EDITOR_PATH

Name of the GNU Emacs command. If set, this is invoked as the editor rather than the standard text editor built in to QUI.

QUINTUS_LISP_PATH

Full pathname for the emacs lisp directories. The default is: <quintus-directory>/editor3.3/gnu.

See Also:

prolog(1)

{manual(c-1)}

contact: product support sales information