Data descriptor

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

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

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

References

  1. Holt, Richard C. (July 1987). "Data descriptors: a compile-time model of data and addressing". ACM Transactions on Programming Languages and Systems. 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 (PDF). pp. 213–218.
  5. IBM Corporation (2006). Enterprise PL/I for z/OSProgramming Guide (PDF). p. 385.
  6. MIT/Honeywell. "array.incl.pl1". Multics/ldd/include. Retrieved January 20, 2012.


This article is issued from Wikipedia - version of the 11/26/2016. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.