The Ciao Prolog System

• Summary
• Introduction
  • About this manual
  • About the Ciao Prolog development system
  • ISO-Prolog compliance versus extensibility
  • About the name of the System
  • Referring to Ciao
  • Syntax terminology and notational conventions
    • Predicates and their components
    • Characters and character strings
    • Predicate specs
    • Modes
    • Properties and types
    • Declarations
    • Operators
  • A tour of the manual
    • PART I - The program development environment
    • PART II - The Ciao basic language (engine)
    • PART III - ISO-Prolog library (iso)
    • PART IV - Classic Prolog library (classic)
    • PART V - Annotated Prolog library (assertions)
    • PART VI - Ciao Prolog library miscellanea
    • PART VII - Ciao Prolog extensions
    • PART VIII - Interfaces to other languages and systems
    • PART IX - Abstract data types
    • PART X - Miscellaneous standalone utilities
    • PART XI - Contributed libraries
    • PART XII - Appendices
  • Acknowledgments
  • Version/Change Log (ciao)
• Getting started on Un*x-like machines
  • Testing your Ciao Un*x installation
  • Un*x user setup
  • Using Ciao from a Un*x command shell
    • Starting/exiting the top-level shell (Un*x)
    • Getting help (Un*x)
    • Compiling and running programs (Un*x)
    • Generating executables (Un*x)
    • Running Ciao scripts (Un*x)
    • The Ciao initialization file (Un*x)
    • Printing manuals (Un*x)
  • An introduction to the Ciao emacs environment (Un*x)
  • Keeping up to date (Un*x)
• Getting started on Windows machines
  • Testing your Ciao Win32 installation
  • Using Ciao from the Windows explorer and command shell
    • Starting/exiting the top-level shell (Win32)
    • Getting help (Win32)
    • Compiling and running programs (Win32)
    • Generating executables (Win32)
    • Running Ciao scripts (Win32)
    • The Ciao initialization file (Win32)
    • Printing manuals (Win32)
  • An introduction to the Ciao emacs environment (Win32)
  • Keeping up to date (Win32)
• PART I - The program development environment
• The stand-alone command-line compiler
  • Introduction to building executables
  • Paths used by the compiler during compilation
  • Running executables from the command line
  • Types of executables generated
  • Environment variables used by Ciao executables
  • Intermediate files in the compilation process
  • Usage (ciaoc)
• The interactive top-level shell
  • Shell invocation and startup
  • Shell interaction
  • Entering recursive (conjunctive) shell levels
  • Usage and interface (ciaosh)
  • Documentation on exports (ciaosh)
  • Documentation on internals (ciaosh)
• The interactive debugger
  • Marking modules and files for debugging in the top-level debugger
  • The debugging process
  • Marking modules and files for debugging with the embedded debugger
  • The procedure box control flow model
  • Format of debugging messages
  • Options available during debugging
  • Calling predicates that are not exported by a module
  • Acknowledgements
• Predicates controlling the interactive debugger
  • Usage and interface (debugger)
  • Documentation on exports (debugger)
  • Documentation on internals (debugger)
  • Known bugs and planned improvements (debugger)
• The script interpreter
  • How it works
  • Command line arguments in scripts
• Customizing library paths and path aliases
  • Usage and interface (libpaths)
  • Documentation on exports (libpaths)
  • Documentation on multifiles (libpaths)
• Using Ciao inside GNU emacs
  • Conventions for writing Ciao programs under Emacs
  • Checking the installation
  • Functionality and associated key sequences (bindings)
  • Syntax coloring and syntax-based editing
  • Getting on-line help
  • Loading and compiling programs
  • Commands available in toplevel and preprocessor buffers
  • Locating errors and checking the syntax of assertions
  • Commands which help typing in programs
  • Debugging programs
  • Preprocessing programs
  • Version control
  • Generating program documentation
  • Setting top level preprocessor and documenter executables
  • Other commands
  • Traditional Prolog Mode Commands
  • Coexistence with other Prolog interfaces
  • Getting the Ciao/Prolog mode version
  • Using Ciao/Prolog mode capabilities in standard shells
  • Customization
    • Ciao general variables
    • CiaoPP variables
    • LPdoc variables
    • Faces used in syntax-based highlighting (coloring)
  • Installation of the Ciao/Prolog emacs interface
  • Emacs version compatibility
  • Acknowledgments (ciao.el)
