SUPPER stropping (The GNU Algol 68 Compiler)

#### 5.4.4 SUPPER stropping ¶

In the SUPPER stropping regime bold words are written by writing a sequence of one or more taggles. Each taggle is written by writing a letter followed by zero or more other letters and digits and is optionally followed by a trailing underscore character. The first letter in a bold word shall be an upper-case letter. The rest of the letters in the bold word may be either upper- or lower-case.

For example, `RecRset`, `Rec_Rset` and `RECRset` are all different ways to represent the same mode indication. This allows to recreate popular naming conventions such as `CamelCase`.

As in the other stropping regimes, the casing of the letters and the underscore characters are not really part of the mode or operator indication.

Operator indications are also bold words and are written in exactly the same way than mode indications, but it is usually better to always use upper-case letters in operator indications. On one side, it looks better, especially in the case of dyadic operators where the asymmetry of, for example `Equal` would look odd, consider `m1 Equal m2` as opposed to `m1 EQUAL m2`. On the other side, tools like editors can make use of this convention in order to highlight operator indications differently than mode indications.

In the SUPPER stropping regime tags are written by writing a sequence of one or more taggles. Each taggle is written by writing a letter followed by zero or more other letters and digits and is optionally followed by a trailing underscore character. All letters in a tag shall be lower-case letters.

For example, the identifier `list` is represented by a single taggle, and it is composed by the letters `l`, `i`, `s` and `t`, in order. In the jargon of the strict language we would spell the tag as `letter-l-letter-i-letter-s-letter-t`.

The label `found_zero` is represented by two taggles, `found_` and `zero`, and it is composed by the letters `f`, `o`, `u`, `n`, `d`, `z`, `e`, `r` and `o`, in order. In the jargon of the strict language we would spell the tag as `letter-f-letter-o-letter-u-letter-n -letter-d-letter-z-letter-e-letter-r-letter-o`.

The identifier `crc_32` is likewise represented by two taggles, `crc_` and `32`. Note how the second taggle contains only digits. In the jargon of the strict language we would spell the tag as `letter-c-letter-r-letter-c-digit-three-digit-two`.

The underscore characters are not really part of the tag, but part of the stropping. For example, both `goto found_zero` and `goto foundzero` jump to the same label.

In general, typographical display features are allowed between any symbol in the written program. In SUPPER stropping, however, it is not allowed to place spaces or tab characters between the constituent digits of bits denotations when the radix is 16. This is to avoid confusing situations like the following invalid program:

    while bitmask /= 16r0 do ~ od

Where the bits denotation would be interpreted as `16r0d` rather than `16r0`, leading to a syntax error. Note however that typographical display features are still allowed between the radix part and the digits, so `16r aabb` is valid also in SUPPER stropping.

The `recsel output records` procedure, encoded in SUPPER stropping, looks like below.

    proc recsel_output_records = void:
    begin bits flags
            := (include_descriptors | rec_f_descriptor | rec_f_none);
          RecRset res = rec_db_query (db, recutl_type,
                                      recutl_uick, flags);
          RecWriter writer := rec_writer_file_new (stdout);

          skip_comments of writer := true;
          if recutl_print_sexps
          then mode_ of writer := rec_writer_sexp fi;
          rec_write (writer, res)
    end