H ? « ‹ ← → › »

Language peer sets for ALGOL 60:
International↑
International/1959↑
Designed 1959 ↑
1950s languages ↑
Second generation↑
Early Cold War↑
Genus True ALGOL60s ↑
Numerical Scientific ↑
True ALGOL60s↑
Generation of Algol 60↑
Algol family ↑
True ALGOL60s/1959↑
Generation of Algol 60/1959↑
Algol family/1959↑
True ALGOL60s/International↑
Generation of Algol 60/International↑
Algol family/International↑
Numerical Scientific ↑
Numerical Scientific/1959↑
Numerical Scientific/aa ↑

ALGOL 60(ID:1807/alg020)

Algorithm Language 

alternate simple view
Country: International
Designed 1959
Published: 1960
Genus: True ALGOL60s
Sammet category: Numerical Scientific

A portable (international) language for scientific (mathematical) computations.

ALGOL 60 is small and elegant. It is block-structured, nested, recursive, and free-form. It was also the first language to be described in BNF (Backus-Naur Form). There are three lexical representations: hardware, reference, and publication. The only structured data types are arrays, but they are permitted to have lower bounds and could be dynamic. It also has conditional expressions, it introduced =, if, then, else ; very general "for' loops, switch declaration. Parameters are call-by-name and call-by-value. It has static local "own" variables. It lacks user-defined types, character manipulation and standard I/O.

