home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / language / prolog68 / readme < prev    next >
Encoding:
Text File  |  1993-10-23  |  19.3 KB  |  620 lines
  1. -------------------------------------------------------------------------------
  2.  
  3.  
  4.        /¯¯¯¯¯)          /¯)                /¯¯¯¯¯) /¯¯¯¯¯)
  5.       / /¯) /         / /               / ____/ / /¯) /
  6.      / (_/ /        / /              / /      / (_/ /
  7.     / ____/ /¯¯¯¯) /¯¯¯¯¯) / / /¯¯¯¯¯) /¯¯¯¯¯) /¯¯¯) /  ¯¯¯) /     /
  8.        / /     / /¯¯¯ / /¯) / / / / /¯) / / /¯) / (___/ / /¯) / / /¯) /
  9.       / /     / /    / (_/ / / / / (_/ / / (_/ /       / (_/ / / (_/ /
  10.      (_/     (_/    (_____/ (_/ (_____/ (___  /       (_____/ (_____/
  11.                        / /
  12.                       /¯¯¯¯ /
  13.                      (_____/
  14.  
  15.                  (pre-release version)
  16.  
  17.  
  18.  
  19.          © Copyright 1989,1990,1991,1992 Jens Kilian
  20.                  All rights reserved
  21.  
  22.  
  23. -------    Shipping list ---------------------------------------------------------
  24.  
  25.     DEMO            Demonstrations
  26.         QUEENS.PL
  27.         RANDOM.PL
  28.         WORM.PL
  29.  
  30.     CODES            Pre-compiled versions of the compiler
  31.         BUILTINS.WAM    and run-time system
  32.         DEBUGGER.WAM
  33.         DRIVER.WAM
  34.         DSTRUCT.WAM
  35.         ENCODER.WAM
  36.         INDEXER.WAM
  37.         LIBRARY.WAM
  38.         SHELL.WAM
  39.         TMPALLOC.WAM
  40.         XLATOR.WAM
  41.  
  42.     DOC
  43.         LIESMICH        This document (German version)
  44.         README        This document (English version)
  45.         PROLOG68.DVI    Preliminary documentation (in German)
  46.  
  47.     INIT.WAM        Bootstrap information
  48.     PROLOG.LST
  49.  
  50.     WAM.TOS         Main program (emulator, primitive operations)
  51.  
  52. -------    Overview --------------------------------------------------------------
  53.  
  54.   This floppy contains pre-release version 0.9.126 of Prolog-68, a new Prolog
  55. system for Atari's ST series. When the program is finished, it will be made
  56. publicly available as free software (NOT public domain software !) together
  57. with the source code.
  58.  
  59.   The present version may be freely distributed, but NOT modified or used
  60. commercially. 'Commercial use' includes distribution, if a fee is charged
  61. and if the rate for a single disk exceeds the sum of the disk's price and
  62. the postal (or other carrier's) charge by more than DM 2,- (at a reasonable
  63. rate of exchange, if applicable).
  64.  
  65. Again:    This is a pre-release version, meaning that I don't even guarantee
  66.     the correctness of this document !
  67.  
  68.   Prolog-68 is based on the `Warren Abstract Machine'; it contains a compiler
  69. (written in Prolog) which translates program clauses into intermediate code.
  70. This intermediate code is stored (as direct threaded code) and executed by a
  71. simulator. The system attains a speed of 12 kLIPS on the 'nrev' Benchmark,
  72. which is quite acceptable on an Atari ST. The program was tested on an Atari ST
  73. with 4MB of main storage, but should be able to run on all STs with 68000 (!)
  74. processors. As usual, `more is better' regarding main memory; at least 250 KB
  75. are required just to load the system. The files in the 'CODES' folder contain
  76. a pre-translated version of the compiler and user interface. DON'T MODIFY
  77. THESE FILES UNDER ANY CIRCUMSTANCES !
  78.  
  79.   Neither the compiler nor the run-time environment are finished, so users will
  80. have to do without database operations ('assert', 'retract') and some
  81. other features. Also, predicate names of the compiler are publicly visible
  82. (to programs at least), so you can produce wonderful crashes just by using
  83. 'consult'.
  84.  
  85. -------    Known bugs ------------------------------------------------------------
  86.  
  87.   The present version 0.9.126 contains the following bugs (to be fixed in
  88. later versions):
  89.  
  90.     * erase/1 doesn't free the memory of the terms it erases
  91.  
  92. -------    Predefined predicates -------------------------------------------------
  93.  
  94.   I'm trying to create a complete Prolog system which is compatible to standard
  95. dialects like Prolog-10 and Quintus Prolog. Most predefined predicates have
  96. already been implemented, but here they can only be described in short:
  97.  
  98.     - Control:
  99.  
  100.     ','/2
  101.     ';'/2
  102.     '!'/2            (see below)
  103.     '->'/2            (see below)
  104.     call/1
  105.     '\+'/1            (as 'not'/1 in TOY Prolog)
  106.     true/0
  107.     otherwise/0        (= true/0)
  108.     fail/0
  109.     false/0         (= fail/0)
  110.     repeat/0
  111.     if_exception/3        (error handling, see below)
  112.     signal_exception/1
  113.     signal_error/3
  114.     propagate_error/4
  115.     trap/2
  116.     set_error_handler/3
  117.     once/1            (as in TOY Prolog)
  118.  
  119.       if_exception/3 and signal_exception/1 are similar to tag/1 and
  120.     tagexit/1 in TOY Prolog. Using
  121.  
  122.         if_exception(?ErrorTerm, +Goal, +Recovery)
  123.  
  124.     one can call 'Goal'. If during the execution of 'Goal' there occurs
  125.     a call to
  126.  
  127.         signal_exception(?Term),
  128.  
  129.     'Term' is unified with 'ErrorTerm', 'Recovery' is called and the
  130.     original call to if_exception/3 is exited. All variable bindings made
  131.     in 'Goal' are undone.
  132.  
  133.       The predicates
  134.  
  135.         signal_error(+Type, +Arg, +Goal)
  136.         propagate_error(+Type, +Arg, +Goal, +Context)
  137.         trap(+Goal, +Handler)
  138.         set_error_handler(+Type, -OldHandler, +NewHandler)
  139.  
  140.     are used for handling errors. The details may yet change, therefore
  141.     these predicates shouldn't be used at the moment.
  142.     
  143.       The 'cut' works inside metacalls, but its scope is limited. In
  144.     'call(X)', a 'cut' inside 'X' will have effect only inside the
  145.     parentheses. A rule of thumb: `letters block the cut'.
  146.  
  147.       '->'/2 resembles a 'cut' which is restricted to part of a clause.
  148.     The call  (P -> Q; R)  can be used as an IF/THEN/ELSE statement:
  149.     If P can be satisfied, Q is called, otherwise R is called.
  150.     (P -> Q) on its own is identical to (P -> Q; fail).
  151.  
  152.     - Input/Output:
  153.  
  154.       This part of the program is almost complete.
  155.  
  156.     read/1            Input and output of terms
  157.     write/1
  158.     writeq/1
  159.     display/1        (Always outputs to 'user' !)
  160.     write_canonical/1   (Output in prefix form, also called displayq/1)
  161.     print/1         (Output via portray/1, if defined by the user)
  162.     portray_clause/1    (Prints clauses in easy-to-read format)
  163.  
  164.     get0/1            Input and output of characters (using ASCII values)
  165.     get/1
  166.     skip/1            *
  167.     put/1            *
  168.     nl/0
  169.     tab/1            * These predicates can take a parameter that is a
  170.                   full arithmetical expression (not just an
  171.                   integer).
  172.  
  173.     is_endfile/1        Specifies end-of-file character
  174.     is_newline/1        Specifies end-of-line character
  175.     is_newpage/1        Specifies end-of-page character
  176.     is_endline/1        Detects end-of-line (must be called with its
  177.                 argument fully instantiated !)
  178.  
  179.     open/3            Management of input/output streams (see below)
  180.     open_null_stream/1
  181.     close/1
  182.     current_stream/3
  183.     nofileerrors/0
  184.     fileerrors/0
  185.     flush_output/1
  186.     set_input/1
  187.     set_output/1
  188.     current_input/1
  189.     current_output/1
  190.     absolute_file_name/2
  191.  
  192.     read/2            Input/Output of terms to arbitrary streams
  193.     write/2
  194.     writeq/2
  195.     display/2
  196.     write_canonical/2   (a.k.a. displayq/2)
  197.     print/2
  198.  
  199.     get0/2            Input/Output of characters to arbitrary streams
  200.     get/2
  201.     skip/2            *
  202.     put/2            *
  203.     nl/1
  204.     tab/2            * (see above)
  205.  
  206.     character_count/2   Inquiry about streams' status
  207.     line_count/2
  208.     line_position/2
  209.     stream_position/3   Inquire and set read/write position
  210.     stream_position/2   Inquire positions of all open files
  211.  
  212.     see/1            Prolog-10 compatible file handling
  213.     seeing/1
  214.     seen/0
  215.     tell/1
  216.     telling/1
  217.     told/0
  218.  
  219.     ttyget0/1        Prolog-10 compatible input/output of characters
  220.     ttyget/1        to the 'user' stream.
  221.     ttyskip/1
  222.     ttyput/1
  223.     ttynl/0
  224.     ttytab/1
  225.  
  226.     biosget0/1        (used in demonstrations only; will disappear
  227.     biosput/1         some of these days ...)
  228.     biosstat/0
  229.  
  230.     op/3            (Define or delete operators)
  231.     current_op/3        (Inquire current operators)
  232.  
  233.     sread/2         (Read a term with its symbol table)
  234.     sread/3         (The same, using an arbitrary input stream)
  235.  
  236.       The stream predicates come from Quintus Prolog. An (input or output)
  237.     stream is a special object that can be created with
  238.  
  239.         open(+FileName, +Mode, -Stream).
  240.  
  241.     `FileName' is the name of a file, `Mode' must be one of the atoms
  242.     'read', 'write', 'append', 'read_binary', 'write_binary' or
  243.     'append_binary'. The stream returned by open/3 can be used with e.g.
  244.  
  245.         write(+Stream, ?Term)
  246.     
  247.     and closed with
  248.  
  249.         close(+Stream).
  250.  
  251.       Besides file streams there are certain predefined streams, accessible
  252.     through the following names:
  253.  
  254.         user        (Quintus compatible)
  255.         user_input
  256.         user_output
  257.         user_error
  258.  
  259.         printer_output  (Extensions for accessing the ST's devices)
  260.         modem_input
  261.         modem_output
  262.         midi_input
  263.         midi_output
  264.         ikbd_output
  265.  
  266.       Use e.g.   write(printer_output, T)  to output T to the printer port.
  267.  
  268.       As of the present version, the 'read' predicates are fully compatible
  269.     to Edinburgh Prolog (in particular, C-Prolog and Quintus Prolog).
  270.  
  271.     - Arithmetic
  272.  
  273.     'is'/2            Evaluate expressions
  274.  
  275.     '=:='/2         Compare expressions
  276.     '=\='/2
  277.     '<'/2
  278.     '=<'/2
  279.     '>'/2
  280.     '>='/2
  281.  
  282.     - Term classification:
  283.  
  284.     var/1            (Standard)
  285.     nonvar/1
  286.     atom/1
  287.     integer/1
  288.     atomic/1
  289.  
  290.     nonatomic/1        (Negation of atomic/1)
  291.     constant/1        (NOT identical to atomic/1)
  292.     nonconstant/1
  293.     composite/1        (Checks if a term is composite)
  294.     simple/1        (Negation of composite/1)
  295.     callable/1        Checks if a term can be called (nonvarint/1 in TOY)
  296.  
  297.     - Structure access:
  298.  
  299.     functor/3
  300.     arg/3
  301.     '=..'/2
  302.  
  303.     name/2            Conversion between constants and strings
  304.     atom_chars/2
  305.     number_chars/2
  306.  
  307.     numbervars/3        Enumerate variables in a term (e.g. for write/1)
  308.  
  309.     - Comparison of arbitrary terms:
  310.  
  311.     '=='/2
  312.     '\=='/2
  313.     '@<'/2
  314.     '@=<'/2
  315.     '@>'/2
  316.     '@>='/2
  317.     compare/3
  318.     sort/2
  319.     msort/2
  320.     keysort/2
  321.  
  322.       When comparing terms with '@<', ..., '@>=', the following total
  323.     ordering relation over the set of all terms is used:
  324.  
  325.     a) Variables @< Numbers @< Atoms @< Composite Terms
  326.  
  327.     b) Variable1 @< Variable2   is uniquely defined, but has no further
  328.                     meaning to the user (... in the Prolog-10
  329.                     library, this feature is used for some
  330.                     REALLY dirty tricks)
  331.  
  332.     c) Number1 @< Number2        iff Number1 < Number2
  333.  
  334.     d) Atom1 @< Atom2        iff Atom1's name is lexicographically less
  335.                     than Atom2's name (as in TOY Prolog)
  336.  
  337.     e) Term1 @< Term2        iff  i) Term1's arity is less than Term2's
  338.                         arity
  339.  
  340.                     ii) both arities are equal and
  341.                         functor(Term1) @< functor(Term2)
  342.  
  343.                        iii) both arities and both functors are
  344.                         equal and there exists an i
  345.                         such that for all j, 1 ≤ j < i:
  346.  
  347.                        argument(Term1, j) == argument(Term2, j)
  348.  
  349.                          and
  350.  
  351.                        argument(Term1, i) @< argument(Term2, i)
  352.  
  353.     compare/3 acts as if it were defined as
  354.  
  355.         compare('<', X, Y) :- X @< Y.
  356.         compare('=', X, Y) :- X == Y.
  357.         compare('>', X, Y) :- X @> Y.
  358.  
  359.       sort/2, msort/2 and keysort/2 sort lists according to the ordering
  360.     relation explained above. sort/2 discards duplicate elements, msort/2
  361.     doesn't; keysort/2 expects a list of terms having the form
  362.  
  363.         Key - Value
  364.  
  365.     It ignores the 'Values' and uses the 'Keys' to sort the list. keysort/2
  366.     keeps duplicate elements and preserves their original ordering; for
  367.     example,
  368.  
  369.         | ?- keysort([4-a, 1-b, 5-c, 1-d, 4-e, 0-f], Sorted).
  370.         Sorted = [0-f, 1-b, 1-d, 4-a, 4-e, 5-c]
  371.  
  372.     These predicates are at best linear, in the worst case they are
  373.     O(NlogN) (so we can safely conclude that they DON'T use 'quicksort').
  374.  
  375.     - Program status:
  376.  
  377.     listing/0        List all predicates
  378.     listing/1        List some predicates
  379.  
  380.     current_atom/1        (Inquire known atoms etc.)
  381.     current_predicate/2
  382.  
  383.     halt/0            (Halt the program)
  384.     halt/1            (ditto, specifying the exit code)
  385.     break            (Start a new run level)
  386.     abort            (Abort and return to Prolog top level)
  387.  
  388.     - Debugger:
  389.  
  390.       Yup, at last there's a debugger, even if it works a bit different
  391.     from the usual kind (sigh).
  392.  
  393.     trace/1            (start debugging)
  394.     debug/1
  395.  
  396.     nodebug/0        (see below)
  397.     trace/0
  398.     debug/0
  399.  
  400.     spy/1            (set & delete spy (=break) points)
  401.     nospy/1
  402.     nospyall/0
  403.     leash/1            (tells the debugger where to stop)
  404.     harness/1        (as leash/1, but controls spy points)
  405.     debugging/1
  406.     unknown/2        (trap calls to undefined predicates)
  407.  
  408.       The debugger can be started via  trace(+Goal)  in single-step
  409.     (creep) mode, or via  debug(+Goal)  in run (leap) mode. It will
  410.     start executing 'Goal'; trace/0, debug/0 and nodebug/0 only work
  411.     if the debugger is active. The debugger is NOT started automatically
  412.     when an error occurs.
  413.  
  414.       unknown(-OldAction, +NewAction) is an abbreviation for
  415.     prolog_flag(unknown, -OldAction, +NewAction) (which see).
  416.  
  417.       For more detailed informations concerning debugging, consult any
  418.     decent Prolog textbook.
  419.  
  420.     - Database operations:
  421.  
  422.     There are no database operations in this version ! (but see below)
  423.  
  424.     - Database references:
  425.  
  426.       Database references allow fast access to stored clauses, terms etc.
  427.     Though there are no database operations as yet, the internal database
  428.     has already been implemented, including one predicate belonging here:
  429.  
  430.     erase/1         (Erases a database reference)
  431.  
  432.     - Internal database:
  433.  
  434.       The internal database exists for reasons of efficiency. It can only
  435.     be used for storing terms, not for storing clauses.
  436.       This part of the program is largely complete.
  437.  
  438.     recorda/3
  439.     recordz/3
  440.     recorded/3
  441.     current_key/2
  442.  
  443.       Using  recorda(+Key, +Term, -Ref)  resp.  recordz(+Key, +Term, -Ref),
  444.     the `Term' is stored in the internal database under `Key'. A database
  445.     reference to the stored term is returned in `Ref'; it can be used to
  446.     remove the term via erase/1.  recorded(+Key, ?Term, ?Ref)  retrieves a
  447.     stored term,  current_key(?KeyName, ?KeyTerm)  inquires all known keys.
  448.  
  449.     - Set operations:
  450.  
  451.       setof/3 and bagof/3 have not been implemented yet. There is a
  452.     restricted version of bagof/3 identical to TOY Prolog's bagof/3
  453.     (but not compatible to the standard version).
  454.  
  455.     findall/3        Substitute for bagof/3
  456.  
  457.       The difference between standard bagof/3 and TOY Prolog's idea of this
  458.     is the treatment of free variables in the goal passed as parameter. The
  459.     standard version collects all solutions that yield the same values for
  460.     these variables, while findall/3 (and bagof/3 in TOY Prolog) regard all
  461.     of them as existentially quantified.
  462.  
  463.     - Grammar rules:
  464.  
  465.     expand_term/2        Called before a clause is compiled; does
  466.                 transformation of grammar rules. The user can
  467.                 define the predicate term_expansion/2 to make
  468.                 additional transformations.
  469.  
  470.     phrase/3        Application of a grammar rule
  471.     phrase/2
  472.  
  473.       Instead of a single non-terminal symbol (as in TOY Prolog),
  474.     phrase/[2,3] can handle an entire phrase (right-hand side of a grammar
  475.     rule). phrase/2 is defined as
  476.  
  477.         phrase(Phrase, List) :- phrase(Phrase, List, []).
  478.  
  479.     - Miscellaneous:
  480.  
  481.     '='/2            (Unification)
  482.     length/2        (Length of a list)
  483.     member/2        (Element relation for a list)
  484.     memberchk/2        (ditto, deterministic)
  485.     append/3        (List concatenation)
  486.  
  487.     - Special predicates (Quintus compatibility):
  488.  
  489.     prolog_flag/3        (modify global flags)
  490.     prolog_flag/2        (inquire global flags)
  491.     prompt/2        (inquire and set console input prompt)
  492.     statistics/0        (print statistics)
  493.     statistics/2        (inquire statistics)
  494.  
  495.       prolog_flag/2 and prolog_flag/3 access some global flags which are
  496.     used to control several internal feratures. Contrary to other Prolog
  497.     systems, the value of a flag is always an integer. The currently
  498.     existing flags are:
  499.  
  500.     Name               Values (Default)    Purpose
  501.  
  502.     character_escapes    0, 1    (0)    Controls evaluation of escape
  503.                         sequences on input and output
  504.     fileerrors        0, 1    (1)    Controls error handling when
  505.                         accessing nonexistent files
  506.     gc_trace        0, 1, 2    (0)    Controls amount of tracing
  507.                         information printed when the
  508.                         garbage collector is run
  509.                         (0=none, 1=terse, 2=verbose)
  510.     unknown            0, 1    (1)    Controls handling of undefined
  511.                         predicates (0=just fail,
  512.                         1=signal an error)
  513.     error_handling        0, 1, 2    (2)    Controls error handling
  514.                         (0=failure, 1=activation of
  515.                         error handling routine,
  516.                         2=additional error messages)
  517.  
  518.     prolog_flag(+Flag, -OldValue, +NewValue) can be used to change the
  519.     value of the `Flag', prolog_flag(?Flag, ?Value) inquires such a value
  520.     without changing it.
  521.  
  522.       The first parameter to statistics/2 must be one of the following
  523.     keywords:
  524.  
  525.     'runtime'        asks for the running time
  526.  
  527.     'memory'        enquire the sizes of various memory areas
  528.     'core'            (some are duplicates, e.g., heap = program)
  529.     'program'
  530.     'heap'
  531.     'global_stack'
  532.     'local_stack'
  533.     'trail'
  534.  
  535.     'garbage_collection' garbage collection statistics (what else ?)
  536.  
  537.     The second parameter is unified with a list of integers indicating the
  538.     results of the enquiry.
  539.  
  540.     - System dependent predicates:
  541.  
  542.     garbage_collect/0   Forces garbage collection. Not needed in normal
  543.                 programs, present for compatibility reasons.
  544.  
  545.     system/1        Pass an atom to a shell (works e.g. with Guläm)
  546.  
  547.       The name of this predicate will change in one of the next releases
  548.     for compatibility reasons.
  549.  
  550.  
  551.   I know that this list is no sufficient documentation, but unfortunately I
  552. can't supply more at this time. At least I'm working on a manual written with
  553. LaTeX (anybody who doesn't have TeX should start looking, if only for an
  554. opportunity to print DVI files. The nearest university would be a good place
  555. to start. If they don't run TeX, they don't have a computer). I've packaged
  556. a preliminary version with this release.
  557.   Whenever it comes out, the documentation will be in GERMAN. Sorry again.
  558.  
  559. -------    Demonstrations --------------------------------------------------------
  560.  
  561. The 'DEMO' folder contains two example programs: a version of the n-Queens
  562. problem ('QUEENS.PL') and a little game ('WORM.PL', 'RANDOM.PL').
  563.  
  564. Use e.g. the following to read & start the programs:
  565.  
  566.         | ?- ['demo\queens'].
  567.         | ?- queens(N).     solve the 'N queens' problem (N >= 4)
  568.     or        | ?- test.        solve the '5 queens' problem
  569.  
  570.  
  571.         | ?- ['demo\worm', 'demo\random'].
  572.         | ?- worm.    (use keys 2, 4, 6, 8 on the
  573.                  numeric keypad)
  574.  
  575. -------    Miscellany ------------------------------------------------------------
  576.  
  577.     ... My address has changed:
  578.  
  579.          Jens Kilian
  580.          Holunderstraße 19
  581.     D-W-7033 Herrenberg-Gültstein
  582.          Germany
  583.  
  584.     ... e-mail to:
  585.  
  586.     Internet:    jensk@hpbbrn.bbn.hp.com
  587.     MausNet:    Jens Kilian @ BB
  588.  
  589.     ... There are unreasonable people out there, so I must specifically
  590.     disclaim any warranty even for this pre-release version:
  591.  
  592.                   NO WARRANTY
  593.  
  594. - BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
  595. FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
  596. OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
  597. PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
  598. OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  599. MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
  600. TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
  601. PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
  602. REPAIR OR CORRECTION.
  603.  
  604. - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  605. WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
  606. REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
  607. INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
  608. OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
  609. TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
  610. YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
  611. PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
  612. POSSIBILITY OF SUCH DAMAGES.
  613.  
  614. -------------------------------------------------------------------------------
  615.  
  616.     Have fun,
  617.  
  618.         Jens Kilian
  619.  
  620.