• PART II - The Ciao basic language (engine)
• The module system
  • Usage and interface (modules)
  • Documentation on internals (modules)
• Directives for using code in other files
  • Usage and interface (loading_code)
  • Documentation on internals (loading_code)
• Control constructs/predicates
  • Usage and interface (basiccontrol)
  • Documentation on exports (basiccontrol)
  • Documentation on internals (basiccontrol)
• Basic builtin directives
  • Usage and interface (builtin_directives)
  • Documentation on internals (builtin_directives)
• Basic data types and properties
  • Usage and interface (basic_props)
  • Documentation on exports (basic_props)
• Extra-logical properties for typing
  • Usage and interface (term_typing)
  • Documentation on exports (term_typing)
• Basic term manipulation
  • Usage and interface (term_basic)
  • Documentation on exports (term_basic)
• Comparing terms
  • Usage and interface (term_compare)
  • Documentation on exports (term_compare)
• Basic predicates handling names of constants
  • Usage and interface (atomic_basic)
  • Documentation on exports (atomic_basic)
• Arithmetic
  • Usage and interface (arithmetic)
  • Documentation on exports (arithmetic)
• Basic file/stream handling
  • Usage and interface (streams_basic)
  • Documentation on exports (streams_basic)
  • Documentation on multifiles (streams_basic)
• Basic input/output
  • Usage and interface (io_basic)
  • Documentation on exports (io_basic)
• Exception handling
  • Usage and interface (exceptions)
  • Documentation on exports (exceptions)
• Changing system behaviour and various flags
  • Usage and interface (prolog_flags)
  • Documentation on exports (prolog_flags)
  • Documentation on multifiles (prolog_flags)
• Fast/concurrent update of facts
  • Usage and interface (data_facts)
  • Documentation on exports (data_facts)
  • Documentation on internals (data_facts)
• Extending the syntax
  • Usage and interface (syntax_extensions)
  • Documentation on internals (syntax_extensions)
• Message printing primitives
  • Usage and interface (io_aux)
  • Documentation on exports (io_aux)
  • Known bugs and planned improvements (io_aux)
• Attributed variables
  • Usage and interface (attributes)
  • Documentation on exports (attributes)
  • Documentation on multifiles (attributes)
  • Other information (attributes)
• Gathering some basic internal info
  • Usage and interface (system_info)
  • Documentation on exports (system_info)
  • Documentation on internals (system_info)
• Other predicates and features defined by default
  • Usage and interface (default_predicates)
  • Documentation on exports (default_predicates)
• PART III - ISO-Prolog library (iso)
• ISO-Prolog package
  • Usage and interface (iso)
• All solutions predicates
  • Usage and interface (aggregates)
  • Documentation on exports (aggregates)
• Dynamic predicates
  • Usage and interface (dynamic)
  • Documentation on exports (dynamic)
  • Documentation on multifiles (dynamic)
• Term input
  • Usage and interface (read)
  • Documentation on exports (read)
  • Documentation on multifiles (read)
  • Documentation on internals (read)
  • Known bugs and planned improvements (read)
• Term output
  • Usage and interface (write)
  • Documentation on exports (write)
  • Documentation on multifiles (write)
• Defining operators
  • Usage and interface (operators)
  • Documentation on exports (operators)
• The Iso Byte Char module
  • Usage and interface (iso_byte_char)
  • Documentation on exports (iso_byte_char)
• Miscellaneous ISO Prolog predicates
  • Usage and interface (iso_misc)
  • Documentation on exports (iso_misc)
• Incomplete ISO Prolog predicates
  • Usage and interface (iso_incomplete)
  • Documentation on exports (iso_incomplete)
• PART IV - Classic Prolog library (classic)
• Definite clause grammars
  • Usage and interface (dcg)
• Definite clause grammars (expansion)
  • Usage and interface (dcg_expansion)
  • Documentation on exports (dcg_expansion)