Structures:
Related languages
ALGOL 58 → ALGOL 60   Evolution of
BNF → ALGOL 60   Spec written in
ALGOL 60 → ABC ALGOL   Extension of
ALGOL 60 → ABS12 ALGOL   Extension of
ALGOL 60 → Active Language I   Written using
ALGOL 60 → AED   Extension of
ALGOL 60 → AL   Based on
ALGOL 60 → A-language   Influence
ALGOL 60 → ALCOR   Subset
ALGOL 60 → ALGAMC   Extension of
ALGOL 60 → ALGEK   Evolution of
ALGOL 60 → Algol 1620   Port
ALGOL 60 → Algol 205   Influence
ALGOL 60 → ALGOL 30   Implementation
ALGOL 60 → Algol 50   Extension of
ALGOL 60 → Algol 60 Publishing   Co-development
ALGOL 60 → ALGOL 60 Revised   Evolution of
ALGOL 60 → Algol 62   Extension of
ALGOL 60 → ALGOL C   Extension of
ALGOL 60 → ALGOL C   Extension of
ALGOL 60 → ALGOL N   Successor
ALGOL 60 → ALGOL(E)   Dialect of
ALGOL 60 → ALGOL/ZAM   Implementation
ALGOL 60 → ALGOL-GENIUS   Dialect of
ALGOL 60 → ALGOL-M   Based on
ALGOL 60 → ALPHA   Dialect of
ALGOL 60 → ANALITIK   Influence
ALGOL 60 → APDL   Extension of
ALGOL 60 → ASGOL   Extension of
ALGOL 60 → BABEL   Subset
ALGOL 60 → BASIC   Incorporated features of
ALGOL 60 → BETA   Dialect of
ALGOL 60 → Case ALGOL   Implementation
ALGOL 60 → Chinese Algol   Implementation
ALGOL 60 → CONA   Augmentation of
ALGOL 60 → COWSEL   Negative moderate Influence
ALGOL 60 → DECAL   Subset
ALGOL 60 → Denert   Extension of
ALGOL 60 → DG/L   Implementation of
ALGOL 60 → DIAMAG   Augmentation of
ALGOL 60 → ECMA ALGOL   Subset
ALGOL 60 → EL1   Influence
ALGOL 60 → Elliott ALGOL   Implementation
ALGOL 60 → EMIDEC Algol   Implementation
ALGOL 60 → EULER   Evolution of
ALGOL 60 → Extended ALGOL   Augmentation of
ALGOL 60 → FLEX   Influence
ALGOL 60 → Forsythe   Influence
ALGOL 60 → GEA   Extension of
ALGOL 60 → Generalized ALGOL   Extension of
ALGOL 60 → Glypnir   Extension of
ALGOL 60 → GOGOL   Implementation
ALGOL 60 → GPL   Augmentation of
ALGOL 60 → GSP   Extension of
ALGOL 60 → IFIP ALGOL   Subset
ALGOL 60 → IMP   Extension of
ALGOL 60 → Irons syntax language   compiler for
ALGOL 60 → Kidsgrove Algol   Implementation
ALGOL 60 → LEAP   Augmentation of
ALGOL 60 → LITHP   Extension of
ALGOL 60 → LOGOL   Extension of
ALGOL 60 → LOTIS   Incorporated some features of
ALGOL 60 → LPL   Derivation of
ALGOL 60 → MALGOL   Implementation
ALGOL 60 → MLISP   Derivation of
ALGOL 60 → NU ALGOL   Implementation
ALGOL 60 → NUCOL   Influence
ALGOL 60 → OSL   Dialect of
ALGOL 60 → PALGO   Augmentation of
ALGOL 60 → PL360   Influence
ALGOL 60 → Process Control Algol   Extension of
ALGOL 60 → PROTOL   Dialect of
ALGOL 60 → PSYCO   dialect of
ALGOL 60 → REDUCE   Derivation of
ALGOL 60 → RegneCentralen ALGOL   Implementation
ALGOL 60 → Relay method   Extension of
ALGOL 60 → Schrader simulation Algol   Extension of
ALGOL 60 → SIMON   Based on
ALGOL 60 → SIMULA   Extension of
ALGOL 60 → SMALGOL   Subset
ALGOL 60 → SNOBOL-A   Subset
ALGOL 60 → SOL   Extension of
ALGOL 60 → SYMBAL   Derivation of
ALGOL 60 → Syncretic   Extension of
ALGOL 60 → TALK   Extension of
ALGOL 60 → The New Language   Influence
ALGOL 60 → Triplex Algol 60   Extension of
ALGOL 60 → USS 90 Algol   Implementation
ALGOL 60 → VALGOL   Implementation
ALGOL 60 → X1 Algol 60   Implementation
References:
  • Naur, P. et al (1960) Naur, P. et al "Report on the algorithmic language ALGOL 60"
          in [ACM] (1960) [ACM] CACM 3(05) May 1960
  • Naur et al (1960) Naur, P. et al "Report on the algorithmic language ALGOL 60"
          in Goodman (ed) (1961) Goodman, Richard (ed) "Annual Review in Automatic Programming" (2) 1961 Pergamon Press, Oxford
  • Woodger, M (1960) Woodger, M "An introduction to ALGOL 60" pp67-75 Abstract
          in (1960) The Computer Journal 3(2) July 1960
  • Bagley, PR (1961) Bagley, PR "Improving problem-oriented language by stratifying it" pp217-221
          in (1961) The Computer Journal 4(3) October 1961
  • Ershov, A. P. (1961) Ershov, A. P. "Avtomatizacija programmirovanija sbor-nik perevodov" [Automatic programming. A collection of translations covering FORTRAN, UNICODE, SOAP, IT and ALGOL] Moscow 1961.
          in (1961) The Computer Journal 4(3) October 1961
  • Naur, Peter (1961) Naur, Peter "The Progress of ALGOL in Europe" Extract: Introduction Extract: The Central European Group (ALCOR) Extract: The Dutch Group Extract: The Scandinavian Group Extract: Independent Centers Extract: General Trends Extract: Conclusion
          in [Proceedings] (1961) Proceedings of the 1961 Computer Applications Symposium, Armour Research Foundation, Illinois Institute of Technology, Chicago, Illinois
  • Rutishauser (1961) Rutishauser, H. "Interference With An Algol Procedure" pp67-76
          in Goodman (ed) (1961) Goodman, Richard (ed) "Annual Review in Automatic Programming" (2) 1961 Pergamon Press, Oxford
  • Barron (1962) Barron, D. W. review of Goodman, Richard (ed) "Annual Review in Automatic Programming", Vol. 2 Abstract Extract: ALGOL 60, MADCAP II, ELLIOTT Autocode
          in [Computer Bulletin] (1962) The Computer Bulletin June 1962
  • d'Agapeyeff, A.; (1962) d'Agapeyeff, A.; "Current developments in commercial automatic programming" pp107-111 Abstract Extract: The properties of data Extract: ALGOL
          in (1962) The Computer Journal 5(2) July 1962
  • Conway, R.W. et al, (1963) Conway, R.W. et al, "The Cornell Computing Language" DOI Abstract Extract: The CORC Language Extract: A field test of CORC
          in [ACM] (1963) [ACM] CACM 6(06) (June 1963)
  • Dijkstra, E. W. (1963) Dijkstra, E. W. "An Algol 60 Translator For the X1" pp329-346
          in Goodman (ed) (1963) Goodman, Richard (ed) "Annual Review in Automatic Programming" (3) 1963 Pergamon Press, Oxford
  • Dijkstra, E. W. (1963) Dijkstra, E. W. "On the Design of Machine Independent Programming Languages" pp27-42
          in Goodman (ed) (1963) Goodman, Richard (ed) "Annual Review in Automatic Programming" (3) 1963 Pergamon Press, Oxford
  • Duncan, FG (1963) Duncan, FG "Input and output for ALGOL 60 on KDF 9" pp341-344 Online copy
          in (1963) The Computer Journal 5(4) January 1963
  • Gerard, JM and Sambles, A (1963) Gerard, JM and Sambles, A "A hardware representation for ALGOL 60 using Creed teleprinter equipment" pp338-340 Abstract Online copy
          in (1963) The Computer Journal 5(4) January 1963
  • Hawkins, E. N. and Huxtable, H. R. (1963) Hawkins, E. N. and Huxtable, H. R. "A Multi-Pass Translation Scheme For Algol 60" pp163-206
          in Goodman (ed) (1963) Goodman, Richard (ed) "Annual Review in Automatic Programming" (3) 1963 Pergamon Press, Oxford
  • Higman, B. (1963) Higman, B. "Towards An Algol Translator" pp121-162
          in Goodman (ed) (1963) Goodman, Richard (ed) "Annual Review in Automatic Programming" (3) 1963 Pergamon Press, Oxford
  • Hirschmann, W. (1963) Hirschmann, W. review of d'Agapeyeff 1962 (Comp J) Abstract
          in [ACM] (1963) ACM Computing Reviews 4(01) January-February, 1963
  • Hoare, CAR (1963) Hoare, CAR "The Elliott ALGOL input/output system" pp345-348 Abstract Online copy
          in (1963) The Computer Journal 5(4) January 1963
  • Leavenworth, B. (1963) Leavenworth, B. review of Naur CACM 1963 Abstract
          in [ACM] (1963) ACM Computing Reviews 4(01) January-February, 1963
  • Naur, Peter (1963) Naur, Peter "Documentation problems: ALGOL 60" pp77-79
          in [ACM] (1963) [ACM] CACM 6(03) (Mar 1963)
  • Naur, Peter (ed) (1963) Naur, Peter (ed) "Revised Report on the Algorithmic Language ALGOL 60
          in Goodman, Richard (ed) (1964) Goodman, Richard (ed) "Annual Review in Automatic Programming" (4) 1964 Pergamon Press, Oxford
  • Naur, Peter (ed) (1963) Naur, Peter (ed) "Revised Report on the Algorithmic Language ALGOL 60" Abstract Online copy
          in (1963) The Computer Journal 5(4) January 1963
  • (1963) Official actions and responses to ALGOL as a programming language pp159-160
          in [ACM] (1963) [ACM] CACM 6(04) April 1963
  • Rutishauser, H. (1963) Rutishauser, H. "The Use of Recursive Procedures In Algol 60" pp43-52
          in Goodman (ed) (1963) Goodman, Richard (ed) "Annual Review in Automatic Programming" (3) 1963 Pergamon Press, Oxford
  • Shoffner, Miriam G. and Peter J. Brown (1963) Shoffner, Miriam G. and Peter J. Brown "A suggested method of making fuller use of strings in ALGOL 60" pp169-171 Abstract
          in [ACM] (1963) [ACM] CACM 6(04) April 1963
  • Watt, JM (1963) Watt, JM "The realization of ALGOL procedures and designational expressions" pp332-337 Abstract Online copy
          in (1963) The Computer Journal 5(4) January 1963
  • Woodger, M. (1963) Woodger, M. "The Description Of Computing Processes, Some Observations on Automatic Programming And Algol 60" pp 1-22
          in Goodman (ed) (1963) Goodman, Richard (ed) "Annual Review in Automatic Programming" (3) 1963 Pergamon Press, Oxford
  • Burnett-Hall, D. G.; Dresel, L.A.G.; Samet, P.A. (1964) Burnett-Hall, D. G.; Dresel, L.A.G.; Samet, P.A. "Computer programming and autocodes" London, English Universities Press, 1964 Extract: Pegasus and Sirius - General Information
          in Goodman (ed) (1963) Goodman, Richard (ed) "Annual Review in Automatic Programming" (3) 1963 Pergamon Press, Oxford
  • Cavadia, I. (1964) Cavadia, I. review of Woodger 1963 Abstract
          in (1964) ACM Computing Reviews 5(05) September-October 1964
  • McCarthy, J. (1964) McCarthy, J. review of Dijkstra ARIAP 1963 (Algol 60) Abstract
          in (1964) ACM Computing Reviews 5(03) May-June 1964
  • Fano, Robert (1965) Fano, Robert "The MAC system: a progress report" pp131-150
          in Sass, M. (1965) Sass, M. and W. Wilkinson, eds. Computer Augmentation of Human Reasoning Spartan Books, Washington, D.C., 1965
  • Rosen (1965) Rosen, Saul review of Burnett-Hall et al 1964 "Computer Programming and Autocodes" Mathematics of Computation, Vol. 19, No. 89 (Apr., 1965), 168-169. Extract: Review
          in Sass, M. (1965) Sass, M. and W. Wilkinson, eds. Computer Augmentation of Human Reasoning Spartan Books, Washington, D.C., 1965
  • Advances in Computers, Vol. (1967) Advances in Computers, Vol. 8 FL Alt and M Rubinoff (Eds.), Academic Press, New York, 1967
          in Sass, M. (1965) Sass, M. and W. Wilkinson, eds. Computer Augmentation of Human Reasoning Spartan Books, Washington, D.C., 1965
  • Lecht, Charles Philip (1967) Lecht, Charles Philip "The programmer's ALGOL: a complete reference" McGraw-Hill Book Co., New Nork, 1967
          in Sass, M. (1965) Sass, M. and W. Wilkinson, eds. Computer Augmentation of Human Reasoning Spartan Books, Washington, D.C., 1965
  • Zimmerman, P.Z. (1967) Zimmerman, P.Z. review of Lecht 1967 Abstract
          in (1967) ACM Computing Reviews 8(06) November-December 1967
  • Bemer, RW (1969) Bemer, RW "A politico-Social History of Algol" pp 151-238
          in (1967) ACM Computing Reviews 8(06) November-December 1967
  • Berry, Daniel M. (1970) Berry, Daniel M. "The importance of implementation models in ALGOL 68: or how to discover the concept of necessary environment" pp14-24 Extract: doi Abstract Extract: THe necesary environment
          in [SIGPLAN] (1970) SIGPLAN Notices 5(09) September 1970
  • Harrison, Malcolm C (1970) Harrison, Malcolm C "Data-structures and programming" New York: Courant Institute of Mathematical Sciences 1970
          in [SIGPLAN] (1970) SIGPLAN Notices 5(09) September 1970
  • Rosen, S. (1972) Rosen, S. "Programming Systems and Languages 1965-1975" Abstract DOI
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • (1973) Computer Oral History Collection, 1969-1973, 1977 Interviewee: Morton Bernstein Interviewer: Robina Mapstone Date: March 14, 1973 Archives Center, National Museum of American History Extract: IAL, Algol 58, Algol 60
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Elson, M. (1973) Elson, M. Concept of programming languages, Science Research Associates, Palo Alto, Calif., 1973
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Peterson, W. (1974) Peterson, W. W. Introduction to programming languages, Prentice-Hall, Englewood Cliffs, N.J., 1974
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Nicholls, J. (1975) Nicholls, J. E. The structure and design of programming languages, Addison-Wesley, Reading, Mass., 1975
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Pratt; T. (1975) Pratt; T. W. Programming languages: Design and implementation Prentice-Hall, Englewood Cliffs N.J., 1975
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • (1976) The Higher Order Language Working Group (HOLWG) Working Paper on 23 exisitng programming languages
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Wichmann, B. A. (1976) Wichmann, B. A. "Ackermann's function: a study in the efficiency of calling procedures" BIT 16 (1976), pp103-110 Abstract Extract: Introduction Extract: Ackermann's function Extract: Acknowledgements Extract: Results of tests (altered to include authors where known) Extract: Program listing Extract: Properties of the algorithm Extract: Notes on the results and Factors influencing the execution speed Extract: Conclusion
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Barron, D. (1977) Barron, D. W. An introduction to the study of programming languages, Cambridge Univ. Press, N.Y., 1977
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Tucker, Allen B., JR. (1977) Tucker, Allen B., JR. Programming languages. McGraw-Hill, Inc., New York, 1977
          in [ACM] (1972) [ACM] CACM 15(07) (July 1972)
  • Gries, D. (1978) Gries, D. "ALGOL 60 language summary"
          in [HOPL I] (1979) SIGPLAN Notices 14(04) April 1979 including The first ACM SIGPLAN conference on History of programming languages (HOPL) Los Angeles, CA, June 1-3, 1978
  • Naur, Peter (1978) Naur, Peter "The European side of the last phase of the development of ALGOL 60"
          in [HOPL I] (1979) SIGPLAN Notices 14(04) April 1979 including The first ACM SIGPLAN conference on History of programming languages (HOPL) Los Angeles, CA, June 1-3, 1978
  • Perlis, Alan J. (1978) Perlis, Alan J. "The American side of the development of ALGOL"
          in [HOPL I] (1979) SIGPLAN Notices 14(04) April 1979 including The first ACM SIGPLAN conference on History of programming languages (HOPL) Los Angeles, CA, June 1-3, 1978
  • Sammet, Jean E (1978) Sammet, Jean E "Roster of programming languages for 1976-77" pp56-85
          in [SIGPLAN] (1978) SIGPLAN Notices 13(11) Nov 1978
  • Pagan, F. G. (1979) Pagan, F. G. "Semantic Specification Using Two-Level Grammars: Blocks, Procedures and Parameters"
          in (1979) Computer Languages 4(3-4)
  • Hoare, CAR (1980) Hoare, CAR "The Emperor's Old Clothes" the ACM Turing Award lecture, 1980 Extract: The birth of Algol 68
          in [ACM] (1981) [ACM] CACM 24(02) February 1981
  • Naur, Peter (1981) Naur, Peter "Aad van Wiingaarden's contributions to ALGOL 60" in Algorithmic languages, Proc. IFIP TC-2 International Symposium (Amsterdam, The Netherlands, 1981), J. W. de Bakker and J. C. van Vliet (Eds.), Elsevier North-Holland, Inc., New York, 1981, pp293-304.
          in [ACM] (1981) [ACM] CACM 24(02) February 1981
  • Adams, J. (1982) Adams, J. M. review of Naur 1981 (Algol 60) in ACM Computing Reviews October 1982 Abstract
          in [ACM] (1981) [ACM] CACM 24(02) February 1981
  • Allen, F. (1982) Allen, F. and Schwartz, J. review of Sammet and Lee HOPL conference end banquet excerpts Abstract
          in (1982) ACM Computing Reviews March 1982
  • Rem, M. (1982) Rem, M. review of Naur 1978 Abstract
          in (1982) ACM Computing Reviews March 1982
  • Smillie, K. (1982) Smillie, K. W. review of Perlis 1978 Abstract
          in (1982) ACM Computing Reviews March 1982
  • Dencker, Peter; Dürre, Karl; Heuft, Johannes (1984) Dencker, Peter; Dürre, Karl; Heuft, Johannes "Optimization of parser tables for portable compilers" pp546-572
          in TOPLAS 6(4) October 1984 Lecture Notes in compute (1984) TOPLAS 6(4) October 1984 Lecture Notes in computer science Vol. 174
  • Bauer (2001) Bauer, Friedrich L. "A computer pioneer's talk: pioneering work in software during the 50s in Central Europe" Extract: Introduction Extract: How did software arise? Extract: Early Work in Munich and Zurich Extract: The Kellerprinzip
          in [History of computing: software issues] (2002) "History of computing: software issues" Hashagen, Ulf; Keil-Slawik, Reinhard; Norberg, Arthur L. eds Proceedings of the international conference on History of computing: software issues 2002, Paderborn, Germany April 05 - 07, 2000 Springer 2002
  • Bauer (2001) Bauer, Friedrich L. "From the Stack Principle to Algol" Extract: Introduction to Zuse's PLankalkul Extract: Influence by Shannon Extract: sequential formula translation Extract: Recursion and the cellar principle Extract: arrival of Algol Extract: Mainz 22 and algol 58 Extract: ICIP, BNF, stack notation Extract: British hostility and absence, ZMD excellence Extract: Paris Conference Extract: The ALCOR Group Extract: Algol 58 and the death of Algol
          in [Computer Pioneers] (2001) Software Pioneers: Contributions to Software Engineering, Bonn, 28-29. 6. 2001 eds Broy, Manfred and Denert, Ernst Springer 2002
  • Bauer (2002) Bauer, Friedrich L. "My Years with Rutishauser" pdf Extract: Introduction Extract: Rutishauser’s way to Stiefel Extract: Stanislaus, Klammerausdrücke, ALGOL Extract: Algol 60 and 68
          in (2002) Latsis Symposium 2002 on the 50th Anniversary of the Conjugate Gradient Algorithm
  • George Gray (2002) George Gray "UNIVAC and ALGOL" Unisys History Newsletter 6(2) June 2002 Extract: Information Online copy at UNISIS History
          in (2002) Latsis Symposium 2002 on the 50th Anniversary of the Conjugate Gradient Algorithm
  • (2002) Library of Congress Subject Headings A24
          in (2002) Latsis Symposium 2002 on the 50th Anniversary of the Conjugate Gradient Algorithm
    Resources
    • <program> ::= <block> | <compound statement>
       <block> ::= <unlabelled block> | <label>: <block>
        <unlabelled block> ::= <block head> ; <compound tail>
        <block head> ::= ′BEGIN′ <declaration> | <block head> ; <declaration>
       <compound statement> ::= <unlabelled compound> | <label>: <compound statement>
        <unlabelled compound> ::= ′BEGIN′ <compound tail>
        <compound tail> ::= <statement> ′END′ | <statement> ; <compound tail>

      <declaration> ::= <type declaration> | <array declaration> | <switch declaration> | <procedure declaration>
       <type declaration> ::= <local or own type> <type list>
        <local or own type> ::= <type> | ′OWN′ <type>
         <type> ::= ′REAL′ | ′INTEGER′ | ′BOOLEAN′
        <type list> ::= <simple variable> | <simple variable> , <type list>
       <array declaration> ::= ′ARRAY′ <array list> | <local or own type> ′ARRAY′ <array list>
        <array list> ::= <array segment> | <array list> , <array segment>
         <array segment> ::= <array identifier> [ <bound pair list> ] | <array identifier> , <array segment>
          <array identifier> ::= <identifier>
          <bound pair list> ::= <bound pair> |  <bound pair list> , <bound pair>
           <bound pair> ::= <lower bound> : <upper bound>
            <upper bound> ::= <arithmetic expression>
            <lower bound> ::= <arithmetic expression>
       <switch declaration> ::= ′SWITCH′ <switch identifier> := <switch list>
        <switch identifier> ::= <identifier>
        <switch list> ::= <designational expression> | <switch list> , <designational expression>
       <procedure declaration> ::= ′PROCEDURE′ <procedure heading> <procedure body> | <type> ′PROCEDURE′ <procedure heading> <procedure body>
        <procedure heading> ::= <procedure identifier> <formal parameter part> ; <value part> <specification part>
         <procedure identifier> ::= <identifier>
         <formal parameter part> ::= <empty> | ( <formal parameter list> )
          <formal parameter list> ::= <formal parameter> | <formal parameter list> <parameter delimiter> <formal parameter>
           <formal parameter> ::= <identifier>
         <value part> ::= ′VALUE′ <identifier list> ; | <empty>
         <specification part> ::= <empty> | <specifier> <identifier list> ; | <specification part> <specifier> <identifier list>
          <specifier> ::= ′STRING′ | <type> | ′ARRAY′ | <type> ′ARRAY′ | ′LABEL′ | ′SWITCH′ | ′PROCEDURE′ | <type> ′PROCEDURE′
          <identifier list> ::= <identifier> | <identifier list> , <identifier>
        <procedure body> ::= <statement> | <code>

      <statement> ::= <unconditional statement> | <conditional statement> | <for statement>
       <unconditional statement> ::= <basic statement> | <compound statement> | <block>
        <basic statement> ::= <unlabelled basic statement> | <label>: <basic statement>
         <label> ::= <identifier> | <unsigned integer>
         <unlabelled basic statement> ::= <assignment statement> | <go to statement> | <dummy statement> | <procedure statement>
          <assignment statement> ::= <left part list> <arithmetic expression> | <left part list> <Boolean expression>
           <left part list> ::= <left part> | <left part list> <left part>
            <left part> ::= <variable> := | <procedure identifier> :=
          <go to statement> ::= ′GOTO′ <designational expression>
           <designational expression> ::= <simple designational expression> |
                                          <if clause> <simple designational expression> ′ELSE′ <designational expression>
           <simple designational expression> ::= <label> | <switch designator> | (<designational expression>)
            <switch designator> ::= <switch identifier> [<subscript expression>]
          <dummy statement> ::= <empty>
          <procedure statement> ::= <procedure identifier> <actual parameter part>
           <actual parameter part> ::= <empty> | ( <actual parameter list> )
            <actual parameter list> ::= <actual parameter> | <actual parameter list> <parameter delimiter> <actual parameter>
             <parameter delimiter> ::= , | ) <letter string> : (
             <actual parameter> ::= <string> | <expression> | <array identifier> | <switch identifier> | <procedure identifier>
       <conditional statement> ::= <if statement> | <if statement> ′ELSE′ <statement> | <if clause> <for statement> | <label>: <conditional statement>
        <if statement> ::= <if clause> <unconditional statement>
         <if clause> ::= ′IF′ <Boolean expression> ′THEN′
       <for statement> ::= <for clause> <statement> | <label>: <for statement>
        <for clause> ::= ′FOR′ <variable> := <for list> ′DO′
         <for list> ::= <for list element> | <for list> , <for list element>
          <for list element> ::= <arithmetic expression> |
                                 <arithmetic expression> ′STEP′ <arithmetic expression> ′UNTIL′ <arithmetic expression> |
                                 <arithmetic expression> ′WHILE′ <Boolean expression>

      <expression> ::= <arithmetic expression> | <Boolean expression> | <designational expression>
       <arithmetic expression> ::= <simple arithmetic expression> | <if clause> <simple arithmetic expression> ′ELSE′ <arithmetic expression>
        <simple arithmetic expression> ::= <term> | <adding operator> <term> | <simple arithmetic expression> <adding operator> <term>
         <adding operator> ::= + | -
         <term> ::= <factor> | <term> <multiplying operator> <factor>
          <multiplying operator> ::= * | / | ÷
          <factor> ::= <primary> | <factor> | <factor> ′POWER′ <primary>
           <primary> ::= <unsigned number> | <variable> | <function designator> | ( <arithmetic expression> )
            <unsigned number> ::= <decimal number> | <exponential part> | <decimal number> <exponential part>
             <decimal number> ::= <unsigned integer> | <decimal fraction> | <unsigned integer> <decimal fraction>
              <unsigned integer> ::= <digit> | <unsigned integer> <digit>
              <decimal fraction> ::= . <unsigned integer>
             <exponential part> ::= E <integer>
              <integer> ::= <unsigned integer> | + <unsigned integer> | - <unsigned integer>
       <Boolean expression> ::= <simple Boolean> | <if clause> <simple Boolean> ′ELSE′ <Boolean expression>
        <simple Boolean> ::= <implication> | <simple Boolean> ′EQUIV′ <implication>
         <implication> ::= <Boolean term> | <implication> ′IMPL′ <Boolean term>
          <Boolean term> ::= <Boolean factor> | <Boolean term> ′OR′ <Boolean factor>
          <Boolean factor> ::= <Boolean secondary> | <Boolean factor> ′AND′ <Boolean secondary>
           <Boolean secondary> ::= <Boolean primary> | ′NOT′ <Boolean primary>
            <Boolean primary> ::= <logical value> | <variable> | <function designator> | <relation> | ( <Boolean expression> )
             <relation> ::= <simple arithmetic expression> <relational operator> <simple arithmetic expression>
              <relational operator> ::= < | ¾ | = | „ | > | ‚ |
                                        ′LESS′ | ′NOTGREATER′ | ′EQUAL′ | ′NOTLESS′ | ′GREATER′ | ′NOTEQUAL′
             <function designator> ::= <procedure identifier> <actual parameter part>

      <variable> ::= <simple variable> | <subscripted variable>
       <simple variable> ::= <variable identifier>
         <variable identifier> ::= <identifier>
      <subscripted variable> ::= <array identifier> [ <subscript list> ]
       <subscript list> ::= <subscript expression> | <subscript list> , <subscript expression>
        <subscript expression> ::= <arithmetic expression>

      <string> ::= "<open string>"
       <open string> ::= <proper string> "<open string>" | <open string><open string>
       <proper string> ::= <any sequence of symbols not containing " > | <empty>

      <letter string> ::= <letter> | <letter string> <letter>

      <identifier> ::= letter> | <identifier> <letter> | <identifier> <digit>

      <basic symbol> ::= <letter> | <digit> | <logical value> | <delimiter>

      <letter> ::= a | b | c | d | e | f | g | h | i | j | k | l |
                   m | n | o | p | q | r | s | t | u | v | w | x | y | z | A |
                   B | C | D | E | F | G | H | I | J | K | L | M | N | O | P |
                   Q | R | S | T | U | V | W | X | Y | Z
      <digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
      <logical value> ::= ′TRUE′ | ′FALSE′

      <delimiter> ::= <operator> | <separator> | <bracket> | <declarator> | <specificator>

      <operator> ::= <arithmetic operator> | <relational operator> | <logical operator> | <sequential operator>
      <arithmetic operator> ::= + | - | * | / | ÷ | ′POWER′
      <relational operator> ::= < | ¾ | = | „ | > | ‚ |
                                ′LESS′ | ′NOTGREATER′ | ′EQUAL′ | ′NOTLESS′ | ′GREATER′ | ′NOTEQUAL′
      <logical operator> ::= ′EQUIV′ | ′IMPL′ | ′OR′ | ′AND′ | ′NOT′
      <sequential operator> ::= ′GOTO′ | ′IF′ | ′THEN′ | ′ELSE′ | ′FOR′ | ′DO′

      <separator> ::= , | . | E | : | ; | := | _ | ′STEP′ | ′UNTIL′ | ′WHILE′ | ′COMMENT′
      <bracket> ::= ( | ) | [ | ] | ` | ′ | ′BEGIN′ | ′END′
      <declarator> ::= ′OWN′ | ′BOOLEAN′ | ′INTEGER′ | ′REAL′ | ′ARRAY′ | ′SWITCH′ | ′PROCEDURE′
      <specificator> ::= ′STRING′ | ′LABEL′ | ′VALUE′

      ');">: Grammar
    Search in: Google  Google scholar  World Cat  Yahoo  Overture  DBLP  Monash bib  NZ  IEEE  ACM portal  CiteSeer  CSB  ncstrl  jstor  Bookfinder