section g of routines in std.i

functions in std.i - g

get_addrs


    addr_lists= get_addrs(file)  


returns the byte addresses of the non-record and record variables  
in the binary file FILE, and lists of the record addresses, file  
indices, and filenames for file families with history records.  
     *addr_lists(1)   absolute addresses of non-record variables  
     *addr_lists(2)   relative addresses of record variables  
                      (add record address to get absolute address)  
        The order of these two address lists matches the  
        corresponding lists of names returned by get_vars.  
     *addr_lists(3)   absolute addresses of records  
     *addr_lists(4)   list of file indices corresponding to  
                      addr_lists(3); indices are into addr_lists(5)  
     *addr_lists(5)   list of filenames in the family  
Builtin function, documented at i0/std.i   line 3279

SEE ALSO: openb, updateb, restore, jt, jc, has_records, get_vars

get_argv


    get_argv()  


returns string array containing the argv from the command line.  
The -batch and batch_include.i arguments are removed (not returned).  
Builtin function, documented at i0/std.i   line 2503

SEE ALSO: process_argv, cd, get_cwd, get_home, get_env, batch

get_cwd


    get_cwd()  
 or get_home()  


returns the pathname of the current working directory or of your  
home directory.  
Builtin function, documented at i0/std.i   line 2487

SEE ALSO: set_primitives, __xdr, __i86

get_times


    times= get_times(file)  
    ncycs= get_ncycs(file)  


returns the list of time or ncyc values associated with the records  
if FILE, or nil if there are none.  The time values are not guaranteed  
to be precise (but they should be good to at least 6 digits or so);  
the precise time associated with each record may be stored as a record  
variable.  
Builtin function, documented at i0/std.i   line 3304

SEE ALSO: collect, openb, updateb, restore, jt, jc, edit_times

get_vars


    name_lists= get_vars(file)  


returns the lists of non-record and record variable names in the  
binary FILE.  The return value is an array of two pointers to  
arrays of type string; *name_lists(1) is the array of non-record  
variable names (or nil if there are none), *name_lists(2) is the  
array of record variable names.  
The get_addrs function returns corresponding lists of disk  
addresses; the get_member function can be used in conjunction  
with the dimsof, structof, and typeof functions to determine  
the other properties of a variable.  
Builtin function, documented at i0/std.i   line 3252

SEE ALSO: openb, updateb, restore, jt, jc, has_records, get_addrs, set_vars

grow


    grow, x, xnext1, xnext2, ...  
 or grow(x, xnext1, xnext2, ...)  
 or    _(x, xnext1, xnext2, ...)  


lengthens the array X by appending XNEXT1, XNEXT2, etc. to its  
final dimension.  If X is nil, X is first redefined to the first  
non-nil XNEXT, and the remainder of the XNEXT list is processed  
normally.  Each XNEXT is considered to have the same number of  
dimensions as X, by appending unit-length dimensions if necessary.  
All but this final dimension of each XNEXT must be right-conformable  
(that is, conformable in the sense of the right hand side of an  
assignment statement) with all but the final dimension of X.  
The result has a final dimension which is the sum of the final  
dimension of X and all the final dimensions of the XNEXT.  Nil  
XNEXT are ignored.  The value of the result is obtained by  
concatenating all the XNEXT to X, after any required broadcasts.  
If invoked as a function, grow returns the new value of X; in  
this case, X may be an expression.  X must be a simple variable  
reference for the subroutine form of grow; otherwise there is  
nowhere to return the result.  The subroutine form is slightly  
more efficient than the function form for the common usage:  
     x= grow(x, xnext1, xnext2)           is the same as  
     grow, x, xnext1, xnext2              the preferred form  
The _ function is a synonym for grow, for people who want this  
operator to look like punctuation in their source code, on analogy  
with the array building operator [a, b, c, ...].  
The _cat function is sometimes more appropriate than grow.  
Usage note:  
Never do this:  
  while (more_data) grow, result, datum;  
The time to complete this loop scales as the SQUARE of the number  
of passes!  Instead, do this:  
  for (i=1,result=array(things,n_init) ; more_data ; i++) {  
    if (i>numberof(result)) grow, result, result;  
    result(i) = datum;  
  }  
  result = result(1:i-1);  
The time to complete this loop scales as n*log(n), because the  
grow operation doubles the length of the result each time.  
Builtin function, documented at i0/std.i   line 1036