• Formatted output
  • Usage and interface (format)
  • Documentation on exports (format)
• List processing
  • Usage and interface (lists)
  • Documentation on exports (lists)
• Sorting lists
  • Usage and interface (sort)
  • Documentation on exports (sort)
  • Documentation on internals (sort)
• compiler (library)
  • Usage and interface (compiler)
  • Documentation on exports (compiler)
• Enumeration of integers inside a range
  • Usage and interface (between)
  • Documentation on exports (between)
• Operating system utilities
  • Usage and interface (system)
  • Documentation on exports (system)
  • Documentation on multifiles (system)
  • Known bugs and planned improvements (system)
• Prolog system internal predicates
  • Usage and interface (prolog_sys)
  • Documentation on exports (prolog_sys)
  • Documentation on internals (prolog_sys)
  • Known bugs and planned improvements (prolog_sys)
• DEC-10 Prolog file IO
  • Usage and interface (dec10_io)
  • Documentation on exports (dec10_io)
• Quintus-like internal database
  • Usage and interface (old_database)
  • Documentation on exports (old_database)
• ttyout (library)
  • Usage and interface (ttyout)
  • Documentation on exports (ttyout)
• Enabling operators at run-time
  • Usage and interface (runtime_ops)
• PART V - Annotated Prolog library (assertions)
• The Ciao assertion package
  • More info
  • Some attention points
  • Usage and interface (assertions)
  • Documentation on new declarations (assertions)
  • Documentation on exports (assertions)
• Types and properties related to assertions
  • Usage and interface (assertions_props)
  • Documentation on exports (assertions_props)
• Declaring regular types
  • Defining properties
  • Usage and interface (regtypes)
  • Documentation on new declarations (regtypes)
• Properties which are native to analyzers
  • Usage and interface (native_props)
  • Documentation on exports (native_props)
• ISO-Prolog modes
  • Usage and interface (isomodes)
  • Documentation on new modes (isomodes)
• Classical Prolog modes
  • Usage and interface (basicmodes)
  • Documentation on new modes (basicmodes)
• Run-time checking of assertions
  • Usage and interface (rtchecks)
  • Documentation on exports (rtchecks)
  • Documentation on internals (rtchecks)
  • Known bugs and planned improvements (rtchecks)
• PART VI - Ciao Prolog library miscellanea
• Structured stream handling
  • Usage and interface (streams)
  • Documentation on exports (streams)
• Dictionaries
  • Usage and interface (dict)
  • Documentation on exports (dict)
• String processing
  • Usage and interface (strings)
  • Documentation on exports (strings)
  • Documentation on internals (strings)
• Printing status and error messages
  • Usage and interface (messages)
  • Documentation on exports (messages)
  • Documentation on multifiles (messages)
  • Documentation on internals (messages)
  • Known bugs and planned improvements (messages)
• Accessing and redirecting the stream aliases
  • Usage and interface (io_alias_redirection)
  • Documentation on exports (io_alias_redirection)
• Atom to term conversion
  • Usage and interface (atom2term)
  • Documentation on exports (atom2term)
  • Known bugs and planned improvements (atom2term)
• ctrlcclean (library)
  • Usage and interface (ctrlcclean)
  • Documentation on exports (ctrlcclean)
• errhandle (library)
  • Usage and interface (errhandle)
  • Documentation on exports (errhandle)
• Fast reading and writing of terms
  • Usage and interface (fastrw)
  • Documentation on exports (fastrw)
  • Known bugs and planned improvements (fastrw)
• File name manipulation
  • Usage and interface (filenames)
  • Documentation on exports (filenames)
• Symbolic filenames
  • Usage and interface (symfnames)
  • Documentation on exports (symfnames)
  • Documentation on multifiles (symfnames)
  • Other information (symfnames)
• File I/O utilities
  • Usage and interface (file_utils)
  • Documentation on exports (file_utils)
• File locks
  • Usage and interface (file_locks)
  • Documentation on exports (file_locks)
  • Known bugs and planned improvements (file_locks)
• Term manipulation utilities
  • Usage and interface (terms)
  • Documentation on exports (terms)
