{"id":11229,"date":"2025-07-21T01:01:00","date_gmt":"2025-07-21T05:01:00","guid":{"rendered":"https:\/\/www.both.org\/?p=11229"},"modified":"2025-07-17T09:39:02","modified_gmt":"2025-07-17T13:39:02","slug":"an-algol-68-pretty-printer","status":"publish","type":"post","link":"https:\/\/www.both.org\/?p=11229","title":{"rendered":"An Algol 68 Pretty Printer"},"content":{"rendered":"
\r\n
\r\n \r\n <\/i>\r\n <\/a>\r\n 1 <\/span>\r\n<\/div><\/div>\n


For Marcel van der Veer<\/em>, with many thanks for Algol 68 Genie<\/em><\/p>\n\n\n\n

If you pick up a textbook on Algol 68 from the 1970s, such as Andrew McGettrick\u2019s wonderful primer, Algol 68 \u2013 a first and second course<\/em>1<\/sup><\/a>, you will see code examples represented as follows:2<\/sup><\/a><\/p>\n\n\n\n

begin real<\/strong> e<\/em> = 2.7182818284; real<\/strong> circum<\/em>;<\/p>\n\n\n\n

    circum<\/em> := 2 \u00d7 pi<\/em> \u00d7 e<\/em>;<\/p>\n\n\n\n

    print<\/em> ((\u201ccircumference of a cricle of radius e is<\/em>\u201d, circum<\/em>))<\/p>\n\n\n\n

end <\/strong><\/p>\n\n\n\n

Professor McGettrick soon explains:<\/p>\n\n\n\n

\n

When a program has to be run on a computer it will have to be prepared in some suitable manner… Unfortunately, however, these and similar devices do not permit the printing in bold type of words such as <\/em>begin<\/strong><\/em>. Indeed, often small leters are also unavailable… <\/em>Typically <\/em>begin<\/strong><\/em> might appear in one of the forms<\/em><\/p>\n\n\n\n

.BEGIN. \u2018BEGIN\u2019 \u2018BEGIN BEGIN<\/em><\/p>\n\n\n\n

… Moreover the multiplication sign has been replaced by an asterisk.<\/em>3<\/sup><\/a><\/p>\n<\/blockquote>\n\n\n\n

This convention of using boldfaced words for symbols comes from the Revised Report,4<\/sup><\/a> which states:<\/p>\n\n\n\n

\n

The manner in which symbols for newly defined <\/em>mode-indications<\/strong><\/em> and <\/em>operators<\/strong><\/em> are to be represented is now more closely defined. Thus it is clear that the implementer is to provide a special alphabet of bold-faced, or “‘stropped”‘, marks from which <\/em>symbols<\/strong><\/em> such as <\/em>person<\/strong><\/em> may be made, and it is also clear that <\/em>operators<\/strong><\/em> such as \u00bb are to be allowed<\/em>.5<\/sup><\/a><\/p>\n<\/blockquote>\n\n\n\n

Worthwhile mentioning at this point is that the members of the Working Group defining Algol 68 were developing a whole new framework for describing the programming language, and even for describing the description, with new concepts such as stropping mentioned above.<\/p>\n\n\n\n

Most of us have had some experience with programming languages whose designers have adopted a standard for styling code in that language. Think of the arguments between C programmers as to whether to write } else {<\/code> or have one or more of the braces appear on separate lines.<\/p>\n\n\n\n

And yes, one of the little things that challenges Algol 68 implementations is how to deal with the difference between begin<\/strong>, which is a symbol, and begin<\/em>, which is an identity.<\/p>\n\n\n\n

In the articles I have written to date about Algol 68 on both.org<\/a>, I have used the Algol 68 Genie compiler \u2013 interpreter, which prefers UPPER stropping<\/em> \u2013 symbols are written all in capital letters and identities are written all in lower case letters and numbers. Moreover, symbols cannot contain blanks, but identifiers can.<\/p>\n\n\n\n

This UPPER stropping makes it pretty straightforward to write a simple pretty printer, in order to convert bold-stropped Algol 68 code into the more decorated version, in HTML format, for inclusion in web pages or elsewhere.<\/p>\n\n\n\n

Enough background, let\u2019s get to work on the code.<\/p>\n\n\n\n

The pretty printer<\/h2>\n\n\n\n

Here it is. It\u2019s pretty long, but not super-complicated, and because of the length I\u2019ve added quite a few comments. Discussion follows:<\/p>\n\n\n\n

     1\t#\n     2\t    Library-preludes\n     3\t    \n     4\t    \/Nothing, however, prevents you from subjoining to this standard-prelude a\n     5\t     set of home made declarations. Of course you are free to declare such new\n     6\t     things in your own particular-program; but, as soon as you want to apply\n     7\t     them in several programs,or you want to enable others to use them, or you\n     8\t     have reason to expect that more efficiency may be acquired, then you can go\n     9\t     to your implementor and ask him to make the whole set an as efficient as\n    10\t     possible extension of the standard-prelude, i.e. 'it 'library-prelude'. In\n    11\t     that way an arbitrary number of problem oriented dialects may be defined.\/\n       \n    12\t     Lindsey, C.H., & van der Meulen, S.G. (1973).\n    13\t     \/Informal Introduction to Algol 68\/ (Revised Edition, Ch. 0.10.7, p. 52).\n    14\t     North Holland Publishing Company.\n    15\t#\n       \n    16\tPR read \"each_line.a68\" PR\n       \n    17\t#\n    18\t    Particular-program\n       \n    19\t    Algol 68 pretty printer.\n    20\t    Depends on UPPER stropping.\n    21\t    Lowercases and bolds reserved words.\n    22\t    Italicizes variable names.\n    23\t    Generates HTML output.\n    24\t#\n       \n    25\tBEGIN\n       \n    26\t    #\n    27\t        Using a68g, we can get at Linux command line arguments.\n       \n    28\t        In order to pass arguments to the program, we terminate arguments to a68g\n    29\t        itself using the command line option \"--\".\n       \n    30\t        Therefore, there are three arguments to be skipped before the program can\n    31\t        find its own arguments:\n       \n    32\t        argv(1) - \"a68g\"\n    33\t        argv(2) - name of the program being interpreted\n    34\t        argv(3) - \"--\" which is necessary to get a68g to leave off interpreting args\n       \n    35\t        Following those, we can provide a list of one or more Algol 68 files,\n    36\t        which appear in argv(4) and onward.\n       \n    37\t    #\n       \n    38\t    IF argc < 4 THEN\n       \n    39\t        print(\"Usage: a68g pp.a68 -- [source files for pretty printing]\")\n       \n    40\t    ELSE\n       \n    41\t        #\n    42\t            Embed our pretty-printed code in a minimal HTML head-body section\n    43\t        #\n       \n    44\t        print((\"<html>\",new line));\n    45\t        print((\"<head>\",new line));\n    46\t        print((\"<title> Algol 68 Pretty Print<\/title>\",new line));\n    47\t        print((\"<body>\",new line));\n       \n    48\t        #\n    49\t            Loop over source files.\n    50\t            There is no sophisticated parsing nor error checking here\n    51\t        #\n       \n    52\t        FOR an FROM 4 TO argc DO\n       \n    53\t            STRING file name = argv(an);\n       \n    54\t            #\n    55\t                If the file is a readable regular file, we attempt to pretty print it\n    56\t            #\n       \n    57\t            IF file is regular(file name) THEN\n       \n    58\t                print((new line, new line,\"<p><strong><em>{ **** \",file name,\" **** }<\/em><\/strong><\/p>\",new line,new line));\n       \n    59\t                #\n    60\t                    There are six \"states\" that the pretty printer can be in:\n       \n    61\t                    - commenting (between opening sharp and closing sharp):\n    62\t                        do no pretty printing\n    63\t                    - stringing (between opening doublequote and closing doublequote):\n    64\t                          do no pretty printing\n    65\t                    - leadering (processing leading blanks on a line):\n    66\t                        replace blanks with &nbsp;, tabs with &nbsp;&nbsp;&nbsp;&nbsp;\n    67\t                    - reserved wording (processing upper case words):\n    68\t                        lowercase and wrap in &lt;strong&gt;&lt;\/strong&gt;\n    69\t                    - identitying (processing lower case variable names possibly\n    70\t                      including spaces or numerals): \n    71\t                          wrap in &lt;em&gt;&lt;\/em&gt;\n    72\t                    - other (for example processing numerals, punctuation):\n    73\t                        just let the characters through\n       \n    74\t                    Commenting can be active over more than one line, but other states reset at the beginning of each line.\n    75\t                    Each file appears as one HTML paragraph, with line breaks after each line.\n    76\t                #\n       \n    77\t                print(\"<p>\");\n       \n    78\t                # multiline state resets #\n       \n    79\t                BOOL commenting := FALSE;\n       \n    80\t                #\n    81\t                    Loop over the lines in the file\n    82\t                #\n       \n    83\t                each line(file name, (STRING line, INT linecount) VOID: BEGIN\n       \n    84\t                    # individual line state resets #\n       \n    85\t                    BOOL reserved wording := FALSE;\n    86\t                    BOOL identitying := FALSE;\n    87\t                    BOOL stringing := FALSE;\n    88\t                    BOOL leadering := TRUE;\n       \n    89\t                    # process the line character-by-character #\n       \n    90\t                    FOR cn FROM LWB line TO UPB line DO\n    91\t                        CHAR c := line[cn];\n       \n    92\t                        # analyze the current character and change states where necessary #\n       \n    93\t                        IF c = \"\"\"\" AND NOT commenting THEN\n       \n    94\t                            # start or end of a string - flip stringing; off reserved wording, identifying, leadering #\n       \n    95\t                            stringing := NOT stringing;\n       \n    96\t                            IF reserved wording THEN reserved wording := FALSE; print(\"<\/strong>\") FI;\n    97\t                            IF identitying THEN identitying := FALSE; print(\"<\/em>\") FI;\n    98\t                            leadering := FALSE\n       \n    99\t                        ELIF c = \"#\" AND NOT stringing THEN\n       \n   100\t                            # start or end of a comment - flip commenting; off reserved wording, identifying, leadering #\n       \n   101\t                            commenting := NOT commenting;\n       \n   102\t                            IF reserved wording THEN reserved wording := FALSE; print(\"<\/strong>\") FI;\n   103\t                            IF identitying THEN identitying := FALSE; print(\"<\/em>\") FI;\n   104\t                            leadering := FALSE\n       \n   105\t                        ELIF NOT (commenting OR stringing) THEN\n       \n   106\t                            IF \"A\" <= c AND c <= \"Z\" THEN\n       \n   107\t                                # reserved wording #\n       \n   108\t                                IF NOT reserved wording THEN\n       \n   109\t                                    # start of reserved wording - on reserved wording; off identifying, stringing, commenting, leadering #\n       \n   110\t                                    reserved wording := TRUE; print(\"<strong>\");\n       \n   111\t                                    IF identitying THEN identitying := FALSE; print(\"<\/em>\") FI;\n   112\t                                    leadering := FALSE\n   113\t                                FI;\n       \n   114\t                                # translate to lower case #\n       \n   115\t                                c := REPR (ABS c - ABS \"A\" + ABS \"a\")\n       \n   116\t                            ELIF \"a\" <= c AND c <= \"z\" THEN\n       \n   117\t                                # identifying #\n       \n   118\t                                IF NOT identitying THEN\n       \n   119\t                                    # start of identifying - on identifying; off reserved wording, stringing, commenting, leadering #\n       \n   120\t                                    identitying := TRUE; print(\"<em>\");\n       \n   121\t                                    IF reserved wording THEN reserved wording := FALSE; print(\"<\/strong>\") FI;\n   122\t                                    leadering := FALSE\n   123\t                                FI\n       \n   124\t                                # don't mess with the character #\n       \n   125\t                            ELIF ABS c = 9 OR c = \" \" THEN\n       \n   126\t                                # leadering, space within an identity or just a space - off reserved wording #\n       \n   127\t                                IF reserved wording THEN reserved wording := FALSE; print(\"<\/strong>\") FI\n       \n   128\t                            ELIF \"0\" <= c AND c <= \"9\" THEN\n       \n   129\t                                # continuation of an identity or just a numeral - off reserved wording, leadering #\n       \n   130\t                                IF reserved wording THEN reserved wording := FALSE; print(\"<\/strong>\") FI;\n   131\t                                leadering := FALSE\n       \n   132\t                            ELSE\n       \n   133\t                                # something else, e.g. punctuation - off reserved wording, identitying and leadering #\n       \n   134\t                                IF reserved wording THEN print(\"<\/strong>\"); reserved wording := FALSE FI;\n   135\t                                IF identitying THEN print(\"<\/em>\"); identitying := FALSE FI;\n   136\t                                leadering := FALSE\n       \n   137\t                            FI\n   138\t                        FI;\n       \n   139\t                        # emit the current character (or its surrogate) #\n       \n   140\t                        IF leadering AND c = \" \" THEN\n   141\t                            print(\"&nbsp;\")\n   142\t                        ELIF leadering AND ABS c = 9 THEN\n   143\t                            print(\"&nbsp;&nbsp;&nbsp;&nbsp;\")\n   144\t                        ELIF c = \"<\" THEN\n   145\t                            print(\"&lt;\")\n   146\t                        ELIF c = \">\" THEN\n   147\t                            print(\"&gt;\")\n   148\t                        ELSE\n   149\t                            print(c)\n   150\t                        FI\n   151\t                    OD;\n       \n   152\t                    # end of line - off reserved wording, identifying; print line break #\n       \n   153\t                    IF reserved wording THEN print(\"<\/strong>\"); reserved wording := FALSE FI;\n   154\t                    IF identitying THEN print(\"<\/em>\"); identitying := FALSE FI;\n   155\t                    print((\"<br \/>\",new line))\n       \n   156\t                END);\n       \n   157\t                #\n   158\t                    That's it for this file, close off the HTML paragraph\n   159\t                #\n       \n   160\t                print((\"<\/p>\",new line))\n       \n   161\t            ELSE\n       \n   162\t                #\n   163\t                    Oops - not a regular file\n   164\t                #\n       \n   165\t                print((new line, new line,\"<p><strong><em>{ **** \",file name,\" **** is not a regular file - skipping }<\/em><\/strong><\/p>\",new line,new line))\n       \n   166\t            FI\n   167\t        OD;\n       \n   168\t        #\n   169\t            Emit HTML postamble\n   170\t        #\n       \n   171\t        print((\"<\/body>\",new line));\n   172\t        print((\"<\/html>\",new line))\n   173\t    FI\n       \n   174\tEND<\/pre>\n\n\n\n
On line 16, we use the Algol 68 Genie pragmat<\/strong> read<\/em> to include the source code for our each line() procedure that lets us process a text file without worrying about the \u201chow\u201d details.<\/p>\n\n\n\n
The particular-program, that is the main program, runs from the BEGIN<\/code> on line 25 through to the END<\/code> on line 174.<\/p>\n\n\n\n
Lines 26 \u2013 40 use Algol 68 Genie extensions to get at the Linux command line arguments, allowing the user of our program to pass in one or more source code files for pretty printing. The comments explain this in more detail.<\/p>\n\n\n\n
Lines 41 \u2013 47 emit the HTML the opening \u201chtml\u201d, the \u201chead\u201d block and the opening \u201cbody\u201d elements; lines 168 \u2013 173 emit the closing \u201cbody\u201d and \u201chtml\u201d elements. This lets us have a standalone HTML page; or we can take the output lines between these two HTML segments if we just want the pretty printed code.<\/p>\n\n\n\n
Lines 52 \u2013 167 are a loop over each file supplied by the user. As the comments note, the pretty printed code is placed in a single HTML paragraph with HTML line breaks at the end of each line.<\/p>\n\n\n\n
Line 53 sets the file name from the relevant argv()<\/code> call.<\/p>\n\n\n\n
Lines 54 \u2013 161 process the file if it is \u201cregular\u201d; lines 162 \u2013 166 print a warning and skip the file otherwise.<\/p>\n\n\n\n
Lines 58 \u2013 77 print an HTML header for the file being processed, describe the interpretation process as a set of states established by what is read and used for the pretty printing and print the HTML opening \u201cp\u201d element, indicating the start of the pretty printed code. Lines 157 \u2013 160 print the closing \u201cp\u201d element.<\/p>\n\n\n\n
Lines 78 \u2013 156 initialize the commenting<\/code> state to FALSE<\/code> \u2013 that is, the pretty printing starts knowing that it is not within a comment – and use the each line()<\/code> procedure to process the lines in the text file. This then is where the work is done. Comments in Algol 68 are potentially multline and therefore cannot be reset to \u201cnot commenting\u201d at the end of each line.<\/p>\n\n\n\n
Lines 84 \u2013 88 reset the remaining states \u2013 stringing<\/code>, reserved wording<\/code>, identifying<\/code> and leadering<\/code> at the beginning of each line. These states are not multiline, so this is appropriate. The leadering<\/code> state might confuse \u2013 this refers to the zero or more blanks or tabs that begin each line of code. All of these states are mutually exclusive, as is the \u201cnot any of these\u201d state, at least as far as pretty printing goes. There is no adjustment to text within comments or strings. Symbols (reserved words) are converted to HTML \u201cstrong\u201d text and lower-cased; identifiers are converted to HTML \u201cem\u201d text.<\/p>\n\n\n\n
Lines 90 \u2013 151 loop over the characters in a line, looking for state changes and wrapping symbols and identifiers as required.<\/p>\n\n\n\n
Lines 93 \u2013 98 detect the beginning or end of a string, flip the stringing<\/code> state and turn off reserved wording<\/code>, identifying<\/code> and leadering<\/code> states.<\/p>\n\n\n\n
Lines 98 \u2013 104 detect the beginning or end of a comment, flip the commenting<\/code> state and turn off reserved wording<\/code>, identifying<\/code> and leadering<\/code> states.<\/p>\n\n\n\n
Lines 105 \u2013 138 deal with the rest of the states provided that the pretty printing process is in neither the stringing<\/code> nor commenting<\/code> state.<\/p>\n\n\n\n
Lines 106 \u2013 115 deal with symbols, turning on the reserved wording<\/code> state at the beginning of a symbol (upper case letter) and turning off identifying<\/code> and leadering<\/code> states. Uppercase characters are translated to lower case in line 115 using a rule that works with ASCII upper- and lowercase characters.<\/p>\n\n\n\n
Lines 116 \u2013 124 deal with identifiers, turning on the identifying<\/code> state at the beginning of an identifier (lower case letter) and turning off reserved wording<\/code> and leadering<\/code> states. No adjustments are made to the characters themselves.<\/p>\n\n\n\n
Lines 125 \u2013 127 deal with spaces that terminate symbols, can be embedded in identifiers or can be \u201csignificant\u201d white space (from a pretty printing perspective) at the beginning of a line, turning off the reserved wording<\/code> state.<\/p>\n\n\n\n
Lines 128 \u2013 131 deal with numerical digits that terminate symbols and leading white space but can be a second or subsequent character in an identifier, turning off the reserved wording<\/code> and leadering<\/code> states.<\/p>\n\n\n\n
Lines 132 \u2013 136 deal with any other characters which terminate symbols, identifiers and leading white space, turning off reserved wording<\/code>, identifying<\/code> and leadering<\/code> states.<\/p>\n\n\n\n
Phew, done with tracking all the state changes and bits of HTML markup!<\/p>\n\n\n\n
Lines 140 \u2013 150 convert the character to one or four HTML non-breaking spaces if it\u2019s a space ot tab and the leadering state is on; to HTML lt and gt symbols if it\u2019s the less-than or greater-than symbol respectively; or just output it otherwise.<\/p>\n\n\n\n
Finally lines 152 \u2013 155 handle the end of line.<\/p>\n\n\n\n
Running the code and looking at the results<\/h2>\n\n\n\n
Let\u2019s test the program out on the regress.a68 program we wrote in the previous article:<\/p>\n\n\n\n
$ a68g pp.a68 -- regress.a68 > regress.html\n$<\/pre>\n\n\n\n
And here\u2019s the output:<\/p>\n\n\n\n
{ **** regress.a68 **** }<\/em><\/strong><\/p>\n\n\n\n
#
     Utility routines
 #
 
 pr<\/strong> read <\/em>“str_to_real.a68” pr<\/strong>
 pr<\/strong> read <\/em>“split.a68” pr<\/strong>
 pr<\/strong> read <\/em>“each_delimited_line.a68” pr<\/strong>
 
 #
     Perform a least-squares fit of a line to a data file containing (x,y) values
 #
 
 begin<\/strong>
 
     [1:2,1:2] real<\/strong> xtx <\/em>:= ((0.0, 0.0),(0.0,0.0));
     [1:2] real<\/strong> xty <\/em>:= (0.0, 0.0);
 
     # Accumulate XTX and XTy #
 
     each delimited line<\/em>(“test_data.txt”, “,”, (string<\/strong> line<\/em>, []string<\/strong> fields<\/em>, int<\/strong> line count<\/em>) void<\/strong>: begin<\/strong>
         # skip the header line #
         if<\/strong> line count <\/em>> 1 then<\/strong>
             real<\/strong> xi <\/em>= str to real<\/em>(fields<\/em>[1]), yi <\/em>= str to real<\/em>(fields<\/em>[2]);
             xtx<\/em>[1,1] +:= xi <\/em>* xi<\/em>;
             xtx<\/em>[1,2] +:= xi<\/em>;
             xtx<\/em>[2,2] +:= 1.0;
             xty<\/em>[1] +:= xi <\/em>* yi<\/em>;
             xty<\/em>[2] +:= yi<\/em>
         fi<\/strong>
     end<\/strong>);
     xtx<\/em>[2,1] := xtx<\/em>[1,2];
 
     # let’s see the matrix and vector before Gauss #
 
     print<\/em>((“before Gauss:”,new line<\/em>));
     print<\/em>((“\u23a1”,xtx<\/em>[1,1],” “,xtx<\/em>[1,2],”\u23a4 = \u23a1”,xty<\/em>[1],”\u23a4”,new line<\/em>));
     print<\/em>((“\u23a3”,xtx<\/em>[2,1],” “,xtx<\/em>[2,2],”\u23a6 \u23a3”,xty<\/em>[2],”\u23a6”,new line<\/em>));
 
     # Gaussian elimination #
 
     real<\/strong> a <\/em>= –xtx<\/em>[2,1] \/ xtx<\/em>[1,1];
     xtx<\/em>[2,1] +:= a <\/em>* xtx<\/em>[1,1];
     xtx<\/em>[2,2] +:= a <\/em>* xtx<\/em>[1,2];
     xty<\/em>[2] +:= a <\/em>* xty<\/em>[1];
 
     # let’s see the matrix and vector after Gauss #
 
     print<\/em>((“after Gauss:”,new line<\/em>));
     print<\/em>((“\u23a1”,xtx<\/em>[1,1],” “,xtx<\/em>[1,2],”\u23a4 = \u23a1”,xty<\/em>[1],”\u23a4”,new line<\/em>));
     print<\/em>((“\u23a3”,xtx<\/em>[2,1],” “,xtx<\/em>[2,2],”\u23a6 \u23a3”,xty<\/em>[2],”\u23a6”,new line<\/em>));
 
     # back substitution #
 
     real<\/strong> b <\/em>= xty<\/em>[2] \/ xtx<\/em>[2,2];
     real<\/strong> m <\/em>= (xty<\/em>[1] – xtx<\/em>[1,2] * b<\/em>) \/ xtx<\/em>[1,1];
 
     # let’s see the equation #
 
     print<\/em>((“equation:”,new line<\/em>));
     print<\/em>((“y = “,fixed<\/em>(m<\/em>,0,7),” * x + “,fixed<\/em>(b<\/em>,0,7),new line<\/em>))
 
 end<\/strong>https:\/\/www.both.org\/?p=11217<\/a><\/p>\n\n\n\n
Not bad! I like to have string constants like “equation:” stand out from identifiers so I don’t italicize them. But other than that, I think it looks pretty close to the beautifully typeset examples from the 1970s.<\/p>\n\n\n\n
What did we learn here? Two things come to mind:<\/p>\n\n\n\n