DG/L

Last updated
DG/L
Data General logo.svg
Paradigms Multi-paradigm: procedural, imperative, structured
Family ALGOL
Developer Data General
First appeared1978;45 years ago (1978)
Platform Nova, Eclipse, Eclipse/MV
OS RDOS, AOS, AOS/VS
Influenced by
ALGOL 60

DG/L is a programming language developed by Data General Corp for the Nova, Eclipse, and Eclipse/MV families of minicomputers in the 1970s and early 1980s.

Contents

There were two separate versions:

The language itself was an extended version of Algol 60. It supported Integers, Single and Double precision floating point and complex numbers, and both fixed and arbitrary precision strings. It also supported full arbitrary precision binary-coded decimal (BCD) arithmetic on strings. It had many convenient program control flow features, but being designed in the mid 70s, lacked user defined data structures.

DG/L had a substantial runtime library for its day, and was used for systems programming both within and outside of Data General.

Originally called Algol/5, the product renamed DG/L shortly before the first commercial release in 1978. Officially, the name is meaningless but it was apparently supposed to imply "Data General Language". After the first commercial release, targeting 16-bit Eclipse and Nova, several subsequent updates and major versions were released, approximately one a year.

Comparison with Algol 60

Appendix A of Data General's 1982 revision of its DG/L Language Reference Manual, 093-00229-01 describes DG/L as based on the ALGOL 60 programming language, but gives "data types, operations and statements that ALGOL 60 lacks". Specific differences are:

Algol 60 features unsupported in DG/L

Algol 60 featureAs described in Algol 60 report [1] paragraphDG/ notes
Call by namepara. 4.7.3.2DG/L allows procedure parameters as type PROCEDURE, allowing procedures to be passed by name to other procedures.
Nested quotation marks in literals2.6.1 and 2.4.1
No limit on length of identifiersDG/L identifier names need to be unique within the first 32 characters
Two division operators3.3.4.2DG/L uses "/" for both real and integer division; an integer divided by another integer implies integer division (e.g. 1/4 is 0) unless the compiler's global /R switch is used
Notation of 10 <integer>2.5.1DG/L uses E <integer> (or D <integer> for double precision) for "scientific" notation to show powers of ten
A program consisting only of a <compound statement>4.1.1
Non-ASCII characters ⋀,⋁,¬,⊃,≡,≤,≥,≠ as Boolean operators3.4.6.1DG/L allows instead: AND, OR, NOT, IMP, EQV, <= (or =<),>= (or =>), and <> (or ><) as well as XOR
Including non-Algol code within Algol procedures4.7.8Apart from the FORTRAN 5 math library, documentation for external procedures assumes only other DG/L procedures will be linked in.

Extensions

Some of the extensions to the Algol 60 standard introduced in DG/L or carried over from Data General's previous Algol implementation of 1971:

String operations

  • SUBSTR - substring
  • INDEX - position of a substring
  • LENGTH - length of a string
  • SETCURRENT - sets the current length of a string, e.g. setcurrent(str,length(str)-1);
  • Concatentation operator: "!!"
  • String arithmetic (e.g. "123.45" + "0.01" )
  • Type conversion (Boolean, Integer, Real, Pointer, Bit)
  • Octal numbers and some special symbols enclosed in brackets to represent ASCII characters

Input and output

  • Fully formatted output, unformatted input, and output for all supported data types
  • Full interface to Data General's RDOS, AOS and AOS/VS system calls
  • Cache memory management (with virtual memory option).
  • Interface to CLRE and INFOS II databases

Other extensions

  • Conditional compiling of sections of code, using /**letter-digit-string <statement> */
  • end-of-line comments using the % character and /* comment */
  • expanded do, for, and if syntax (e.g. WHILE <boolexp1> DO <statement> UNTIL <boolexp2> )
  • Types: BIT, BYTE, 16-bit and 32-bit integers, 32-bit and 64-bit reals and arbitrary precision arithmetic,
  • Literals, e.g. LITERAL C (299792.458)
  • Global data
  • Error trapping
  • External procedures and data
  • Cluster declaration... very similar to Pascal units (allows a cluster of procedures and data in a separate compiled source).
  • Pointer -> symbol and BASED variables of all types
  • Exclusive-OR operator (XOR)
  • Multitasking

Related Research Articles

<span class="mw-page-title-main">Data General Nova</span> 16-bit minicomputer series

The Data General Nova is a series of 16-bit minicomputers released by the American company Data General. The Nova family was very popular in the 1970s and ultimately sold tens of thousands of units.

<span class="mw-page-title-main">Floating-point arithmetic</span> Computer approximation for real numbers

In computing, floating-point arithmetic (FP) is arithmetic that represents subsets of real numbers using an integer with a fixed precision, called the significand, scaled by an integer exponent of a fixed base. Numbers of this form are called floating-point numbers. For example, 12.345 is a floating-point number in base ten with five digits of precision:

In computer science, an integer is a datum of integral data type, a data type that represents some range of mathematical integers. Integral data types may be of different sizes and may or may not be allowed to contain negative values. Integers are commonly represented in a computer as a group of binary digits (bits). The size of the grouping varies so the set of integer sizes available varies between different types of computers. Computer hardware nearly always provides a way to represent a processor register or memory address as an integer.