• Term checking utilities
  • Usage and interface (terms_check)
  • Documentation on exports (terms_check)
  • Other information (terms_check)
• Sets of variables in terms
  • Usage and interface (terms_vars)
  • Documentation on exports (terms_vars)
• A simple pretty-printer for Ciao programs
  • Usage and interface (pretty_print)
  • Documentation on exports (pretty_print)
  • Documentation on internals (pretty_print)
• Pretty-printing assertions
  • Usage and interface (assrt_write)
  • Documentation on exports (assrt_write)
• The Ciao library browser
  • Usage and interface (librowser)
  • Documentation on exports (librowser)
  • Documentation on internals (librowser)
• Code translation utilities
  • Usage and interface (expansion_tools)
  • Documentation on exports (expansion_tools)
  • Documentation on internals (expansion_tools)
  • Known bugs and planned improvements (expansion_tools)
• Low-level concurrency/multithreading primitives
  • Usage and interface (concurrency)
  • Documentation on exports (concurrency)
  • Known bugs and planned improvements (concurrency)
• All solutions concurrent predicates
  • Usage and interface (conc_aggregates)
  • Documentation on exports (conc_aggregates)
  • Known bugs and planned improvements (conc_aggregates)
• The socket interface
  • Usage and interface (sockets)
  • Documentation on exports (sockets)
• Sockets I/O
  • Usage and interface (sockets_io)
  • Documentation on exports (sockets_io)
• The Ciao Make Package
  • Usage and interface (make)
  • Other information (make)
    • The Dependency Rules
    • Specifying Paths
    • Documenting Rules
    • An Example of a Makefile
• Predicates Available When Using The Make Package
  • Usage and interface (make_rt)
  • Documentation on exports (make_rt)
• system_extra (library)
  • Usage and interface (system_extra)
  • Documentation on exports (system_extra)
• PART VII - Ciao Prolog extensions
• Pure Prolog package
  • Usage and interface (pure)
  • Known bugs and planned improvements (pure)
• Multiple Argument Indexing
  • Usage and interface (indexer)
  • Documentation on internals (indexer)
• Higher-order
  • Usage and interface (hiord_rt)
  • Documentation on exports (hiord_rt)
• Higher-order predicates
  • Usage and interface (hiordlib)
  • Documentation on exports (hiordlib)
• Terms with named arguments -records/feature terms
  • Usage and interface (argnames)
  • Documentation on new declarations (argnames)
  • Other information (argnames)
    • Using argument names in a toy database
    • Complete code for the zebra example
  • Known bugs and planned improvements (argnames)
• Functional notation
  • Usage and interface (functions)
  • Known bugs and planned improvements (functions)
• global (library)
  • Usage and interface (global)
  • Documentation on exports (global)
• Independent and-parallel execution
  • Usage and interface (andprolog)
  • Documentation on internals (andprolog)
  • Known bugs and planned improvements (andprolog)
• Andorra execution
  • Usage and interface (andorra)
  • Documentation on new declarations (andorra)
  • Documentation on exports (andorra)
  • Other information (andorra)
• Call on determinate
  • Usage and interface (det_hook_rt)
  • Documentation on exports (det_hook_rt)
  • Documentation on internals (det_hook_rt)
  • Other information (det_hook_rt)
  • Known bugs and planned improvements (det_hook_rt)
• Miscellaneous predicates
  • Usage and interface (odd)
  • Documentation on exports (odd)
• Delaying predicates (freeze)
  • Usage and interface (freeze)
  • Documentation on exports (freeze)
• Delaying predicates (when)
  • Usage and interface (when)
  • Documentation on exports (when)
  • Known bugs and planned improvements (when)
• Active modules (high-level distributed execution)
  • Active module name servers
  • Active modules as agents
  • Usage and interface (actmods)
  • Documentation on new declarations (actmods)
  • Known bugs and planned improvements (actmods)
• Breadth-first execution
  • Usage and interface (bf)
  • Known bugs and planned improvements (bf)
• Iterative-deepening execution
  • Usage and interface (id)
• Constraint programming over rationals
  • Usage and interface (clpq)
  • Other information (clpq)
    • Some CLP(Q) examples
  • Known bugs and planned improvements (clpq)
