Home Manual Packages Global Index Keywords Quick Reference | # functions in std.i - d
data_align |
                 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
SEE ALSO: | save, add_variable
dbauto |
     dbauto

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

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

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dbexit |
                 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 |
     dbinfo

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

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

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

    builtin function, documented at i0/std.i   line 2844
SEE | dbexit
dec_primitives |
                 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 |
                 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
SEE ALSO: | histogram, interp, integ, sort, where, where2
dimsof |
                 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
SEE ALSO: | typeof, structof, numberof, sizeof, orgsof
disassemble |
                 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 |
                 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
SEE ALSO: | openb