functions in std.i - d

             data_align, file, alignment  
 
     in binary file FILE, align new variables to begin at a byte address  
     which is a multiple of ALIGNMENT.  (This affects placement of data  
     declared using save and add_variable.  For add_variable, data_align  
     has an effect only if the address is not specified.)  If ALIGNMENT  
     is <=0, new variables will be aligned as they would be if they were  
     data structure members.  The default value is 0.  

builtin function, documented at i0/std.i   line 2498  

 dbauto  
 
builtin function, documented at i0/std.i   line 2844  

 dbcont  
 
builtin function, documented at i0/std.i   line 2844  

 dbdis  
 
builtin function, documented at i0/std.i   line 2844  

             Debug mode.  
 
   Yorick errors fall into two general categories: Syntax errors discovered  
   during parsing, and runtime errors discovered when a Yorick program is  
   actually running.  When a runtime error occurs, Yorick offers the  
   choice of entering "debug mode", which you can do by typing the   
   key immediately after the error occurs.  Typing a non-blank line exits  
   debug mode automatically by default.  In debug mode, the Yorick prompt  
   becomes "dbug>" instead of the usual ">".  When you see this prompt,  
   Yorick has halted "in the middle of" the function in which the error  
   occurred, and you can print, plot, modify, or save the local variables  
   in that function by means of ordinary Yorick commands.  Debug mode is  
   recursive; that is, you can debug an error which occurred during  
   debugging to any number of levels.  
   You can exit from debug mode in several ways:  
      dbexit            -- exit current debug level, discarding all  
                           active functions and their local variables  
      dbexit, 0         -- exit all debug levels  
      dbexit, n         -- exit (at most) N debug levels  
      dbcont            -- continue execution of the current function  
         Continuing is useful if you have managed to repair the  
	 problem which caused the error.  The expression in which the  
	 error occurred will be evaluated a second time, so beware of  
	 side effects.  
      dbret, value      -- continue execution by returning VALUE (which  
                           may be nil or omitted) to the caller of the  
			   function in which the error occurred.  
	 This is useful if the function in which the error occurred is  
	 hopelessly confounded, but you know the value it should return.  
   Yorick does not allow "single stepping" directly, although you can  
   execute the statements in a function by copying them, then tell  
   Yorick to skip those statements you have executed "by hand".  There  
   are two functions for skipping execution:  
      dbskip            -- skip the next logical line (This will be only  
                           a portion of a source line if several statements  
			   are stacked on the source line.)  
      dbskip, n         -- skip next N (positive or negative) logical lines  
      dbup              -- discard the current function, so that you are  
                           debugging its caller -- there is no way to go  
			   back "down", so be careful  
   There are two functions which print information (like other print  
   functions, if called as functions instead of subroutines, their  
   result is returned as a string array with one line per string):  
      dbinfo            -- returns current function and source line  
      dbdis             -- returns disassembled virtual machine code  
                           for the next line (use the disassemble function  
			   to get the entire function)  
	 This allows you to see exactly where in a line the error occurred.  
   Finally,  
      dbauto            -- toggles whether debug mode will be entered  
                           automatically when a runtime error occurs  
      dbauto, 1         -- enter debug mode automatically after an error  
      dbauto, 0         -- type  after error to enter debug mode  

builtin function, documented at i0/std.i   line 2844  

 dbinfo  
 
builtin function, documented at i0/std.i   line 2844  

 dbret  
 
builtin function, documented at i0/std.i   line 2844  

 dbskip  
 
builtin function, documented at i0/std.i   line 2844  

 dbup  
 
builtin function, documented at i0/std.i   line 2844  

             dec_primitives, file  
 
     sets FILE primitive data types to be native to DEC (MIPS) workstations.  

interpreted function, defined at i0/std.i   line 1979  

             digitize(x, bins)  
 
     returns an array of longs with dimsof(X), and values i such that  
     BINS(i-1) <= X < BINS(i) if BINS is monotonically increasing, or  
     BINS(i-1) > X >= BINS(i) if BINS is monotonically decreasing.  
     Beyond the bounds of BINS, returns either i=1 or i=numberof(BINS)+1  
     as appropriate.  

builtin function, documented at i0/std.i   line 933  

             dimsof(object)  
          or dimsof(object1, object2, ...)  
 
     returns a vector of integers describing the dimensions of OBJECT.  
     The format of the vector is [number of dims, length1, length2, ...].  
     The orgsof function returns the origin of each dimension (normally 1).  
     If more than one argument is given, dimsof returns the dimension  
     list of the result of binary operations between all the objects,  
     or nil if the objects are not conformable.  

builtin function, documented at i0/std.i   line 336  

             disassemble(function)  
          or disassemble, function  
 
     Disassembles the specified function.  If called as a function, the  
     result is returned as a vector of strings; if called as a subroutine,  
     the disassembly is printed at the terminal.  If the function is nil,  
     the current *main* program is disassembled -- you must include the  
     call to disassemble in the main program, of course, NOT on its own  
     line as a separate main program.  

builtin function, documented at i0/std.i   line 253  

             dump_clog, file, clog_name  
 
     dumps a Contents Log of the binary file FILE into the text file  
     CLOG_NAME.  Any previous file named CLOG_NAME is overwritten.  

builtin function, documented at i0/std.i   line 1892