• Constraint programming over reals
  • Usage and interface (clpr)
  • Other information (clpr)
    • Some CLP(R) examples
  • Known bugs and planned improvements (clpr)
• Fuzzy Prolog
  • Usage and interface (fuzzy)
  • Documentation on new declarations (fuzzy)
  • Documentation on exports (fuzzy)
  • Other information (fuzzy)
  • Known bugs and planned improvements (fuzzy)
• Object oriented programming
  • Early examples
  • Recommendations on when to use objects
  • Limitations on object usage
• Declaring classes and interfaces
  • Usage and interface (class)
  • Documentation on new declarations (class)
  • Documentation on exports (class)
  • Other information (class)
    • Class and Interface error reporting at compile time
    • Class and Interface error reporting at run time
    • Normal Prolog module system interaction
  • Known bugs and planned improvements (class)
• Compile-time usage of objects
  • Usage and interface (objects)
  • Documentation on new declarations (objects)
  • Other information (objects)
    • Error reporting at compile time (objects)
    • Error reporting at run time (objects)
• Run time usage of objects
  • Usage and interface (objects_rt)
  • Documentation on exports (objects_rt)
  • Known bugs and planned improvements (objects_rt)
• The Ciao Remote Services Package
  • Usage and interface (remote)
  • Documentation on exports (remote)
  • Known bugs and planned improvements (remote)
• PART VIII - Interfaces to other languages and systems
• Foreign Language Interface
  • Declaration of Types
  • Equivalence between Ciao Prolog and C types
  • Equivalence between Ciao Prolog and C modes
  • Custom access to Prolog from C
    • Term construction
    • Testing the Type of a Term
    • Term navigation
    • Testing for Equality and Performing Unification
    • Raising Exceptions
    • Creating and disposing of memory chunks
    • Calling Prolog from C
  • Examples
    • Mathematical functions
    • Addresses and C pointers
    • Lists of bytes and buffers
    • Lists of integers
    • Strings and atoms
    • Arbitrary Terms
    • Exceptions
    • Testing number types and using unbound length integers
  • Usage and interface (foreign_interface)
• Foreign Language Interface Properties
  • Usage and interface (foreign_interface_properties)
  • Documentation on exports (foreign_interface_properties)
  • Documentation on internals (foreign_interface_properties)
  • Known bugs and planned improvements (foreign_interface_properties)
• Utilities for on-demand compilation of foreign files
  • Usage and interface (foreign_compilation)
  • Documentation on exports (foreign_compilation)
• Foreign Language Interface Builder
  • Usage and interface (build_foreign_interface)
  • Documentation on exports (build_foreign_interface)
• Interface to daVinci
  • Usage and interface (davinci)
  • Documentation on exports (davinci)
  • Documentation on internals (davinci)
• The Tcl/Tk interface
  • Usage and interface (tcltk)
  • Documentation on exports (tcltk)
• Low level interface library to Tcl/Tk
  • Usage and interface (tcltk_low_level)
  • Documentation on exports (tcltk_low_level)
  • Documentation on internals (tcltk_low_level)
• The Tcl/Tk Class Interface
  • Usage and interface (window_class)
  • Documentation on exports (window_class)
• widget_class (library)
  • Usage and interface (widget_class)
  • Documentation on exports (widget_class)
• menu_class (library)
  • Usage and interface (menu_class)
  • Documentation on exports (menu_class)
• canvas_class (library)
  • Usage and interface (canvas_class)
  • Documentation on multifiles (canvas_class)
• button_class (library)
  • Usage and interface (button_class)
  • Documentation on exports (button_class)
• checkbutton_class (library)
  • Usage and interface (checkbutton_class)
  • Documentation on exports (checkbutton_class)
• radiobutton_class (library)
  • Usage and interface (radiobutton_class)
  • Documentation on exports (radiobutton_class)
• entry_class (library)
  • Usage and interface (entry_class)
  • Documentation on exports (entry_class)
• label_class (library)
  • Usage and interface (label_class)
  • Documentation on exports (label_class)
• menubutton_class (library)
  • Usage and interface (menubutton_class)
  • Documentation on exports (menubutton_class)
