MULTICS (3513/mul003)

Command system for Multics 

Command language for Multics.

from the Manual:
"The Multics Command Language provides the user with a concise means of expressing his wishes to the Multics system. The language and Implementation are based on the work and suggestions of L. Peter Deutsch, E. L. Glaser, R. M. Graham, C. N. Mooers, J. H. Saltzer, and C. Strachey."

Related languages
BESYS => MULTICS   Derivation of
CTSS => MULTICS   Evolution of
TRAC T64 => MULTICS   Derivation of
MULTICS => sh   Evolution of

  • W. H. Southworth, G. Schroeder, R. Sobecki, D. Eastwood "Multics Command Language" MULTICS SYSTEM-PROGRAMMERS' MANUAL Section BX.1.00 10/29/68 view details External link: online Extract: Multics and PL/I
    Most time-sharing systems provide the user with various services which may be invoked from his console by means of "commands" to the operating system. A small number of time-sharing systems go beyond this and allow any user to define (with varying degrees of ease) his own commands, which may be used in exactly the same way as the system supplied commands. Nearly all command programs, whether user defined or system provided, require additional information, which must be supplied by the user, before they can complete their function. Some systems require that every command program directly interrogate the user for the additional information it needs. A more general method is to accept "arguments" in addition to the command name, at the time the command is issued by the user. These arguments are then passed on to the command program by the system. This approach permits great flexibility in the design of command programs. Information may be supplied by arguments, interrogation or a combination of both.

    Issuing a command is analogous to executing a function or subroutine call in a language such as PL/I or FORTRAN. With this view, the name of the command is simply the name of a command program to be either interpreted, if it is a user defined macro (see BX,1.01 for a description of the Macro facility), or executed if it is the name of an entry point in an executable segment which conforms to Multics standards (as defined in BD.7.02). The arguments are either used in the expansion of the macro or passed to the executed procedure in the standard manner. The link between the issuance of the command by a user and the calling of the command program is the command language interpreter. It performs many of the functions of a compiler, principally, parsing the command (which is initially a character string) into its basic elements (e.g., command name and arguments) and formatting the arguments for use by the command program. Finally, the command language interpreter calls the macro expander if the command name is the name of a macro or calls the command program directly.
  • A. W. Colijn: "A NOTE ON THE MULTICS COMMAND LANGUAGE" Calgary Computer Science Technical Reports 1980-47-05 December 1, 1980 view details Abstract: Some aspects of the Multics operating system are critically examined. In particular, the properties of the command and language are noted as allowing considerable general purpose programming power. The strength and weaknesses are discussed and a quantitative evaluation of speed is attempted based on a comparison of programming the "Towers of Hanoi" and Ackermann's function in both Multics command language and pll. The programs also serve to exemplify the use of the command language.

  • Mastrogiovanni, Amy P. "Operating Systems: Some Reflections After a Meeting in Chicago" view details
          in Annals of the History of Computing 10(3) 1988 view details
  • Norberg, Arthur L.; O'Neill, Judy E.; Freedman, Kerry J. "A history of the Information Processing Techniques Office of the Defense Advanced Research Projects Agency" The Charles Babbage Institute, The University of Minnesota, Minneapolis, MN, October 1992 view details Extract: BESYS and MULTICS
    Bell Laboratories was looking for a new computer in order to implement a new time-sharing operating system for its internal use. It had developed its own in-house BESYS (Bell System) batch operating system on an IBM 704 computer in 1958. BESYS continued to evolve as it served as the operating system for the many IBM computers used at Bell Laboratories. The staff evaluated the GE equipment and chose it for their planned time-sharing system.
    They then decided to cooperate with Project MAC and GE on the development of a new time-sharing system. In 1965, the three organizations announced their joint effort in a series of papers describing the planned Multiplexed Information and Computing Service (Multics). Each organization brought strengths to the project.

          in Annals of the History of Computing 10(3) 1988 view details
  • Tom Van Vleck entry for "Command Language" in "Multics Glossary" view details External link: online Extract: Multics command language
    The Multics command language derives from the CTSS language, with ideas added from BESYS and TRAC. The listener reads lines from the input stream and passes them to the shell for execution.

    The Multics command language permits quoting, iteration and command functions ("active functions") with string return values. The string return values can themselves contain quoting, iteration, or more command functions. By default the command processor evaluates the return value, but you can suppress that and use the unevaluated return value. There is no particular limit to the length of a command line, command argument or return value; the [files] active function returns the names of all files matching a star name, for example, which can easily return hundreds of file names. Everything in Multics is case sensitive; Multics permits use of the full upper and lower case ASCII character set.

    Multics command names and programming languages use lowercase by convention, but users are free to use uppercase letters in path names, identifiers, user names, etc.

    Simple command line example:

    rename a.pl1 b.pl1     /* renames branch a.pl1 to b.pl1
                            works on files, dirs, or links */

    Quoted command line example:

    rename "x y z" "x_y_z" /* change spaces to underscores yes,
                               filenames could have spaces */

    Iteration example:

    rename (a b c).pl1 (d e f).pl1

    expands to:

    rename a.pl1 d.pl1
    rename b.pl1 e.pl1
    rename c.pl1 f.pl1

    Active Function example:

    copy [home_dir]>Green.abbrev

    All of these features can be combined, nested, etc., to produce very complex (and very useful) command lines. To run two commands on the same file, you can say:

    (edm pl1) t.pl1

    which runs the edm line editor, then the pl1 compiler, on the file t.pl1.
    Since Multics was meant to be extensible, you can write your own commands, your own active functions, your own command processor, or even your own "listener" (the top-level program in the process that reads command lines and dispatches them to the command processor). We had environments that simulated Dartmouth BASIC (by Bob Frankston) and GCOS timesharing, to name two. [PG]

    An early implementation of the Multics command language is described in MSPM section BX.1.00. Several features described in that section were changed later, such as the support for two different quoting mechanisms.

          in Annals of the History of Computing 10(3) 1988 view details

    • bnf: <command sequence> ::= <command> (<semicolon> <command>)

      <command> ::= <element list>

      <element list> ::= <element> (<spaces> <element list>)

      <element> ::= <element component> (<element>)

      <element component> ::= <function> | <iteration set>
                              <literal string> | <unreserved character>

      <function> ::= <active function> | <neutral function>
                     <empty function>

      <active function>  ::= <left bracket> <command> <right bracket>

      <neutral function> ::= <vertical bar> <left bracket>
                             <command> <right bracket>

      <empty function> ::= <vertical bar> <vertical bar> <left
                            bracket> <command> <right bracket>

      <iteration set> ::= <left paren> <element list> <right paren>

      <literal string> ::= <quoted string> | <balanced quoted string>

      <quoted string> ::= <quote> <balanced quoted string> <quote> |
                          <quote> <unquoted character string> <quote>

      <balanced quoted string> ::= <left accent> <balanced quoted
                                   substring> <right accent>

      <balanced quoted substring> ::= <character string not containing ' or `>
                                      | <balanced quoted string>