NEWS.TXT    /* REFAL-5 */

VERSION-PZ-New 20.09.2000
*****************************************************************************
  -- A number of errors were corrected.

  -- Automatic addition a built-in function can be done.
     New built-in function is created by CGRC4 ( by Alexandr Konyshev ).
     CGRC4 is a compiler of Refal-graph ( a result of the Scp4 ) to C-language.

  -- A new switch to run the Refal-5 tracer ( reftr ) is present:
            ---  -f_file_name_ ( or -f _file_name_ ) 
                 when this switch is ON, then Refal-5 tracer doubles all
                 stdin output to the _file_name_  file.

  -- Two standart function were created ( REFLIB.REF ):
            --- <PairArg s.number> 
                 pairs '(' and ')' into structure brackets from <Arg s.number>
            --- <InputArg s.number>
                 inputs Refal expressions, program style code from <Arg s.number>

VERSION-PZ-New 28.08.2000
*****************************************************************************
  -- A number of errors were corrected.

  -- THIS VERSION IS NOT SUPPORTED UNDER MS-DOS.

  -- SYNTAX OF REFAL-5 WAS CHANGED. So you have to CORRECT your Refal-5 
     sources to use the new version of Refal-5.

     The canges in brief informal description:
             --- semantics of the "-double quotes was changes:
                   A compound symbol is a sequence of arbitrary characters 
                   enclosed in double quotes, e.g. "a+B-c". As with strings, 
                   an escape character may enter a compound symbol only as its 
                   escape sequence. Unlike a single-quoted  string, a compound 
                   symbol is handled as a whole: exactly one symbol.
                   "" is a compound symbol with the empty name.

                   An identifier is a sequence of characters which begins with 
                   a letter and  may include letters, digits, and characters dash  - ,
                   and underscore _  . An identifier may be enclosed in double quotes,
                   then it can be seen as a special case of a compound symbol. 
                   This operation does not alter it: "abc" is the same as abc. 
                   As in a compound symbol, the case of the letters in an identifier 
                   is significant: abc is not the same as Abc. 

                   A function name is an identifier.
  
                   Characters inside names of compound symbols are case-sensitive.

             --- semantics of the '-quotes was corrected:

                   '' is an empty sequence of characters, id est an empty expression.

                  A number of characters have to be escaped (with '\') inside quotes
                  as well as inside double quotes. 
                  The characters are ' , " , \ , n (NEW LINE), r (CARRIAGE RETURN ) ,
                  t (HORIZONTAL TAB), 
                  xHH ( character-byte whose code is HH, where each H is an arbitrary
                        hexadecimal digit )

             --- A variable is a type indicator followed by a dot, followed by an index.

             --- Built-in function Type was modifies:

                  <Type e.Expr> :: s.Type s.Subtype e.Expr 
                     where e.Expr is unchanged and s.Type and s.Subtype 
                     depend on the type of the first element of e.Expr . 

                     s.Type  s.subtype e.Expr starts with 
                     'L'  s.subtype Latin letter 
                          'Lu'   capital Latin letter
                          'Ll'   lower Latin letter 
                     'D'   0   decimal digit  
                     'W'  s.subtype   word ( compound symbol ) 
                          'Wi'  identifier 
                          'Wq'  other word 
                     'N'    0  macrodigit 
                     'P'   s.subtype    printable character
                          'Pu'      character belongs to upper case.
                          'Pl'      character belongs to lower case.
                     'O'   s.subtype   any other symbol 
                          'Ou'      character belongs to upper case.
                          'Ol'      character belongs to lower case.
                     'B'   0 left parenthesis 
                     '*'   0  e.Expr  is empty 

              --- There are other changes.
 
  -- New built-in functions were created: 
     TimeElapsed, XMLParse (just Windows NT/98/95), DeSysfun

     <TimeElapsed e.init> :: e.char-digits '.' e.char-digits
      takes empty expression or macrodigit zero. It returns  elapsead system time. 
      The time is elapsed time from a last call to the same function with zero as 
      its argument. If there was no such call then the time is elapsed time from 
      start of loading of RSL-modules. The time is given in seconds.
      If the argument is something else, then "Recognition impossible" occurs. 
 
     <XMLParse e.file_name> :: e.expression
	takes characters (e.file_name) as a file name to be parsed. 
        Content of the file is consedered as a XML-document and parsed 
        in e.expression. At present this function just Windows NT/98/95.

     <DeSysfun e.file_name (s.number e.expression)> :: e.empty /* nothing */
	takes characters (e.file_name) as a file name where the e.expression
        should be deparsed. s.number is a maximal allowed length of lines 
        in the file. The function is inverse to Sysfun
        The next predicate is successful
            <DeSysfun e.file-name (s.number e.data)>: e.1, 
            <Sysfun e.file-name>: e.new-data, e.data : e.new-data

  -- Internal tracer's print was changes: 
        expression are encoded in the same fashion as in Refal-5 program.
  
VERSION-PZ 12.04.2000
*****************************************************************************
  -- A number of errors were corrected.

  -- FORMAT OF THE RSL-FILES WAS CHANGED AGAIN! So you have to RECOMPILE 
     your Refal-5 sources to use the new version of Refal-5.
  
  -- "Simultaneous" compilation a number of modules is possible:
     refc [<file_name1>[.ref] ... <file_nameN>[.ref]]
     The files are compiled step by step while a module with a syntax error will
     not found out. In the last case the process of compilation gives 1 as 
     a return cod otherwise the return cod is 0.


VERSION-PZ 31.01.2000
*****************************************************************************
  -- A number of errors were corrected.

  -- FORMAT OF THE RSL-FILES WAS CHANGED AGAIN! So you have to RECOMPILE 
     your Refal-5 sources to use the new version of Refal-5.

  -- A limit on lengths of variable's names was removed.

  -- A limit on lengths of function's names was removed.

  -- A limit on lengths of identifiers was removed.

  -- A number of new switches to run the Refal-5 interpreter are present:
        -cnnn (or --code_limit=nnn) 
                : rsl-module's size is limited with nnn Kb. By default 64Kb.
        -Vnn  (or --var_stack=nn  ) 
                : size of the element's table is limited 
                  with nn*(a BASE_SIZE_TABLE_OF_ELEMENT), 
                  We keep values of Refal-variables in the table.(e,s,t-variabbles)
                  (As well as other information for pattern matching).
                  We recommend the range of the counter from 1 to 10.
        -Cnn (or --call_stack=nn) 
                : size of stack of function call from left sides of Refal sentences is
                  is limited with nn*(a BASE_SIZE_STACK). 
                  We recommend the range of the counter from 1 to 10.
 

  -- New built-in functions were created: 
     ExistFile, GetCurrentDirectory, RemoveFile

     <ExistFile e.name> :: s.Boolean
	the characters (e.name) is a file name. This function checks wether  
	exist the file. Return a boolean value ("True"/"False") as 
	a refal-symbol.

     <GetCurrentDirectory> :: e.characters
	This function is called without arguments. It return a name of the current 
	directory, where the Refal-5 interpreter is running.

     <RemoveFile e.file_name> :: s.Boolean (e.Errors)
	takes characters (e.file_name), as a file name to be deleted. Return
	a boolean value s.Boolean ("True" or "False") as a refal-symbol and 
	a term - (e.Errors) . If the function cannot delete the file 
	(s.Boolean = False), then the value of e.Errors is a description of an error
        which is happend. Otherwise e.Errors is empty. The description is a sequence
        of characters.


VERSION-PZ 24.10.1999
*****************************************************************************
  -- A number of errors were corrected. 

  -- FORMAT OF THE RSL-FILES WAS CHANGED ! So you have to RECOMPILE 
     your Refal-5 sources to use the new version of Refal-5.

  -- The limit to lengths of names of Refal-5 modules was removed.
     At present, the length is restrected just a current operating system.

  -- New built-in functions were created: System, Exit, GetEnv.

     <System e.characters>
       takes characters and tries to interpret them as a shell's command of
     a current operating system. The string must not exceed 255 characters.
     If the value is a negative integer, then the function returns the value 
     as two terms: '-' and a macrodigit, otherwise it returns a macrodigit.
       If the argument is not a sequence of chracters, then "Recognition
     impossible" occures. 

    <Exit e.return-code>
      takes a macrodigit or two terms ( '-' s.macrodigit ) and interrupts
    a current Refal-process. The process returns the argument to 
    the current operating system as a return-code.   
      If the argument is something else, then "Recognition impossible" occures. 

    <GetEnv e.characters>
       takes characters and interprets it as an environment variable of
    the current operating system. The string must not exceed 120 characters.
    If the variable is undefined, then the function returns the empty 
    expression, otherwise it returns a value of the variable as an sequence 
    of chracters.  
       If the argument is not a sequence of chracters, then "Recognition
    impossible" occures. 

 -- REF5RSL-enviroment variable of the current operating system can be
    used. A value of the variable is interpreted as a sequence of paths
    to RSL-files. If the Refal-5 interpreter cannot find out a file.rsl 
    inside a current directory ( to load the file ), then the interpreter 
    looks for a first directory from the sequence where there exist a file
    with the same name and loads it. The paths in the sequence have to be
    devided with semicolons.

 -- The syntax of the Refal-5 loader was extended. Now a user can load
    RSL-files using a left distributive rule: catenation is used as 
    multiplication and each factor-path is added the subdirectory character 
    on the end.
    An example for UNIX: 

    refgo f1+path1(f2+path2(f4+path3(f6+f7)+f8))+path4(f9+f10)
       is equal to
    refgo f1+path1/f2+path1/path2/f4+path1/path2/path3/f6+path1/path2/path3/f7+path1/path2/f8+path4/f9+path4/f10

 -- The Refal-5 executable modules (refc, refgo and reftr) return 
    ( to the current operating system ) either 0 if it has just stoped normally,
    or another integer in the next cases:
          refc:  
                - syntax errors in a file which was compiled;
                - there exist not a file to be compiled;
          refgo, reftr:
                - "Recognition impossible" is happened;
                - a read/write operation is failed; 
                - there exist not a file to be loaded;
                - format of a file to be loaded is incorrect;
                 
**************************** The End *****************************************
