functions in std.i - c


    call, subroutine(arg1, arg2, arg3, arg4, arg5  
    arg6, arg7, arg8);  

allows a SUBROUTINE to be called with a very long argument list  
as an alternative to:  
     subroutine, arg1, arg2, arg3, arg4, arg5,  
       arg6, arg7, arg8;  
Note that the statement  
     subroutine(arg1, arg2, arg3, arg4, arg5,  
                arg6, arg7, arg8);  
will print the return value of subroutine, even if it is nil.  
If invoked as a function, call simply returns its argument.  
Interpreted function, defined at i0/std.i   line 3709  




Catch errors of the specified category.  Category may be -1 to  
catch all errors, or a bitwise or of the following bits:  
   0x01 math errors (SIGFPE, math library)  
   0x02 I/O errors  
   0x04 keyboard interrupts (e.g.- control C interrupt)  
   0x08 other compiled errors (YError)  
   0x10 interpreted errors (error)  
Use catch by placing it in a function before the section of code  
in which you are trying to catch errors.  When catch is called,  
it always returns 0, but it records the virtual machine program  
counter where it was called, and longjumps there if an error is  
detected.  The most recent matching call to catch will catch the  
error.  Returning from the function in which catch was called  
pops that call off the list of catches the interpreter checks.  
To use catch, place the call near the top of a function:  
   if (catch(category)) {  
If an error with the specified category occurs in the "protected"  
code, the program jumps back to the point of the catch and acts  
as if the catch function had returned 1 (remember that when catch  
is actually called it always returns 0).  
In order to lessen the chances of infinite loops, the catch is  
popped off the active list if it is actually used, so that a  
second error will *not* be caught.  Often, this is only desirable  
for the error handling code itself -- if you want to re-execute  
the "protected" code, do this, and take care of the possibility  
of infinite loops in your interpreted code:  
   while (catch(category)) {  
After an error has been caught, the associated error message  
(what would have been printed had it not been caught) is left  
in the variable catch_message.  
If the code protected by the catch contains include or require  
calls, or function references which force autoloads, and the  
fault occurs while yorick is interpreting an included file,  
catch will itself fault, and the error code will not execute.  
If a fault occurs after an include has pushed a file onto  
the include stack for delayed parsing and you catch that fault,  
the include stack will not unwind to its condition at the time  
catch was called.  That is, catch is incapable of protecting  
you completely during operations involving nested levels of  
include files.  
Builtin function, documented at i0/std.i   line 3452  

SEE ALSO: error  


    cd, directory_name  
 or cd(directory_name)  

change current working directory to DIRECTORY_NAME, returning  
the expanded path name (i.e.- with leading environment variables,  
., .., or ~ replaced by the actual pathname).  If called as a  
function, returns nil to indicate failure, otherwise failure  
causes a Yorick error.  
Builtin function, documented at i0/std.i   line 2453  

SEE ALSO: lsdir,   mkdir,   rmdir,   get_cwd,   get_home,   get_env,   get_argv  



returns the smallest integer not less than x (no-op on integers).  
Builtin function, documented at i0/std.i   line 709  

SEE ALSO: floor  


    close, f  

closes the I/O stream F (returned earlier by the open function).  
If F is a simple variable reference (as opposed to an expression),  
the close function will set F to nil.  If F is the only reference  
to the I/O stream, then "close, f" is equivalent to "f= []".  
Otherwise, "close, f" will close the file (so that subsequent  
I/O operations will fail) and print a warning message about the  
outstanding ("stale") references.  
Builtin function, documented at i0/std.i   line 1973  

SEE ALSO: open,   read,   write,   rdline,   bookmark,   backup,   save,   restore,   rename,  



    close102  is a keyword for createb or updateb,  
    open102   is a keyword for openb or updateb  
    close102_default   is a global variable (initially 0)  
    ***Do not use close102_default -- use at_pdb_close  
    -- this is for backward compatibility only***  
    close102=1  means to close the PDB file "Major-Order:102"  
    close102=0  means close it "Major-Order:101"  
    if not specified, uses 1 if close102_default non-zero,  
    otherwise the value specified in at_pdb_close  
    open102=1   means to ignore what the PDB file says internally,  
    and open it as if it were "Major-Order:102"  
    open102=0   (the default) means to assume the PDB file is  
    correctly writen  
    open102=2   means to assume that the file is incorrectly  
    written, whichever way it is marked  
    open102=3   means to ignore what the PDB file says internally,  
    and open it as if it were "Major-Order:101"  

The PDB file format comes in two styles, "Major-Order:101", and  
"Major-Order:102".  Yorick interprets these correctly by default,  
but other codes may ignore them, or write them incorrectly.  
Unlike Yorick, not all codes are able to correctly read both  
styles.  If you are writing a file which needs to be read by  
a "102 style" code, create it with the close102=1 keyword.  
If you notice that a file you though was a history file isn't, or  
that the dimensions of multi-dimensional variables are transposed  
from the order you expected, the code which wrote the file probably  
blew it.  Try openb("filename", open102=2).  The choices 1 and 3  
are for cases in which you know the writing code was supposed to  
write the file one way or the other, and you don't want to be  
The open102 and close102 keywords, if present, override the  
defaults in the variables at_pdb_open and at_pdb_close.  
Keyword,  defined at i0/std.i   line 2694  

SEE ALSO: at_pdb_open,   at_pdb_close  



Keyword,  defined at i0/std.i   line 2694  

SEE close102  


    result= collect(f, name_string)  

scans through all records of the history file F accumulating the  
variable NAME_STRING into a single array with one additional  
index varying from 1 to the number of records.  
NAME_STRING can be either a simple variable name, or a name  
followed by up to four simple indices which are either nil, an  
integer, or an index range with constant limits.  (Note that  
0 or negative indices count from the end of a dimension.)  
   collect(f, "xle")        -- collects the variable f.xle  
   collect(f, "tr(2,2:)")   -- collects,2:)  
   collect(f, "akap(2,-1:0,)") -- collects f.akap(2,-1:0,)  
                (i.e.- akap in the last two values of its  
                       second index)  
Keyword,  defined at i0/std.i   line 2620  

SEE ALSO: get_times  



returns the complex conjugate of its argument.  
Builtin function, documented at i0/std.i   line 737  



    copyright, (no) warranty  

Copyright (c) 1996.  The Regents of the University of California.  
              All rights reserved.  
Yorick is provided "as is" without any warranty, either expressed or  
implied.  For a complete statement, type:  
at the Yorick prompt.  
Keyword,  defined at i0/std.i   line 72  

SEE ALSO: legal  



Builtin function, documented at i0/std.i   line 565  

SEE sin  



Builtin function, documented at i0/std.i   line 604  

SEE sinh  


    cray_primitives, file  

sets FILE primitive data types to be native to Cray 1, XMP, and YMP.  
Interpreted function, defined at i0/std.i   line 2905  



    f= create(filename)  

is a synonym for       f= open(filename, "w")  
Creates a new text file FILENAME, destroying any existing file of  
that name.  Use the write function to write into the file F.  
Interpreted function, defined at i0/std.i   line 1964  

SEE ALSO: write,   close,   open  


    file= createb(filename)  
 or file= createb(filename, primitives)  

creates FILENAME as a PDB file in "w+b" mode, destroying any  
existing file by that name.  If the PRIMITIVES argument is  
supplied, it must be the name of a procedure that sets the  
primitive data types for the file.  The default is to create  
a file with the native primitive types of the machine on which  
Yorick is running.  The following PRIMITIVES functions are  
   sun_primitives    -- appropriate for Sun, HP, IBM, and  
                        most other workstations  
   sun3_primitives   -- appropriate for old Sun-2 or Sun-3  
   dec_primitives    -- appropriate for DEC (MIPS) workstations, Windows  
   alpha_primitives  -- appropriate for DEC alpha workstations  
   sgi64_primitives  -- appropriate for 64 bit SGI workstations  
   cray_primitives   -- appropriate for Cray 1, XMP, and YMP  
   mac_primitives    -- appropriate for MacIntosh  
   macl_primitives   -- appropriate for MacIntosh, 12-byte double  
   i86_primitives    -- appropriate for Linux i86 machines  
   pc_primitives     -- appropriate for IBM PC  
   vax_primitives    -- appropriate for VAXen only (H doubles)  
   vaxg_primitives   -- appropriate for VAXen only (G doubles)  
   xdr_primitives    -- appropriate for XDR files  
Interpreted function, defined at i0/std.i   line 2827  

SEE ALSO: openb,   updateb,   cd,   save,   add_record,   set_filesize,   set_blocksize,  
close102,   close102_default,   at_pdb_open,   at_pdb_close  




Interpreted function, defined at i0/std.i   line 614  

SEE sech