词条 | ALGOL 68 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
释义 |
| name = ALGOL 68 | logo = Algol68RevisedReportCover.jpg | logo_size = 220 | logo caption = Revised Report on the Algorithmic Language - Algol 68 Edited by: A. van Wijngaarden & al, Sep 1973 | paradigm = multi-paradigm: concurrent, imperative | year = Final Report: 1968r0 | designer = A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck and C.H.A. Koster, et al. | developer = | latest_release_version = Algol 68/RR | latest_release_date = Revised Report: 1973r1 | latest_test_version = | latest_test_date = | typing = static, strong, safe, structural | implementations = ALGOL 68C, Algol 68 Genie (recent), ALGOL 68-R, ALGOL 68RS, ALGOL 68S, FLACC, Алгол 68 Ленинград/Leningrad Unit, Odra ALGOL 68 | dialects = ALGOL 68/FR (Final Reportr0) | influenced_by = ALGOL 60, ALGOL Y | influenced = C,{{refn|Influence on C: types, structures, arrays, pointers and procedures - Dennis Ritchie[1]}}{{refn|Influence on C: union, structure, syntax and long precision - Dennis Ritchie[2]}} C++,[1]Bourne shell, KornShell, Bash, Steelman, Ada, Python,[2] Seed7, Mary, S3}}{{SpecialChars | alt = Decimal Exponent Symbol | link = http://mailcom.com/unicode/DecimalExponent.ttf | special = Unicode 6.0 "[https://www.unicode.org/charts/PDF/U2300.pdf Miscellaneous Technical]" characters | fix = Unicode#External_links | characters = something like "₁₀" (Decimal Exponent Symbol U+23E8 TTF) }} ALGOL 68 (short for Algorithmic Language 1968) is an imperative computer programming language that was conceived as a successor to the ALGOL 60 programming language, designed with the goal of a much wider scope of application and more rigorously defined syntax and semantics. The contributions of ALGOL 68 to the field of computer science have been deep, wide ranging and enduring, although many of these contributions were only publicly identified when they had reappeared in subsequently developed programming languages. OverviewALGOL 68 features include expression-based syntax, user-declared types and structures/tagged-unions, a reference model of variables and reference parameters, string, array and matrix slicing, and also concurrency. ALGOL 68 was designed by the IFIP Working Group 2.1. On December 20, 1968, the language was formally adopted by Working Group 2.1 and subsequently approved for publication by the General Assembly of IFIP. ALGOL 68 was defined using a two-level grammar formalism invented by Adriaan van Wijngaarden. Van Wijngaarden grammars use a context-free grammar to generate an infinite set of productions that will recognize a particular ALGOL 68 program; notably, they are able to express the kind of requirements that in many other programming language standards are labelled "semantics" and have to be expressed in ambiguity-prone natural language prose, and then implemented in compilers as ad hoc code attached to the formal language parser.
ALGOL 68 has been criticized, most prominently by some members of its design committee such as C. A. R. Hoare and Edsger Dijkstra, for abandoning the simplicity of ALGOL 60, becoming a vehicle for complex or overly general ideas, and doing little to make the compiler writer's task easier, in contrast to deliberately simple contemporaries (and competitors) such as C, S-algol and Pascal. In 1970, ALGOL 68-R became the first working compiler for ALGOL 68. In the 1973 revision, certain features – such as proceduring, [https://groups.google.com/group/comp.lang.misc/msg/03af5063e1662d4d gommas] and formal bounds – were omitted.[8] C.f. The language of the unrevised report.r0 Though European defence agencies (in Britain Royal Signals and Radar Establishment – RSRE) promoted the use of ALGOL 68 for its expected security advantages, the American side of the NATO alliance decided to develop a different project, the Ada programming language, making its use obligatory for US defense contracts. Algol 68 also had a notable influence within the Soviet Union, details of which can be found in Andrey Ershov's 2014 paper: "ALGOL 68 and Its Impact on the USSR and Russian Programming" and "Алгол 68 и его влияние на программирование в СССР и России" - pages: 336 & 342. Steve Bourne, who was on the Algol 68 revision committee, took some of its ideas to his Bourne shell (and thereby, to descendant shells such as Bash) and to C (and thereby to descendants such as C++). The complete history of the project can be found in C.H. Lindsey's A History of ALGOL 68.[9] For a full-length treatment of the language, see Programming Algol 68 Made Easy[10] by Dr. Sian Mountbatten, or Learning Algol 68 Genie by Dr. Marcel van der Veer which includes the Revised Report. Timeline of ALGOL 68
The Algorithmic Language ALGOL 68 Reports
Timeline of standardization1968: On December 20, 1968, the "Final Report" (MR 101) was adopted by the Working Group, then subsequently approved by the General Assembly of UNESCO's IFIP for publication. Translations of the standard were made for Russian, German, French and Bulgarian, and then later Japanese and Chinese.[16] The standard was also made available in Braille. 1984: TC97 considered Algol 68 for standardisation as "New Work Item" TC97/N1642 {{Dead link|date=September 2018 |bot=InternetArchiveBot |fix-attempted=yes }}. West Germany, Belgium, Netherlands, USSR and Czechoslovakia willing to participate in preparing the standard but the USSR and Czechoslovakia "were not the right kinds of member of the right ISO committees" and Algol 68's ISO standardisation stalled. 1988: Subsequently ALGOL 68 became one of the GOST standards in Russia.
Notable language elementsBold symbols and reserved wordsThere are about 60 such reserved words (some with "brief symbol" equivalents) in the standard language: '''mode''', '''op''', '''prio''', '''proc''', '''flex''', '''heap''', '''loc''', '''long''', '''ref''', '''short''', '''bits''', '''bool''', '''bytes''', '''char''', '''compl''', '''int''', '''real''', '''sema''', '''string''', '''void''', '''channel''', '''file''', '''format''', '''struct''', '''union''', '''at''' "@", '''either'''r0, '''is''' ":=:", '''isnt''' '''is not'''r0 ":/=:" ":≠:", '''of''' "→"r0, '''true''', '''false''', '''empty''', '''nil''' "○", '''skip''' "~", '''co''' "¢", '''comment''' "¢", '''pr''', '''pragmat''', '''case''' ~ '''in''' ~ '''ouse''' ~ '''in''' ~ '''out''' ~ '''esac''' "( ~ | ~ |: ~ | ~ | ~ )", '''for''' ~ '''from''' ~ '''to''' ~ '''by''' ~ '''while''' ~ '''do''' ~ '''od''', '''if''' ~ '''then''' ~ '''elif''' ~ '''then''' ~ '''else''' ~ '''fi''' "( ~ | ~ |: ~ | ~ | ~ )", '''par''' '''begin''' ~ '''end''' "( ~ )", '''go to''', '''goto''', '''exit''' "."r0. Units: ExpressionsThe basic language construct is the unit. A unit may be a formula, an enclosed clause, a routine text or one of several technically needed constructs (assignation, jump, skip, nihil). The technical term enclosed clause unifies some of the inherently bracketing constructs known as block, do statement, switch statement in other contemporary languages. When keywords are used, generally the reversed character sequence of the introducing keyword is used for terminating the enclosure, e.g. ( if ~ then ~ else ~ fi, case ~ in ~ out ~ esac, for ~ while ~ do ~ od ). This Guarded Command syntax was reused by Stephen Bourne in the common Unix Bourne shell. An expression may also yield a multiple value, which is constructed from other values by a collateral clause. This construct just looks like the parameter pack of a procedure call. mode: Declarations{{SpecialChars| alt = Decimal Exponent Symbol | link = http://mailcom.com/unicode/DecimalExponent.ttf | special = Unicode 6.0 "[https://www.unicode.org/charts/PDF/U2300.pdf Miscellaneous Technical]" characters | fix = Unicode#External_links | characters = something like "₁₀" (Decimal Exponent Symbol U+23E8 TTF) }} The basic data types (called modes in Algol 68 parlance) are real, int, compl (complex number), bool, char, bits and bytes. For example: '''int''' n = 2; '''co''' n is fixed as a constant of 2. '''co''' '''int''' m := 3; '''co''' m is a newly created local ''variable'' whose value is initially set to 3. '''co''' '''co''' This is short for ref int m = loc int := 3; '''co''' '''real''' avogadro = 6.0221415⏨23; '''co''' Avogadro's number '''co''' '''long long real''' long long pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510; '''compl''' square root of minus one = 0 ⊥ 1; However, the declaration real x; is just syntactic sugar for ref real x = loc real;. That is, x is really the constant identifier for a reference to a newly generated local real variable. Furthermore, instead of defining both All variables need to be declared, the declaration does not have to appear prior to the first use. primitive-declarer: int, real, compl, complexG, bool, char, string, bits, bytes, format, file, pipeG, channel, sema
Complex types can be created from simpler ones using various type constructors:
For some examples, see Comparison of ALGOL 68 and C++. Other declaration symbols include: flex, heap, loc, ref, long, short, eventS
A name for a mode (type) can be declared using a mode declaration, which is similar to typedef in C/C++ and type in Pascal: '''int''' max=99; '''mode''' newmode = [0:9][0:max]'''struct''' ( '''long''' '''real''' a, b, c, '''short''' '''int''' i, j, k, '''ref''' '''real''' r ); This is similar to the following C code: Note that for ALGOL 68 only the newmode mode-indication appears to the left of the equals symbol, and most notably the construction is made - and can be read - from left to right without regard to priorities. Note also that the lower bound of Algol 68 arrays is one by default, but can be any integer from -max int to max int. Mode declarations allow types to be recursive: defined directly or indirectly in terms of themselves. This is subject to some restrictions - for instance, these declarations are illegal: '''mode''' A = '''ref''' A '''mode''' A = '''struct''' (A a, B b) '''mode''' A = '''proc''' (A a) A while these are valid: '''mode''' A = '''struct''' ('''ref''' A a, B b) '''mode''' A = '''proc''' ('''ref''' A a) '''ref''' A Coercions: castingThe coercions produce a coercee from a coercend according to three criteria: the a priori mode of the coercend before the application of any coercion, the a posteriori mode of the coercee required after those coercions, and the syntactic position or "sort" of the coercee. Coercions may be cascaded. There are six possible coercions, termed "deproceduring", "dereferencing", "uniting", "widening", "rowing" and "voiding". Each coercion, except for "uniting", prescribes a corresponding dynamic effect on the associated values. Hence, a number of primitive actions can be programmed implicitly by coercions. Context strength – allowed coercions:
Coercion hierarchy with examplesALGOL 68 has a hierarchy of contexts which determine which kind of coercions are available at a particular point in the program. These contexts are:
For more details about Primaries, Secondaries, Tertiary & Quaternaries refer to Operator precedence. pr & co: Pragmats and CommentsPragmats are directives in the program, typically hints to the compiler; in newer languages these are called "pragmas" (no 't'). e.g. '''pragmat''' heap=32 '''pragmat''' '''pr''' heap=32 '''pr''' Comments can be inserted in a variety of ways: ¢ The original way of adding your 2 cents worth to a program ¢ '''comment''' "bold" comment '''comment''' '''co''' Style i comment '''co''' # Style ii comment # £ This is a hash/pound comment for a UK keyboard £ Normally, comments cannot be nested in ALGOL 68. This restriction can be circumvented by using different comment delimiters (e.g. use hash only for temporary code deletions). Expressions and compound statementsALGOL 68 being an expression-oriented programming language, the value returned by an assignment statement is a reference to the destination. Thus, the following is valid ALGOL 68 code: This notion is present in C and Perl, among others. Note that as in earlier languages such as Algol 60 and FORTRAN, spaces are allowed in identifiers, so that As another example, to express the mathematical idea of a sum of Note that, being an integer expression, the former block of code can be used in any context where an integer value can be used. A block of code returns the value of the last expression it evaluated; this idea is present in Lisp, among other languages. Compound statements are all terminated by distinctive closing brackets:
'''if''' condition1 '''then''' statements '''elif''' condition2 '''then''' statements [ '''else''' statements ] '''fi''' "brief" form: ( condition1 | statements |: condition2 | statements | statements ) This scheme not only avoids the dangling else problem but also avoids having to use
'''case''' switch1 '''in''' statements, statements,... '''ouse''' switch2 '''in''' statements, statements,... [ '''out''' statements ] '''esac''' "brief" form of '''case''' statement: ( switch1 | statements,statements,... |: switch2 | statements,statements,... | statements ) Choice clause example with Brief symbols: '''proc''' days in month = ('''int''' year, month)'''int''': (month| 31, (year÷×4=0 ∧ year÷×100≠0 ∨ year÷×400=0 | 29 | 28 ), 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ); Choice clause example with Bold symbols: '''proc''' days in month = ('''int''' year, month)'''int''': '''case''' month '''in''' 31, '''if''' year '''mod''' 4 '''eq''' 0 '''and''' year '''mod''' 100 '''ne''' 0 '''or''' year '''mod''' 400 '''eq''' 0 '''then''' 29 '''else''' 28 '''fi''', 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 '''esac'''; Choice clause example mixing Bold and Brief symbols: '''proc''' days in month = ('''int''' year, month)'''int''': '''case''' month '''in''' ¢Jan¢ 31, ¢Feb¢ ( year '''mod''' 4 = 0 '''and''' year '''mod''' 100 ≠ 0 '''or''' year '''mod''' 400 = 0 | 29 | 28 ), ¢Mar¢ 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ¢ to Dec. ¢ '''esac'''; Algol68 allowed the switch to be of either type int or (uniquely) union. The latter allows the enforcing strong typing onto union variables. c.f. union below for example.
This was considered the "universal" loop, the full syntax is: There are several unusual aspects of the construct:
Subsequent "extensions" to the standard Algol68 allowed the to syntactic element to be replaced with upto and downto to achieve a small optimisation. The same compilers also incorporated:
Further examples can be found in the code examples below. struct, union & [:]: Structures, unions and arraysALGOL 68 supports arrays with any number of dimensions, and it allows for the slicing of whole or partial rows or columns. '''mode''' '''vector''' = [1:3] '''real'''; ''# vector '''mode''' declaration (typedef) #'' '''mode''' '''matrix''' = [1:3,1:3]'''real'''; ''# matrix '''mode''' declaration (typedef) #'' '''vector''' v1 := (1,2,3); ''# array variable initially (1,2,3) #'' []'''real''' v2 = (4,5,6); ''# constant array, type equivalent to '''vector''', bounds are implied #'' '''op''' + = ('''vector''' a,b) '''vector''': ''# binary '''op'''erator definition #'' ('''vector''' out; '''for''' i '''from''' ⌊a '''to''' ⌈a '''do''' out[i] := a[i]+b[i] '''od'''; out); '''matrix''' m := (v1, v2, v1+v2); print ((m[,2:])); ''# a slice of the 2nd and 3rd columns #'' Matrices can be sliced either way, e.g.: '''ref''' '''vector''' row = m[2,]; ''# define a '''ref''' (pointer) to the 2nd row #'' '''ref''' '''vector''' col = m[,2]; ''# define a '''ref''' (pointer) to the 2nd column #'' ALGOL 68 supports multiple field structures (struct) and united modes. Reference variables may point to any mode including array slices and structure fields. For an example of all this, here is the traditional linked list declaration: '''mode''' '''node''' = '''union''' ('''real''', '''int''', '''compl''', '''string'''), '''list''' = '''struct''' ('''node''' val, '''ref''' '''list''' next); Usage example for union case of node:
proc: ProceduresProcedure (proc) declarations require type specifications for both the parameters and the result (void if none): '''proc''' max of real = ('''real''' a, b) '''real''': '''if''' a > b '''then''' a '''else''' b '''fi'''; or, using the "brief" form of the conditional statement: The return value of a '''proc''' apply = ('''ref''' [] '''real''' a, '''proc''' ('''real''') '''real''' f): '''for''' i '''from''' '''lwb''' a '''to''' '''upb''' a '''do''' a[i] := f(a[i]) '''od''' This simplicity of code was unachievable in ALGOL 68's predecessor ALGOL 60. op: OperatorsThe programmer may define new operators and both those and the pre-defined ones may be overloaded and their priorities may be changed by the coder. The following example defines operator '''prio''' '''max''' = 9; '''op''' '''max''' = ('''int''' a,b) '''int''': ( a>b | a | b ); '''op''' '''max''' = ('''real''' a,b) '''real''': ( a>b | a | b ); '''op''' '''max''' = ('''compl''' a,b) '''compl''': ( '''abs''' a > '''abs''' b | a | b ); '''op''' '''max''' = ([]'''real''' a) '''real''': ('''real''' out := a['''lwb''' a]; '''for''' i '''from''' '''lwb''' a + 1 '''to''' '''upb''' a '''do''' ( a[i]>out | out:=a[i] ) '''od'''; out) Array, Procedure, Dereference and coercion operations
These are technically not operators, rather they are considered "[https://web.archive.org/web/20130101062456/http://jmvdveer.home.xs4all.nl/report.html#52#52 units associated with names]" Monadic operators
Dyadic operators with associated priorities
Note: Tertiaries include names nil and ○. Assignation and identity relations etcThese are technically not operators, rather they are considered "[https://web.archive.org/web/20130101062456/http://jmvdveer.home.xs4all.nl/report.html#052#052 units associated with names]"
Note: Quaternaries include names skip and ~. ":=:" (alternatively "is") tests if two pointers are equal; ":/=:" (alternatively "isnt") tests if they are unequal. Why :=: and :/=: are needed: Consider trying to compare two pointer values, such as the following variables, declared as pointers-to-integer: Now consider how to decide whether these two are pointing to the same location, or whether one of them is pointing to nil. The following expression will dereference both pointers down to values of type int, and compare those, since the "=" operator is defined for int, but not ref int. It is not legal to define "=" for operands of type ref int and int at the same time, because then calls become ambiguous, due to the implicit coercions that can be applied: should the operands be left as ref int and that version of the operator called? Or should they be dereferenced further to int and that version used instead? Therefore the following expression can never be made legal: Hence the need for separate constructs not subject to the normal coercion rules for operands to operators. But there is a gotcha. The following expressions: while legal, will probably not do what might be expected. They will always return false, because they are comparing the actual addresses of the variables Patent application: On 14 May 2003, software patent application No. 20040230959[19] was filed for the Special charactersMost of Algol's "special" characters (⊂, ≡, ␣, ×, ÷, ≤, ≥, ≠, ¬, ⊃, ≡, ∨, ∧, →, ↓, ↑, ⌊, ⌈, ⎩, ⎧, ⊥, ⏨, ¢, ○ and □) can be found on the IBM 2741 keyboard with the APL "golf-ball" print head inserted; these became available in the mid-1960s while ALGOL 68 was being drafted. These characters are also part of the Unicode standard and most of them are available in several popular fonts. transput: Input and outputTransput is the term used to refer to ALGOL 68's input and output facilities. There are pre-defined procedures for unformatted, formatted and binary transput. Files and other transput devices are handled in a consistent and machine-independent manner. The following example prints out some unformatted output to the standard output device: print ((newpage, "Title", newline, "Value of i is ", i, "and x[i] is ", x[i], newline)) Note the predefined procedures Books, channels and filesThe transput is considered to be of books, channels and files:
formatted transput"Formatted transput" in ALGOL 68's transput has its own syntax and patterns (functions), with formats embedded between two $ characters.[20] Examples: printf (($2l"The sum is:"x, g(0)$, m + n)); ¢ prints the same as: ¢ print ((new line, new line, "The sum is:", space, whole (m + n, 0)) par: Parallel processingALGOL 68 supports programming of parallel processing. Using the keyword par, a collateral clause is converted to a parallel clause, where the synchronisation of actions is controlled using semaphores. In A68G the parallel actions are mapped to threads when available on the hosting operating system. In A68S a different paradigm of parallel processing was implemented (see below). '''int''' initial foot width = 5; '''mode''' '''foot''' = '''struct'''( '''string''' name, '''sema''' width, '''bits''' toe ¢ packed vector of BOOL ¢ ); '''foot''' left foot:= '''foot'''("Left", '''level''' initial foot width, 2r11111), right foot:= '''foot'''("Right", '''level''' initial foot width, 2r11111); ¢ 10 round clip in a 1968 Colt Python .357 Magnum ¢ '''sema''' rounds = '''level''' 10; ¢ the Magnum needs more barrels to take full advantage of parallelism ¢ '''sema''' acquire target = '''level''' 1; '''prio''' ∧:= = 1; '''op''' ∧:= = ('''ref''' '''bits''' lhs, '''bits''' rhs)'''ref''' '''bits''': lhs := lhs ∧ rhs; '''proc''' shoot = ('''ref''' '''foot''' foot)'''void''': ( ↓acquire target; ↓rounds; print("BANG! "); ↓width → foot; toe → foot ∧:= ¬('''bin''' 1 '''shl''' '''level''' width → foot); printf(($g": Ouch!! - "5(g)l$, name → foot, []'''bool'''(toe → foot)[bits width - initial foot width + 1:])); ↑acquire target ); ¢ do shooting in parallel to cater for someone hoping to stand on just one foot ¢ '''par''' ( '''for''' toe '''to''' initial foot width '''do''' shoot(left foot) '''od''', ¢ <= a comma is required ¢ '''for''' toe '''to''' initial foot width '''do''' shoot(right foot) '''od''' ) Examples of useCode sampleThis sample program implements the Sieve of Eratosthenes to find all the prime numbers that are less than 100. nil is the ALGOL 68 analogue of the null pointer in other languages. The notation x of y accesses a member x of a struct y. '''begin''' # Algol-68 prime number sieve, functional style # '''proc''' error = ('''string''' s) '''void''': (print(( newline, " error: ", s, newline)); '''goto''' stop); '''proc''' one to = ('''int''' n) '''list''': ('''proc''' f = ('''int''' m,n) '''list''': (m>n | '''nil''' | cons(m, f(m+1,n))); f(1,n)); '''mode''' '''list''' = '''ref''' '''node'''; '''mode''' '''node''' = '''struct''' ('''int''' h, '''list''' t); '''proc''' cons = ('''int''' n, '''list''' l) '''list''': '''heap''' '''node''' := (n,l); '''proc''' hd = ('''list''' l) '''int''': ( l '''is''' '''nil''' | error("hd '''nil'''"); '''skip''' | h '''of''' l ); '''proc''' tl = ('''list''' l) '''list''': ( l '''is''' '''nil''' | error("tl '''nil'''"); '''skip''' | t '''of''' l ); '''proc''' show = ('''list''' l) '''void''': ( l '''isnt''' '''nil''' | '''print'''((" ",whole(hd(l),0))); show(tl(l))); '''proc''' filter = ('''proc''' ('''int''') '''bool''' p, '''list''' l) '''list''': '''if''' l '''is''' '''nil''' '''then''' '''nil''' '''elif''' p(hd(l)) '''then''' cons(hd(l), filter(p,tl(l))) '''else''' filter(p, tl(l)) '''fi'''; '''proc''' sieve = ('''list''' l) '''list''': '''if''' l '''is''' '''nil''' '''then''' '''nil''' '''else''' '''proc''' not multiple = ('''int''' n) '''bool''': n '''mod''' hd(l) ≠ 0; cons(hd(l), sieve( filter( not multiple, tl(l) ))) '''fi'''; '''proc''' primes = ('''int''' n) '''list''': sieve( tl( one to(n) )); show( primes(100) ) '''end''' Operating systems written in ALGOL 68
Note: The Soviet Era computers Эльбрус-1 (Elbrus-1) and Эльбрус-2 were created using high-level language Эль-76 (AL-76), rather than the traditional assembly. Эль-76 resembles Algol-68, The main difference is the dynamic binding types in Эль-76 supported at the hardware level. Эль-76 is used for application, job control, system programming.[24] ApplicationsBoth ALGOL 68C and ALGOL 68-R are written in ALGOL 68, effectively making ALGOL 68 an application of itself. Other applications include:
Libraries and APIs
Program representationA feature of ALGOL 68, inherited from the ALGOL tradition, is its different representations. There is a representation language used to describe algorithms in printed work, a strict language (rigorously defined in the Report) and an official reference language intended to be used in actual compiler input. In the examples you will observe bold typeface words, this is the strict language. ALGOL 68's reserved words are effectively in a different namespace from identifiers, and spaces are allowed in identifiers, so this next fragment is legal: The programmer who actually writes code does not always have an option of bold typeface or underlining in the code as this may depend on hardware and cultural issues. So different methods to denote these identifiers have been devised. This is called a stropping regime. For example all or some of the following may be available programming representations: '''int''' a real int = 3; # the '''strict''' language # 'INT'A REAL INT = 3; # QUOTE stropping style # .INT A REAL INT = 3; # POINT stropping style # INT a real int = 3; # UPPER stropping style # int a_real_int = 3; # RES stropping style, there are 61 accepted reserved words # All implementations must recognise at least POINT, UPPER and RES inside PRAGMAT sections. Of these, POINT and UPPER stropping are quite common, while RES stropping is in contradiction to the specification (as there are no reserved words). QUOTE (single apostrophe quoting) was the original recommendation, while matched apostrophe quoting, common in ALGOL 60, is not used much in ALGOL 68.[27] The following characters were recommended for portability, and termed "worthy characters" in the Report on the Standard Hardware Representation of Algol 68:
This reflected a problem in the 1960s where some hardware didn't support lower-case, nor some other non-ASCII characters, indeed in the 1973 report it was written: "Four worthy characters — "|", "_", "[", and "]" — are often coded differently, even at installations which nominally use the same character set."
Example of different program representations{{CompactTable|r1c1= Algol68 "strict" as typically published |r2c1={{pre|1= ¢ underline or bold typeface ¢ '''mode''' '''xint''' = '''int'''; '''xint''' sum sq:=0; '''for''' i '''while''' sum sq≠70×70 '''do''' sum sq+:=i↑2 '''od''' }} |r1c2= Quote stropping (like wikitext) |r2c2={{sxhl|2=text|1= 'pr' quote 'pr' 'mode' 'xint' = 'int'; 'xint' sum sq:=0; 'for' i 'while' 'do' 'od' }} |r1c3= For a 7-bit character code compiler |r2c3={{sxhl|2=text|1= .PR UPPER .PR MODE XINT = INT; XINT sum sq:=0; FOR i WHILE DO OD }} |r1c4= For a 6-bit character code compiler |r2c4={{sxhl|2=text|1= .PR POINT .PR .MODE .XINT = .INT; .XINT SUM SQ:=0; .FOR I .WHILE .DO .OD }} |r1c5= Algol68 using res stropping (reserved word) |r2c5={{sxhl|2=text|1= .PR RES .PR mode .xint = int; .xint sum sq:=0; for i while do od }} }} ALGOL 68 allows for every natural language to define its own set of keywords Algol-68. As a result, programmers are able to write programs using keywords from their native language. Below is an example of a simple procedure that calculates "the day following", the code is in two languages: English and German.{{Citation needed|date=August 2011}} # Next day date - English variant # '''mode''' '''date''' = '''struct'''('''int''' day, '''string''' month, '''int''' year); '''proc''' the day following = ('''date''' x) '''date''': '''if''' day '''of''' x < length of month (month '''of''' x, year '''of''' x) '''then''' (day '''of''' x + 1, month '''of''' x, year '''of''' x) '''elif''' month '''of''' x = "December" '''then''' (1, "January", year '''of''' x + 1) '''else''' (1, successor of month (month '''of''' x), year '''of''' x) '''fi'''; # Nachfolgetag - Deutsche Variante # '''menge''' '''datum''' = '''tupel'''('''ganz''' tag, '''wort''' monat, '''ganz''' jahr); '''funktion''' naechster tag nach = ('''datum''' x) '''datum''': '''wenn''' tag '''von''' x < monatslaenge(monat '''von''' x, jahr '''von''' x) '''dann''' (tag '''von''' x + 1, monat '''von''' x, jahr '''von''' x) '''wennaber''' monat '''von''' x = "Dezember" '''dann''' (1, "Januar", jahr '''von''' x + 1) '''ansonsten''' (1, nachfolgemonat(monat '''von''' x), jahr '''von''' x) '''endewenn''';Russian/Soviet example: In English Algol68's case statement reads case ~ in ~ out ~ esac, in Cyrillic this reads выб ~ в ~ либо ~ быв. Some VanitasFor its technical intricacies, ALGOL 68 needs a cornucopia of methods to deny the existence of something: '''skip''', "~" or "?"C - an undefined value always syntactically valid, '''empty''' - the only value admissible to '''void''', needed for selecting '''void''' in a '''union''', '''void''' - syntactically like a '''mode''', but not one, '''nil''' or "○" - a name not denoting anything, of an unspecified reference mode, () or specifically [1:0]'''int''' - a ''vacuum'' is an empty array (here specifically of '''mode''' []'''int'''). ''undefined'' - a standards reports procedure raising an exception in the runtime system. ℵ - Used in the standards report to inhibit introspection of certain types. e.g. '''sema''' c.f. below for other examples of ℵ. The term nil is var always evaluates to true for any variable (but see above for correct use of is :/=:), whereas it is not known to which value a comparison x < skip evaluates for any integer x. ALGOL 68 leaves intentionally undefined what happens in case of integer overflow, the integer bit representation, and the degree of numerical accuracy for floating point. In contrast, the language Java has been criticized for over-specifying the latter. Both official reports included some advanced features that were not part of the standard language. These were indicated with an ℵ and considered effectively private. Examples include "≮" and "≯" for templates, the outtype/intype for crude duck typing, and the straightout and straightin operators for "straightening" nested arrays and structures. Extract from the 1973 report: §10.3.2.2. Transput modes a) '''mode''' ℵ '''simplout''' = '''union''' (≮ℒ '''int'''≯, ≮ℒ '''real'''≯, ≮ℒ '''compl'''≯, '''bool''', ≮ℒ bits≯, '''char''', '''char'''); b) '''mode''' ℵ '''outtype''' = ¢ an actual - declarer specifying a mode united from a sufficient set of modes none of which is 'void' or contains 'flexible', 'reference to', 'procedure' or 'union of' ¢; c) '''mode''' ℵ '''simplin''' = '''union''' (≮'''ref''' ℒ '''int'''≯, ≮'''ref''' ℒ '''real'''≯, ≮'''ref''' ℒ '''compl'''≯, '''ref''' '''bool''', ≮'''ref''' ℒ '''bits'''≯, '''ref''' '''char''', '''ref''' '''char''', '''ref''' '''string'''); d) '''mode''' ℵ '''intype''' = ¢ ... ¢; §10.3.2.3. Straightening a) '''op''' ℵ '''straightout''' = ('''outtype''' x) '''simplout''': ¢ the result of "straightening" 'x' ¢; b) '''op''' ℵ '''straightin''' = ('''intype''' x) '''simplin''': ¢ the result of straightening 'x' ¢; Comparisons with other languages
RevisionsExcept where noted (with a superscript), the language described above is that of the "Revised Report(r1)". The language of the unrevised reportThe original language (As per the "Final Report"r0) differs in syntax of the mode cast, and it had the feature of proceduring, i.e. coercing the value of a term into a procedure which evaluates the term. Proceduring would be intended to make evaluations lazy. The most useful application could have been the short-circuited evaluation of boolean operators. In: '''op''' '''andf''' = ('''bool''' a,'''proc''' '''bool''' b)'''bool''':(a | b | '''false'''); '''op''' '''orf''' = ('''bool''' a,'''proc''' '''bool''' b)'''bool''':(a | '''true''' | b); b is only evaluated if a is true. As defined in ALGOL 68, it did not work as expected, for example in the code: '''if''' '''false''' '''andf''' '''co''' proc bool: '''co''' ( print ("Should not be executed"); '''true''') '''then''' ... against the programmers naïve expectations the print would be executed as it is only the value of the elaborated enclosed-clause after andf that was procedured. Textual insertion of the commented-out proc bool: makes it work. Some implementations emulate the expected behaviour for this special case by extension of the language. Before revision, the programmer could decide to have the arguments of a procedure evaluated serially instead of collaterally by using semicolons instead of commas ([https://groups.google.com/group/comp.lang.misc/msg/03af5063e1662d4d gomma]s). For example in: '''proc''' test = ('''real''' a; '''real''' b) :... ... test (x '''plus''' 1, x); The first argument to test is guaranteed to be evaluated before the second, but in the usual: '''proc''' test = ('''real''' a, b) :... ... test (x '''plus''' 1, x); then the compiler could evaluate the arguments in whatever order it felt like. Extension proposals from IFIP WG 2.1After the revision of the report, some extensions to the language have been proposed to widen the applicability:
So far, only partial parametrisation has been implemented, in Algol 68 Genie. True ALGOL 68s specification and implementation timeline
The S3 language that was used to write the ICL VME operating system and much other system software on the ICL 2900 Series was a direct derivative of Algol 68. However, it omitted many of the more complex features, and replaced the basic modes with a set of data types that mapped directly to the 2900 Series hardware architecture. Implementation specific extensionsALGOL 68R(R) from RRE was the first ALGOL 68 subset implementation, running on the ICL 1900. Based on the original language, the main subset restrictions were definition before use and no parallel processing. This compiler was popular in UK universities in the 1970s, where many computer science students learnt ALGOL 68 as their first programming language; the compiler was renowned for good error messages. ALGOL 68RS(RS) from RSRE was a portable compiler system written in ALGOL 68RS (bootstrapped from ALGOL 68R), and implemented on a variety of systems including the ICL 2900/Series 39, Multics and DEC VAX/VMS. The language was based on the Revised Report, but with similar subset restrictions to ALGOL 68R. This compiler survives in the form of an Algol68-to-C compiler. In ALGOL 68S(S) from Carnegie Mellon University the power of parallel processing was improved by adding an orthogonal extension, eventing. Any variable declaration containing keyword event made assignments to this variable eligible for parallel evaluation, i.e. the right hand side was made into a procedure which was moved to one of the processors of the C.mmp multiprocessor system. Accesses to such variables were delayed after termination of the assignment. Cambridge ALGOL 68C(C) was a portable compiler that implemented a subset of ALGOL 68, restricting operator definitions and omitting garbage collection, flexible rows and formatted transput. Algol 68 Genie(G) by M. van der Veer is an ALGOL 68 implementation for today's computers and operating systems. "Despite good intentions, a programmer may violate portability by inadvertently employing a local extension. To guard against this, each implementation should provide a PORTCHECK pragmat option. While this option is in force, the compiler prints a message for each construct that it recognizes as violating some portability constraint."[36] Quotes
See also{{col-begin}}{{col-3}}
References1. ^{{cite web |url=http://www.research.att.com/~bs/hopl2.pdf|at=Page 12, 2nd paragraph: Algol68 [gave] operator overloading(§3.3.3), references (§3.3.4), and the ability to declare variables anywhere in a block (§3.3.1)|title=A History of C++: 1979−1991|date=March 1993 |accessdate=May 6, 2008}} {{Refbegin}}2. ^{{cite web|url=http://www.amk.ca/python/writing/gvr-interview |title=Interview with Guido van Rossum |date=July 1998 |accessdate=April 29, 2007 |archiveurl=https://web.archive.org/web/20070501105422/http://www.amk.ca/python/writing/gvr-interview |archivedate=1 May 2007 |deadurl=yes }} 3. ^Completeness and clarity of description {{webarchive |url=https://web.archive.org/web/20130317015548/http://jmvdveer.home.xs4all.nl/report.html#011 |date=March 17, 2013 }} 4. ^Orthogonal design {{webarchive |url=https://web.archive.org/web/20130317015548/http://jmvdveer.home.xs4all.nl/report.html#012 |date=March 17, 2013 }} 5. ^Security {{webarchive |url=https://web.archive.org/web/20130317015548/http://jmvdveer.home.xs4all.nl/report.html#013 |date=March 17, 2013 }} 6. ^Efficiency {{webarchive |url=https://web.archive.org/web/20130317015548/http://jmvdveer.home.xs4all.nl/report.html#014 |date=March 17, 2013 }} 7. ^{{cite web|title=A Shorter History of Algol68 |url=http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt |accessdate=September 15, 2006 |archiveurl=https://web.archive.org/web/20060810103448/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt |archivedate=August 10, 2006 |deadurl=yes |df= }} 8. ^Revised Report on the Algorithmic Language Algol 68 {{webarchive |url=https://web.archive.org/web/20130317015548/http://jmvdveer.home.xs4all.nl/report.html#03B |date=March 17, 2013 }}. jmvdveer.home.xs4all.nl (1968-12-20). Retrieved on 2013-07-21. 9. ^1 {{cite book | last = Lindsey | first = Charles H. | authorlink = Charles H. Lindsey | title = A History of ALGOL 68 | journal = ACM SIGPLAN Notices | volume = 28 | issue = 3 | pages = 97–132 | publisher = ACM Press | editor = T.J. Bergin & R.G. Gibson | series = History of Programming Languages-II | others = also in ACM SIGPLAN Notices 28(3), March 1993 (includes a comprehensive bibliography of the meetings and discussions before, during and after development of ALGOL 68). | year = 1996 | isbn = 978-0-201-89502-5 | url = https://dl.acm.org/citation.cfm?id=155365| doi = 10.1145/155360.155365 }} 10. ^{{cite web |title=PAME |url=http://www.geocities.com/ernobe |website= |archiveurl=https://www.webcitation.org/5klVUXNat?url=http://www.geocities.com/ernobe |archivedate=2009-10-24 |deadurl=yes |df= }} 11. ^{{cite web|title=Draft Report on the Algorithmic Language ALGOL 68 |url=http://archive.computerhistory.org/resources/text/algol/algol_bulletin/AS26/INDEX.HTM |accessdate=June 22, 2007 |date=March 1968 |archiveurl=https://web.archive.org/web/20070930181523/http://archive.computerhistory.org/resources/text/algol/algol_bulletin/AS26/INDEX.HTM |archivedate=September 30, 2007 |deadurl=no |df= }} 12. ^{{cite web|title=Penultimate Draft Report on the Algorithmic Language ALGOL 68 – Chapters 1-9 |url=http://repos.project.cwi.nl:8888/cwi_repository/docs/I/09/9180A.pdf |accessdate=June 22, 2007 |date=October 1968 }}{{dead link|date=November 2016 |bot=InternetArchiveBot |fix-attempted=yes }} 13. ^{{cite web|title=Penultimate Draft Report on the Algorithmic Language ALGOL 68 - Chapters 10-12 |url=http://repos.project.cwi.nl:8888/cwi_repository/docs/I/09/9179A.pdf |accessdate=June 22, 2007 |date=October 1968 }}{{dead link|date=November 2016 |bot=InternetArchiveBot |fix-attempted=yes }} 14. ^{{cite web| title=Report on the Algorithmic Language ALGOL 68 | url=http://www.fh-jena.de/~kleine/history/languages/Algol68-Report.pdf | accessdate=December 30, 2007 |date=December 1968 }} 15. ^{{cite web|title=Revised Report on the Algorithmic Language Algol 68 |url=http://burks.brighton.ac.uk/burks/language/other/a68rr/rrtoc.htm |accessdate=April 30, 2007 |date=September 1973 |archiveurl=https://web.archive.org/web/20070927191700/http://burks.brighton.ac.uk/burks/language/other/a68rr/rrtoc.htm |archivedate=September 27, 2007 |deadurl=no |df= }} 16. ^{{cite web |url=http://archive.computerhistory.org/resources/text/algol/ACM_Algol_bulletin/1061739/p33-ru_ian.pdf| title=The Translation of Algol 68 into Chinese.|author=Lu Hu-quan | year=1971 | publisher=Institute of Mathematics, Academia Sinica - Peking, China | accessdate=August 17, 2012}} 17. ^{{cite web| url=http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf | title=GOST 27974-88 Programming language ALGOL 68 - Язык программирования АЛГОЛ 68 | language=Russian | year=1988 | publisher=GOST | accessdate=November 15, 2008 | archiveurl= https://web.archive.org/web/20081115035038/http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf| archivedate= 15 November 2008 | deadurl= no}} 18. ^{{cite web | url=http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27975-88.pdf | title=GOST 27975-88 Programming language ALGOL 68 extended - Язык программирования АЛГОЛ 68 расширенный | language=Russian | year=1988 | publisher=GOST | accessdate=November 15, 2008 }} 19. ^"IS NOT OPERATOR" - {{US patent application|20040230959}} 20. ^Format syntax in ALGOL 68G {{webarchive |url=https://web.archive.org/web/20080109161728/http://www.xs4all.nl/~jmvdveer/syntax.html#formats |date=January 9, 2008 }} 21. ^{{Cite journal | url=http://research.microsoft.com/pubs/72418/cap.pdf | title=The Cambridge CAP Computer and its Operating System| journal=Microsoft Research| date=January 1979| last1=Needham| first1=R. M.| last2=Wilkes| first2=M. V.}} 22. ^{{cite web|title=KDF9 Time Sharing: Eldon 2 is not EGDON! |url=http://www.cs.man.ac.uk/CCS/res/res49.htm#e|author=David Holdsworth |date=Winter 2009–2010 |work=Computer Resurrection - Number 49 |publisher=Computer Conservation Society |accessdate=October 3, 2010}} 23. ^http://www.vitanuova.com/dist/doc/rsre-3522-curt.pdf 24. ^Эльбрус Бабаяна и Pentium Пентковского. Ixbt.com. Retrieved on 2013-07-21. 25. ^{{cite journal | title = Practical experience with ALGOL 68-RT | journal = The Computer Journal | year = 1979 | first = J. R. | last = Oliver |author2=Newton, R.S. | volume = 22 | issue = 2 | pages = 114–118| id = | url = http://comjnl.oxfordjournals.org/content/22/2/114.full.pdf | accessdate = 2011-04-09 | doi=10.1093/comjnl/22.2.114}} 26. ^Applications, libraries, and test suites — Software Preservation Group. Softwarepreservation.org. Retrieved on 2013-07-21. 27. ^Revised Report, page 123, footnote 28. ^http://dare.ubvu.vu.nl/bitstream/1871/2609/1/11054.pdf 29. ^{{cite journal|title=A Modules and Separate Compilation facility for ALGOL 68 |journal=ALGOL Bulletin |date=Dec 1978 |first=C.H. |last=Lindsey |last2=Boom, H.J. |issue=43 |url=http://0-portal.acm.org.millennium.lib.cyut.edu.tw/citation.cfm?id=1061724 |accessdate=2011-05-05 |doi=10.1145/1061719.1061724 |doi-broken-date=2019-03-11 }}{{dead link|date=November 2016 |bot=InternetArchiveBot |fix-attempted=yes }} 30. ^{{cite web|url=http://www.80bus.co.uk/publications/magazines/LSG3.pdf |title=Archived copy |accessdate=2010-03-20 |deadurl=yes |archiveurl=https://web.archive.org/web/20100415194813/http://www.80bus.co.uk/publications/magazines/LSG3.pdf |archivedate=2010-04-15 |df= }} 31. ^http://htportal.acm.org/ft_gateway.cfm?id=803425&type=pdf{{dead link|date=October 2016 |bot=InternetArchiveBot |fix-attempted=yes }} 32. ^An abstract ALGOL 68 machine and its application in a machine independent compiler - Springer. Springerlink.com. Retrieved on 2013-07-21. 33. ^{{cite web|url=http://hopl.murdoch.edu.au/showlanguage2.prx?exp%3D4351 |title=Archived copy |accessdate=2010-03-20 |deadurl=yes |archiveurl=https://web.archive.org/web/20110310110439/http://hopl.murdoch.edu.au/showlanguage2.prx?exp=4351 |archivedate=2011-03-10 |df= }} 34. ^Open source Algol 68 implementations - Browse Files at. Sourceforge.net. Retrieved on 2013-07-21. 35. ^ {{webarchive |url=https://web.archive.org/web/20060829235643/http://www.nunan.fsnet.co.uk/algol68/a68mk2.zip |date=August 29, 2006 }} 36. ^http://www.fh-jena.de/~kleine/history/languages/Algol68-RR-HardwareRepresentation.pdf 37. ^1 {{cite web|title=The Development of the C Language |author=Dennis Ritchie |date=April 1993 |url=http://cm.bell-labs.com/cm/cs/who/dmr/chist.pdf |accessdate=April 26, 2007 |deadurl=yes |archiveurl=http://wayback.vefsafn.is/wayback/20051106120954/http://cm.bell-labs.com/cm/cs/who/dmr/chist.pdf |archivedate=November 6, 2005 |df= }} 38. ^1 {{cite web | title = C and Algol 68| url = http://groups.google.co.uk/group/comp.lang.misc/browse_thread/thread/1e6d4bb30659b78d/f57b6f5c81502cf5 | author=Dennis Ritchie|date=June 1988| accessdate = September 15, 2006 }} 39. ^{{cite journal | title = The Making of Algol 68 | author=C.H.A. Koster| year=1993 | citeseerx=10.1.1.76.2072}} 40. ^{{cite web | title = To the EDITOR ALGOL 68 Mathematische Centrum | author=E.W. Dijkstra| url = http://www.cs.utexas.edu/users/EWD/transcriptions/EWD02xx/EWD230.html | accessdate = April 28, 2007 | archiveurl= https://web.archive.org/web/20070421193554/http://www.cs.utexas.edu/users/EWD/transcriptions/EWD02xx/EWD230.html| archivedate= 21 April 2007 | deadurl= no}} 41. ^{{cite web | title = Python-Dev Wishlist: dowhile | author= Guido van Rossum |date=June 2005 | url=http://mail.python.org/pipermail/python-dev/2005-June/054225.html | accessdate = April 28, 2007 }} 42. ^{{cite journal |last=Hoare |first=C. A. R. |title=The emperor's old clothes |origyear=based on his 1980 Turing Award Lecture |journal=Communications of the ACM |volume=24 |issue=2 |date=February 1981 |pages=75–83 |url=http://cacm.acm.org/magazines/1981/2/10949-the-emperors-old-clothes/abstract |archiveurl=http://zoo.cs.yale.edu/classes/cs422/2011/bib/hoare81emperor.pdf |archivedate=2010-01-07 |doi=10.1145/358549.358561}} 43. ^{{cite web|title=ALGOL Bulletin (referred to in AB30.1.1.1) |date=March 1970 |url=http://archive.computerhistory.org/resources/text/algol/algol_bulletin/A31/P111.HTM |accessdate=March 1, 2007 |archiveurl=https://web.archive.org/web/20070930230048/http://archive.computerhistory.org/resources/text/algol/algol_bulletin/A31/P111.HTM |archivedate=September 30, 2007 |deadurl=no |df= }}
External links
10 : ALGOL 68|Algol programming language family|Academic programming languages|Articles with example ALGOL 68 code|Computer-related introductions in 1968|Procedural programming languages|Programming languages created in 1968|Systems programming languages|Programming languages|1968 software |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
随便看 |
|
开放百科全书收录14589846条英语、德语、日语等多语种百科知识,基本涵盖了大多数领域的百科知识,是一部内容自由、开放的电子版国际百科全书。