• menu_entry_class (library)
  • Usage and interface (menu_entry_class)
  • Documentation on exports (menu_entry_class)
• shape_class (library)
  • Usage and interface (shape_class)
  • Documentation on exports (shape_class)
• arc_class (library)
  • Usage and interface (arc_class)
  • Documentation on exports (arc_class)
• oval_class (library)
  • Usage and interface (oval_class)
  • Documentation on exports (oval_class)
• poly_class (library)
  • Usage and interface (poly_class)
  • Documentation on exports (poly_class)
• line_class (library)
  • Usage and interface (line_class)
  • Documentation on exports (line_class)
• text_class (library)
  • Usage and interface (text_class)
  • Documentation on exports (text_class)
• The PiLLoW Web programming library
  • Installing PiLLoW
  • Usage and interface (pillow)
• HTML/XML/CGI programming
  • Usage and interface (html)
  • Documentation on exports (html)
  • Documentation on multifiles (html)
  • Other information (html)
• HTTP conectivity
  • Usage and interface (http)
  • Documentation on exports (http)
• PiLLoW types
  • Usage and interface (pillow_types)
  • Documentation on exports (pillow_types)
• Persistent predicate database
  • Introduction to persistent predicates
  • Persistent predicates, files, and relational databases
  • Using file-based persistent predicates
  • Implementation Issues
  • Defining an initial database
  • Using persistent predicates from the top level
  • Usage and interface (persdbrt)
  • Documentation on exports (persdbrt)
  • Documentation on multifiles (persdbrt)
  • Documentation on internals (persdbrt)
  • Known bugs and planned improvements (persdbrt)
• Using the persdb library
  • An example of persistent predicates (static version)
  • An example of persistent predicates (dynamic version)
  • A simple application / a persistent queue
• Filed predicates
  • Usage and interface (factsdb_rt)
  • Documentation on exports (factsdb_rt)
  • Documentation on multifiles (factsdb_rt)
  • Documentation on internals (factsdb_rt)
  • Known bugs and planned improvements (factsdb_rt)
• SQL persistent database interface
  • Implementation of the Database Interface
  • Example(s)
  • Usage and interface (persdbrt_mysql)
  • Documentation on exports (persdbrt_mysql)
  • Documentation on multifiles (persdbrt_mysql)
  • Documentation on internals (persdbrt_mysql)
  • Known bugs and planned improvements (persdbrt_mysql)
• Prolog to SQL translator
  • Usage and interface (pl2sql)
  • Documentation on exports (pl2sql)
  • Documentation on multifiles (pl2sql)
  • Documentation on internals (pl2sql)
  • Known bugs and planned improvements (pl2sql)
• Low-level socket interface to SQL/ODBC databases
  • Usage and interface (mysql_client)
  • Documentation on exports (mysql_client)
• Types for the Low-level interface to SQL databases
  • Usage and interface (db_client_types)
  • Documentation on exports (db_client_types)
• sqltypes (library)
  • Usage and interface (sqltypes)
  • Documentation on exports (sqltypes)
• persdbtr_sql (library)
  • Usage and interface (persdbtr_sql)
  • Documentation on exports (persdbtr_sql)
• pl2sqlinsert (library)
  • Usage and interface (pl2sqlinsert)
  • Documentation on exports (pl2sqlinsert)
  • Documentation on multifiles (pl2sqlinsert)
• Prolog to Java interface
  • Prolog to Java Interface Structure
    • Prolog side of the Java interface
    • Java side
  • Java event handling from Prolog
  • Java exception handling from Prolog
  • Usage and interface (javart)
  • Documentation on exports (javart)
• Java to Prolog interface
  • Usage and interface (jtopl)
  • Documentation on exports (jtopl)
• Low-level Prolog to Java socket connection
  • Usage and interface (javasock)
  • Documentation on exports (javasock)
• Calling emacs from Prolog
  • Usage and interface (emacs)
  • Documentation on exports (emacs)
• linda (library)
  • Usage and interface (linda)
  • Documentation on exports (linda)
• PART IX - Abstract data types
• Extendable arrays with logarithmic access time
  • Usage and interface (arrays)
  • Documentation on exports (arrays)
