functions in std.i - g

             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 2508  

             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 1728  

             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 1712  

             get_env(environment_variable_name)  
 
     returns the environment variable (a string) associated with  
     ENVIRONMENT_VARIABLE_NAME (calls ANSI getenv routine).  
builtin function, documented at i0/std.i   line 1721  

 get_home  
 
builtin function, documented at i0/std.i   line 1712  

             get_member(f_or_s, member_name)  
 
     returns F_OR_S member MEMBER_NAME, like F_OR_S.MEMBER_NAME syntax,  
     but MEMBER_NAME can be a computed string.  The F_OR_S may be a  
     binary file or a structure instance.  
builtin function, documented at i0/std.i   line 1872  

 get_ncycs  
 
builtin function, documented at i0/std.i   line 2533  

             prims = get_primitives(file)  
 
     Return the primitive data types for FILE as an array of 32  
     integers.  The format is described under set_primitives.  
builtin function, documented at i0/std.i   line 2200  

             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 2533  

             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 2481  

             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.  
builtin function, documented at i0/std.i   line 988