DCL IS THE STANDARD COMMAND LINE INTERFACE (CLI) ADOPTED BY MOST OF THE OPERATING SYSTEMS THAT WERE SOLD BY THE FORMER DIGITAL EQUIPMENT CORPORATION (WHICH HAS SINCE
BEEN ACQUIRED BY HEWLETT-PACKARD). IT HAD ITS ROOTS IN THE IAS AND RSTS/11 OPERATING SYSTEMS, BUT TOOK ITS MOST POWERFUL FORM IN THE OPENVMS OPERATING SYSTEM. IT WAS IMPLEMENTED AS A STANDARD ACROSS MOST OF DIGITAL'S OPERATING SYSTEMS, NOTABLY
RSX-11.
A SCRIPTING LANGUAGE THAT WAS WRITTEN WHEN THE FORTRAN PROGRAMMING
LANGUAGE WAS IN HEAVY USE, IT SUPPORTS SEVERAL DATATYPES, INCLUDING STRINGS,
INTEGERS, BIT ARRAYS, ARRAYS AND BOOLEANS, BUT NOT FLOATING POINT NUMBERS. ACCESS TO OPENVMS SYSTEM SERVICES
(KERNEL API) IS THROUGH LEXICAL FUNCTIONS, WHICH PERFORM THE SAME AS THEIR COMPILED LANGUAGE COUNTERPARTS AND ALLOW SCRIPTS TO GET INFORMATION ON
SYSTEM STATE. DCL INCLUDES IF-THEN-ELSE, ACCESS TO ALL THE RMS FILE TYPES INCLUDING STREAM, INDEXED, AND SEQUENTIAL, BUT UNFORTUNATELY LACKS A DO-WHILE OR
OTHER LOOPING CONSTRUCT, REQUIRING USERS TO MAKE DO WITH IF AND GOTO-LABEL INSTEAD.
FOR THE OPENVMS IMPLEMENTATION, THE COMMAND LINE PARSER IS A RUNTIME LIBRARY (CLI$) THAT CAN BE COMPILED INTO USER APPLICATIONS AND THEREFORE GIVES A
CONSISTENT COMMAND LINE INTERFACE FOR BOTH OPERATING SYSTEM SUPPLIED COMMANDS AND USER WRITTEN COMMANDS. THE COMMAND LINE MUST
START WITH A VERB AND IS THEN FOLLOWED BY ARGUMENTS AND/OR POSITION INDEPENDENT QUALIFIERS (SWITCHES IN UNIX TERMINOLOGY), WHICH CAN OCCUR ANYWHERE ON THE COMMAND LINE, OR POSITION DEPENDENT QUALIFIERS WHICH AFFECT
THE PARAMETER THEY APPEAR AFTER. MOST QUALIFIERS ARE POSITION INDEPENDENT; THAT IS, THEY CAN APPEAR ANYWHERE IN THE COMMAND LINE.
ONLY THE FIRST MOST SIGNIFICANT PART OF THE VERB AND QUALIFIER NAME IS REQUIRED. AN EXAMPLE OPERATING SYSTEM COMMAND MAY LOOK
LIKE:
SET AUDIT/ALARM/ENABLE=(AUTHORIZATION,BREAKIN=ALL)
SHOW DEVICE/FILES $1$DGA1424:
THE SECOND SHOW COMMAND COULD ALSO BE TYPED AS
SHO DEV $1$DGA1424:/FIL
UNLIKE OTHER SYSTEMS WHICH USE PATHS FOR LOCATING
COMMANDS, DCL REQUIRES COMMANDS TO BE DEFINED EXPLICITLY, EITHER VIA CLD (COMMAND LANGUAGE DEFINITION) DEFINITIONS OR A
FOREIGN SYMBOL. MOST OPENVMS-NATIVE COMMANDS ARE DEFINED VIA CLD FILES; THESE
ARE COMPILED BY THE CDU (COMMAND DEFINITION UTILITY) AND ADDED TO A DCL 'TABLE' -- SYS$LIBRARY:DCLTABLES.EXE BY DEFAULT,
ALTHOUGH PROCESSES ARE FREE TO USE THEIR OWN TABLES -- AND CAN THEN BE INVOKED BY THE USER. FOR EXAMPLE, TO DEFINE A COMMAND FOO,
WHICH ACCEPTED THE OPTION "/BAR", AND WAS IMPLEMENTED BY THE IMAGE SYS$SYSEXE:FOO.EXE, MIGHT REQUIRE A CLD FILE SIMILAR
TO:
DEFINE VERB FOO
IMAGE "SYS$SYSEXE:FOO.EXE"
QUALIFIER BAR
THE USER CAN THEN TYPE "FOO", OR "FOO/BAR", AND THE FOO PROGRAM WILL BE INVOKED. THE COMMAND DEFINITION
LANGUAGE SUPPORTS MANY TYPES OF OPTIONS, FOR EXAMPLE DATES AND FILE SPECIFICATIONS, AND ALLOWS A QUALIFIER TO CHANGE THE IMAGE
INVOKED -- FOR EXAMPLE "CREATE", TO CREATE A FILE, VS. "CREATE/DIRECTORY" TO CREATE A DIRECTORY.
THE OTHER (SIMPLER, BUT LESS FLEXIBLE) METHOD TO DEFINE COMMANDS IS VIA FOREIGN COMMANDS. THIS IS MORE AKIN TO THE UNIX
METHOD OF INVOKING PROGRAMS. BY GIVING THE COMMAND:
FOO :== $SYS$SYSEXE:FOO.EXE
THE COMMAND 'FOO' WILL INVOKE FOO.EXE, AND SUPPLY ANY ADDITIONAL ARGUMENTS LITERALLY TO THE PROGRAM, FOR EXAMPLE, "FOO -V".
THIS METHOD IS GENERALLY USED FOR PROGRAMS PORTED FROM UNIX AND OTHER NON-NATIVE SYSTEMS.
RECENT VERSIONS OF OPENVMS DCL SUPPORT THE DCL$PATH LOGICAL FOR
UNIX-STYLE COMMAND PATHS, BUT THIS FEATURE DOES NOT RECEIVE WIDESPREAD USE.
[EDIT]
SCRIPTING
DCL SCRIPTS LOOK MUCH LIKE ANY OTHER SCRIPTING LANGUAGE, WITH SOME EXCEPTIONS. ALL DCL VERBS IN A SCRIPT ARE PRECEDED WITH A $
SYMBOL; OTHER LINES ARE CONSIDERED TO BE INPUT TO A COMMAND. FOR EXAMPLE, TO USE THE TYPE COMMAND TO PRINT A PARAGRAPH ONTO THE
SCREEN, ONE MIGHT USE A SCRIPT SIMILAR TO:
$ TYPE SYS$INPUT:
THIS IS AN EXAMPLE OF USING THE TYPE VERB
IN THE DCL LANGUAGE.
$ EXIT
[EDIT]
INDIRECT VARIABLE REFERENCING
IT IS POSSIBLE TO BUILD ARRAYS IN DCL THAT ARE REFERENCED THROUGH TRANSLATED SYMBOLS. THIS ALLOWS THE PROGRAMMER TO BUILD
ARBITRARILY SIZED DATA STRUCTURES USING THE DATA ITSELF AS AN INDEXING FUCTION.
$ I = 1
$ VARIABLE'I' = "BLUE"
$ I = 2
$ VARIABLE'I' = "GREEN"
$ J = 1
$ COLOR = VARIABLE'J'
$ RAINBOW'COLOR' = "RED"
$ COLOR = VARIABLE'I'
$ RAINBOW'COLOR' = "YELLOW"
IN THIS EXAMPLE THE VARIABLE RAINBOWBLUE IS ASSIGNED THE VALUE "RED", AND RAINBOWGREEN IS ASSIGNED THE VALUE "YELLOW".
[EDIT]
EXTERNAL LINKS
HP OPENVMS DCL DICTIONARY
(HTTP://H71000.WWW7.HP.COM/DOC/732FINAL/9996/9996PRO.HTML)
OPENVMS.ORG'S DCL ARCHIVE (HTTP://DCL.OPENVMS.ORG/)
ARCHIVE OF DEC
PROFESSIONAL/DIGITAL AGE MAGAZINE'S DCL COLUMNS (HTTP://WWW.KGB.COM/DCL.HTML)
ForsättNING
PÅ Webdeveloper