• counters (library)
  • Usage and interface (counters)
  • Documentation on exports (counters)
• Identity lists
  • Usage and interface (idlists)
  • Documentation on exports (idlists)
• Lists of numbers
  • Usage and interface (numlists)
  • Documentation on exports (numlists)
• Pattern (regular expression) matching
  • Usage and interface (patterns)
  • Documentation on exports (patterns)
• Graphs
  • Usage and interface (graphs)
  • Documentation on exports (graphs)
  • Documentation on internals (graphs)
• Unweighted graph-processing utilities
  • Usage and interface (ugraphs)
  • Documentation on exports (ugraphs)
• wgraphs (library)
  • Usage and interface (wgraphs)
  • Documentation on exports (wgraphs)
• Labeled graph-processing utilities
  • Usage and interface (lgraphs)
  • Documentation on exports (lgraphs)
• queues (library)
  • Usage and interface (queues)
  • Documentation on exports (queues)
• Random numbers
  • Usage and interface (random)
  • Documentation on exports (random)
• Set Operations
  • Usage and interface (sets)
  • Documentation on exports (sets)
• Variable name dictionaries
  • Usage and interface (vndict)
  • Documentation on exports (vndict)
• PART X - Miscellaneous standalone utilities
• A Program to Help Cleaning your Directories
  • Usage (cleandirs)
  • Known bugs and planned improvements (cleandirs)
• Printing the declarations and code in a file
  • Usage (fileinfo)
  • More detailed explanation of options (fileinfo)
• Printing the contents of a bytecode file
  • Usage (viewpo)
• Crossed-references of a program
• Gathering the dependent files for a file
  • Usage (get_deps)
• Finding differences between two Prolog files
  • Usage (pldiff)
  • Known bugs and planned improvements (pldiff)
• The Ciao lpmake scripting facility
  • General operation
  • Format of the Configuration File
  • lpmake usage
  • Acknowledgments (lpmake)
• Find out which architecture we are running on
  • Usage (ciao_get_arch)
  • More details
• Print out WAM code
  • Usage (compiler_output)
• PART XI - Contributed libraries
• Programming MYCIN rules
  • Usage and interface (mycin)
  • Documentation on new declarations (mycin)
  • Known bugs and planned improvements (mycin)
• Constraint programming over finite domains
  • Usage and interface (fd)
  • Documentation on exports (fd)
• XDR handle library
  • Usage and interface (xdr_handle)
  • Documentation on exports (xdr_handle)
• XML query library
  • Usage and interface (xml_path)
  • Documentation on exports (xml_path)
  • Documentation on internals (xml_path)
• A Chart Library
  • Bar charts
  • Line graphs
  • Scatter graphs
  • Tables
  • Overview of widgets
  • Usage and interface (chartlib)
  • Documentation on exports (chartlib)
• Low level Interface between Prolog and blt
  • Usage and interface (bltclass)
  • Documentation on exports (bltclass)
• Error Handler for Chartlib
  • Usage and interface (chartlib_errhandle)
  • Documentation on exports (chartlib_errhandle)
  • Documentation on internals (chartlib_errhandle)
• Color and Pattern Library
  • Usage and interface (color_pattern)
  • Documentation on exports (color_pattern)
• Barchart widgets - 1
  • Usage and interface (genbar1)
  • Documentation on exports (genbar1)
  • Documentation on internals (genbar1)
• Barchart widgets - 2
  • Usage and interface (genbar2)
  • Documentation on exports (genbar2)
• Depict barchart widgets - 3
  • Usage and interface (genbar3)
  • Documentation on exports (genbar3)
  • Documentation on internals (genbar3)
• Depict barchart widgets - 4
  • Usage and interface (genbar4)
  • Documentation on exports (genbar4)
  • Documentation on internals (genbar4)
• Depic line graph
  • Usage and interface (gengraph1)
  • Documentation on exports (gengraph1)
• Line graph widgets
  • Usage and interface (gengraph2)
  • Documentation on exports (gengraph2)
• Multi barchart widgets
  • Usage and interface (genmultibar)
  • Documentation on exports (genmultibar)
  • Documentation on internals (genmultibar)