PL/I is a procedural, imperative computer programming language initially developed by IBM. The PL/1 ANSI standard, X3.53-1976, was published in 1976. It is designed for scientific, engineering, business and system programming. It has been in continuous use by academic, commercial and industrial organizations since it was introduced in the 1960s.

OCaml is a general-purpose, high-level multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. OCaml was created in 1996 by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, and others.

Double-precision floating-point format is a floating-point number format, usually occupying 64 bits in computer memory; it represents a wide dynamic range of numeric values by using a floating radix point.

<span class="mw-page-title-main">Data type</span> Attribute of data

In computer science and computer programming, a data type is a collection or grouping of data values, usually specified by a set of possible values, a set of allowed operations on these values, and/or a representation of these values as machine types. A data type specification in a program constrains the possible values that an expression, such as a variable or a function call, might take. On literal data, it tells the compiler or interpreter how the programmer intends to use the data. Most programming languages support basic data types of integer numbers, floating-point numbers, characters and Booleans.

<span class="mw-page-title-main">Data General</span> Minicomputer manufacturer, 1968–1999

Data General Corporation was one of the first minicomputer firms of the late 1960s. Three of the four founders were former employees of Digital Equipment Corporation (DEC).

In computer programming, a type system is a logical system comprising a set of rules that assigns a property called a type to every term. Usually the terms are various language constructs of a computer program, such as variables, expressions, functions, or modules. A type system dictates the operations that can be performed on a term. For variables, the type system determines the allowed values of that term. Type systems formalize and enforce the otherwise implicit categories the programmer uses for algebraic data types, data structures, or other components.

The Data General RDOS is a real-time operating system released in 1970. The software was bundled with the company's popular Nova and Eclipse minicomputers.

<span class="mw-page-title-main">GNU Multiple Precision Arithmetic Library</span> Free software

GNU Multiple Precision Arithmetic Library (GMP) is a free library for arbitrary-precision arithmetic, operating on signed integers, rational numbers, and floating-point numbers. There are no practical limits to the precision except the ones implied by the available memory (operands may be of up to 232−1 bits on 32-bit machines and 237 bits on 64-bit machines). GMP has a rich set of functions, and the functions have a regular interface. The basic interface is for C, but wrappers exist for other languages, including Ada, C++, C#, Julia, .NET, OCaml, Perl, PHP, Python, R, Ruby, and Rust. Prior to 2008, Kaffe, a Java virtual machine, used GMP to support Java built-in arbitrary precision arithmetic. Shortly after, GMP support was added to GNU Classpath.

In computer science, type conversion, type casting, type coercion, and type juggling are different ways of changing an expression from one data type to another. An example would be the conversion of an integer value into a floating point value or its textual representation as a string, and vice versa. Type conversions can take advantage of certain features of type hierarchies or data representations. Two important aspects of a type conversion are whether it happens implicitly (automatically) or explicitly, and whether the underlying data representation is converted from one representation into another, or a given representation is merely reinterpreted as the representation of another data type. In general, both primitive and compound data types can be converted.

In computer science, arbitrary-precision arithmetic, also called bignum arithmetic, multiple-precision arithmetic, or sometimes infinite-precision arithmetic, indicates that calculations are performed on numbers whose digits of precision are limited only by the available memory of the host system. This contrasts with the faster fixed-precision arithmetic found in most arithmetic logic unit (ALU) hardware, which typically offers between 8 and 64 bits of precision.

Data General Business Basic was a BASIC interpreter marketed by Data General for their Nova minicomputer in the 1970s, and later ported to the Data General Eclipse MV and AViiON computers. Most business applications for the Nova were developed in Business Basic.

B32 Business Basic was a competitor to Data General Business Basic written by Murray Haszard in 1986. It ran on the Data General Eclipse MV line of computers initially, and was ported to Unix in 1989 and to DOS in 1991.

In computer science, the Boolean is a data type that has one of two possible values which is intended to represent the two truth values of logic and Boolean algebra. It is named after George Boole, who first defined an algebraic system of logic in the mid 19th century. The Boolean data type is primarily associated with conditional statements, which allow different actions by changing control flow depending on whether a programmer-specified Boolean condition evaluates to true or false. It is a special case of a more general logical data type—logic does not always need to be Boolean.

In computer programming, a one-pass compiler is a compiler that passes through the parts of each compilation unit only once, immediately translating each part into its final machine code. This is in contrast to a multi-pass compiler which converts the program into one or more intermediate representations in steps between source code and machine code, and which reprocesses the entire compilation unit in each sequential pass.

Data General AOS was the name of a family of operating systems for Data General 16-bit Eclipse C, M, and S minicomputers, followed by AOS/VS and AOS/RT32 (1980) and later AOS/VS II (1988) for the 32-bit Eclipse MV line.

This article compares a large number of programming languages by tabulating their data types, their expression, statement, and declaration syntax, and some common operating-system interfaces.

Dartmouth ALGOL 30 was a 1960s-era implementation, first of the ALGOL 58 programming language and then of ALGOL 60. It is named after the computer on which it ran: a Librascope General Precision (LGP-30) desk-size computer acquired by Dartmouth College in 1959.

References

  1. Naur, Peter (Jan 1963). "Revised Report on the Algorithmic Language ALGOL 60". Communications of the ACM. 6: 1–17. doi: 10.1145/366193.366201 .