Data descriptor

From Wikipedia, the free encyclopedia
Jump to: navigation, search

In computing, a data descriptor is a structure containing information that describes data.

Data descriptors may be used in compilers,[1] as a software structure at run time in languages like Ada[2] or PL/I, or as a hardware structure in some computers such as Burroughs large systems.

Data descriptors are typically used at run-time to pass argument information to called subroutines. HP OpenVMS[3] and Multics[4] have system-wide language-independent standards for argument descriptors. Descriptors are also used to hold information about data that is only fully known at run-time, such as a dynamically allocated array.

Unlike a dope vector, a data descriptor does not contain address information.

Examples[edit]

The following descriptor is used by IBM Enterprise PL/I to describe a character string:[5]

      +--------+--------+--------+--------+
      |  desc  | string |        | flags  |
      |  type  |  type  | (res)  |        |
      +--------+--------+--------+--------+
      |       maximum string length       |
      |                                   |
      +--------+--------+--------+--------+
 byte         0        1        2        3
  • 'desc type' is 2 to indicate that this is an element descriptor rather than an array or structure descriptor.
  • 'string type' indicates that this is a character or a bit string, with varying or nonvarying length. 2 indicates a nonvarying (fixed-length) character string.
  • '(res)' is a reserved byte not used for character strings.
  • 'flags' indicate the encoding of the string, EBCDIC or ASCII, and the encoding of the length of varying strings.
  • 'maximum string length' is the actual length of the string for nonvarying strings, or the maximum length for varying strings.

Here is the source of an array descriptor from Multics.[6] The definitions include a structure for the base array information and a structure for each dimension. (Multics ran on systems with 36-bit words).

dcl	1 array			        based    aligned,
	2 node_type		        bit(9)   unaligned,
	2 reserved		        bit(34)  unaligned,
	2 number_of_dimensions	        fixed(7) unaligned,
	2 own_number_of_dimensions	fixed(7) unaligned,
	2 element_boundary		fixed(3) unaligned,
	2 size_units		        fixed(3) unaligned,
	2 offset_units		        fixed(3) unaligned,
	2 interleaved		        bit(1)   unaligned,
	2 c_element_size		fixed(24),
	2 c_element_size_bits	        fixed(24),
	2 c_virtual_origin		fixed(24),
	2 element_size		        ptr unaligned,
	2 element_size_bits		ptr unaligned,
	2 virtual_origin		ptr unaligned,
	2 symtab_virtual_origin	        ptr unaligned,
	2 symtab_element_size	        ptr unaligned,
	2 bounds			ptr unaligned,
	2 element_descriptor	        ptr unaligned;
 
dcl	1 bound			        based aligned,
	2 node_type		        bit(9),
	2 c_lower			fixed(24),
	2 c_upper			fixed(24),
	2 c_multiplier		        fixed(24),
	2 c_desc_multiplier		fixed(24),
	2 lower			        ptr unaligned,
	2 upper			        ptr unaligned,
	2 multiplier		        ptr unaligned,
	2 desc_multiplier		ptr unaligned,
	2 symtab_lower		        ptr unaligned,
	2 symtab_upper		        ptr unaligned,
	2 symtab_multiplier		ptr unaligned,
	2 next			        ptr unaligned;

See also[edit]

References[edit]

  1. ^ Holt, Richard C (July 1987). "Data descriptors: a compile-time model of data and addressing". ACM Transactions on Programming Languages and Systems (TOPLAS) 9 (3): 367–389. doi:10.1145/24039.24051. 
  2. ^ Schonberg, Ed. "Ada Compared with C++". The Advantages of Ada 95. Retrieved January 15, 2013. 
  3. ^ Hewlett-Packard. "Chapter 7 OpenVMS Argument Descriptors". HP OpenVMS Systems Documentation. Retrieved January 15, 2013. 
  4. ^ Honeywell, Inc. (1979). Multics Programmers' Manual – Subsystem Writers' Guide. pp. 2–13–2–18. 
  5. ^ IBM Corporation (2006). Enterprise PL/I for z/OSProgramming Guide. p. 385. 
  6. ^ MIT/Honeywell. "array.incl.pl1". Multics/ldd/include. Retrieved January 20, 2012.