• table_widget1 (library)
  • Usage and interface (table_widget1)
  • Documentation on exports (table_widget1)
  • Documentation on internals (table_widget1)
• table_widget2 (library)
  • Usage and interface (table_widget2)
  • Documentation on exports (table_widget2)
• table_widget3 (library)
  • Usage and interface (table_widget3)
  • Documentation on exports (table_widget3)
• table_widget4 (library)
  • Usage and interface (table_widget4)
  • Documentation on exports (table_widget4)
• test_format (library)
  • Usage and interface (test_format)
  • Documentation on exports (test_format)
• ProVRML - a Prolog interface for VRML
  • Usage and interface (provrml)
  • Documentation on exports (provrml)
  • Documentation on internals (provrml)
• boundary (library)
  • Usage and interface (boundary)
  • Documentation on exports (boundary)
• dictionary (library)
  • Usage and interface (dictionary)
  • Documentation on exports (dictionary)
• dictionary_tree (library)
  • Usage and interface (dictionary_tree)
  • Documentation on exports (dictionary_tree)
• error (library)
  • Usage and interface (error)
  • Documentation on exports (error)
• field_type (library)
  • Usage and interface (field_type)
  • Documentation on exports (field_type)
• field_value (library)
  • Usage and interface (field_value)
  • Documentation on exports (field_value)
• field_value_check (library)
  • Usage and interface (field_value_check)
  • Documentation on exports (field_value_check)
• generator (library)
  • Usage and interface (generator)
  • Documentation on exports (generator)
• generator_util (library)
  • Usage and interface (generator_util)
  • Documentation on exports (generator_util)
• internal_types (library)
  • Usage and interface (internal_types)
  • Documentation on exports (internal_types)
• io (library)
  • Usage and interface (io)
  • Documentation on exports (io)
• lookup (library)
  • Usage and interface (lookup)
  • Documentation on exports (lookup)
• parser (library)
  • Usage and interface (parser)
  • Documentation on exports (parser)
• parser_util (library)
  • Usage and interface (parser_util)
  • Documentation on exports (parser_util)
• possible (library)
  • Usage and interface (possible)
  • Documentation on exports (possible)
• tokeniser (library)
  • Usage and interface (tokeniser)
  • Documentation on exports (tokeniser)
• Double linked list
  • Usage and interface (ddlist)
  • Documentation on exports (ddlist)
  • Other information (ddlist)
    • Using insert_after
    • More Complex example
• Measuring features from predicates (time cost or memory used...)
  • Usage and interface (time_analyzer)
  • Documentation on exports (time_analyzer)
• Printing graph using gnuplot as auxiliary tool.
  • Usage and interface (gnuplot)
  • Documentation on exports (gnuplot)
• Automatic modules caller tester
  • Usage and interface (modtester)
  • Documentation on exports (modtester)
• Automatic tester
  • Usage and interface (tester)
  • Documentation on exports (tester)
  • Other information (tester)
    • Understanding run_test predicate
    • More complex example
• PART XII - Appendices
• Installing Ciao from the source distribution
  • Un*x installation summary
  • Un*x full installation instructions
  • Checking for correct installation on Un*x
  • Cleaning up the source directory
  • Multiarchitecture support
  • Installation and compilation under Windows
  • Porting to currently unsupported operating systems
  • Troubleshooting (nasty messages and nifty workarounds)
• Installing Ciao from a Win32 binary distribution
  • Win32 binary installation summary
  • Checking for correct installation on Win32
  • Compiling the miscellaneous utilities under Windows
  • Server installation under Windows
  • CGI execution under IIS
  • Uninstallation under Windows
• Beyond installation
  • Architecture-specific notes and limitations
  • Keeping up to date with the Ciao users mailing list
  • Downloading new versions
  • Reporting bugs
• References
• Library/Module Definition Index
• Predicate/Method Definition Index
• Property Definition Index
• Regular Type Definition Index
• Declaration Definition Index
• Concept Definition Index
• Global Index

This document was generated on 28 January 2007 using texi2html 1.56k + clip patches and lpdoc.