The GNU Algol 68 Big Task List

[Jose E. Marchesi]

Hello people!

Today I spent quite a lot of time reviewing my notes, and I managed to
put together a rather extensive task list to replace the old "Roadmap"
section in the wiki, which was oriented to the core language support,
which is almost done.

I have already updated the wiki page at

 https://gcc.gnu.org/wiki/BPFFrontEnd

with the contents below.

Salud!


---

= The GNU Algol 68 Big Task List =

In order to help people interested in contributing the entries listed here are
concrete tasks that should require little or no planning before being
undertaken.

Bigger projects that require some planning and discussion in the mailing list
are marked with [PROJ].  These are listed last in each category.

Generally speaking the entries in each category are listed in a decreasing
priority order.

Entries are removed from this wiki once completed.  We are interested in what
to do next, not in justifying what we have already done!  The wiki system
should provide some mean of recovering the history of editions.

== Bugs ==
  
These should all have bugzillas.

 * [BZ algol68/123653] a68: segmentation fault in mode_check_selection

== Compiler ==

 * It is no longer necessary to check for HAS_ROWS before calling low_dup. Remove existing checks from the codebase.
 * Disable strict-aliasing in front-end. In LANG_HOOKS_POST_OPTOINS add `flag_strict_aliasing = 0'.
 * In systems where in < 32 the set of Unicode points that can be stored in `char' decreases: BMP for 16-bit ints, and ASCII+1bit for 8-bit ints. libga68 always uses u32, so the compiler-runtime interface should do proper conversions in the generated code when chars get sent and returned from libcalls.
 * Ghost elements in multiples.
 * Bound checking in row displays.
 * Expand front-end token locations with an end of token position
 * The scope of a skip shall be the primal scope as per the RR (?)
 * Add scope to names, and descriptor to names to multiple values.
 * Finish UNSAFE.
 * Use fat names to avoid using the heap in trimming.
 * Make long long int 128-bit in targets supporting it.
 * Support short real.
 * Straightening.
 * [PROJ] Generation of dependencies in ga68.
 * [PROJ] ga68 as formatter: ga68 -F

== Modules ==

 * Add support for reading .a archives to a68-imports.cc. The go front-end has code for this.
 * Support publicized row modes with actual bounds in modules.

== Diagnostics ==

 * Warning for prio declarations of monadic operators.
 * Warning for `MODE foo = GEN MODE'.
 * Error on overflow in integral denotations.

== Core language ==


 * Widening from `SIZETY real' to `SIZETY compl'.
 * Widening from `SIZETY bytes' to `[]char'.

== Pragmats ==

 * The include pragmat should save and restore current stropping when including files.

== Representation ==

 * Do not use "^" as representation for exponentiation. "**" and "UP" are also used for this. This makes the worthy character available for other uses.
 * Adopt backslash as alt representation for `of' As suggested by Hansen in AB427.

== Optimizations ==

 * Cache `skip' values for standard M_* modes. Store the cached tree node in the MOID_T struct.
 * Adopt Meertens algorithm for copying multiples "Space saving technique for multiple assignation".
 * Generate per-mode specialized dup routines and call them rather than inlining code.
 * [PROJ] Static properties parser pass. Based on Branquart's work.
 * [PROJ] Put string denotations and multiple displays in global decls to avoid allocating them on the stack

== Hardware representation ==

 * Support string breaks 'L, 'P and 'F for line number, procedure name and file name respectively.

== GNU extensions ==

 * [PROJ] Asymmetric pragmat delimiters. 
 * [PROJ] Left-to-right selection representation using apostrophe.
 * [PROJ] forall like ALGOL68RS
 * [PROJ] Transposition and reversal operators for multiples. These just change the descriptor.

 For discussion:

 * [PROJ] Vectors and i-structs like ALGOL68RS
 * [PROJ] User accessible Straight mode like ALGOL68RS
 * [PROJ] code-clauses like ALGOL68RS
 * [PROJ] Optional arguments: (,,) use all three default arguments.
 * [PROJ] "Eventual" values and coercion like ALGOL68-S
 * [PROJ] on-error error recovery routine like ALGOL68-S
{{{
    on_error ((int modno, lineno, bits errno) bool:
    if errno SHR 6 = BIN 3
        { 3 means a division-by-zero error. For a
          table of error message numbers, see the
          attached pages.  }
    then write_bin (some file,
                    (modno, lineno, errno));
         try_to_restart
    else false
    fi
}}}
 * [PROJ] Support out-parts in serial clauses
{{{
    begin ... out ... always executed on exit ... end
}}}
 * [PROJ] choice-using-string and choice-using-character
 * [PROJ] Invariable references. `.-' is the becomes-and-remains-symbol. Coercion from `ref MODE' to `invar ref MODE'.
{{{
    : invar int foo .- 10;
}}}

== Extended standard prelude ==

 * Mode Byte.
 * Mode PtrSize.
 * SET and CLEAR dyadic operators for `SIZETY bits'.
 * Operator `LEN = (char)int' gives number of bytes for representing the given char in UTF-8. (?)

== POSIX prelude ==

 * posix_sleep.
 * TimeSpec and gettime/settime.
 * Signal handling: posix_on_signal
 * Termios and tcgetattr, tcsetattr.
 * Binary IO, fgetb, fputb.

== Transput ==

 * Remove fundamental modes file, channel, etc.
 * Move flip, flop and friends to transput.a68.in.

== Runtime ==

 * Check at configure time for all needed target functions like open, close, etc.

== Testsuite ==

 * Test completer in collateral clause
 * Test completer after a statement (voided unit) in serial clause
 * Test completer in loop clause
 * Test negative bounds in indexers and trimmers
 * Test `[]int a = ((matrix[,2], (3,4,5)))'
 * Test for unions and `empty'
 * Test for ghost element
{{{
    flex[1:0][1:8]real foo;
    foo := heap[1:2][1:6]real
    This should lead to run-time error.  The original bounds 1:8 are stored in
    a "ghost element" of the "flex to fix" flexible multiple.
}}}
 * Test completers and jumps in DSA ranges
 * Test assignation of overlapping multiples

== Documentation ==

 * Document whole, fixed and float in the manual.
 * Document the static scope checker in the manual.
 * Document uninitialized union values in the manual
 * Document public symbol effect in normal form of collateral declarations vs. contracted form.
{{{
module Foo =
def
    { Collateral declaration.
      Two declarers, pub affects to the first, `int' }
    pub int i = 1, bits b = 16rff;

    { Contracted form of the above.
      One declarer, pub affects both tags. }
    pub int x = 1, y = 2;

    skip
fed
}}}

== Other preludes ==

 * Write a prelude for handling of multi-precision integral values: mode LInt,
   operators L and I to conver to/from ints, etc. See "ALGOL 68 Preludes for
   Arithmetic in Z and Q" by Guenter Baszenski.


== Emacs a68-mode ==

Homepage: https://git.sr.ht/~jemarch/a68-mode

 * Highlight _foo and _FOO as errors.
 * Add idle task to collect mode names from mode declarations in buffer so they get highlighted properly.
 * Provide "light" and "dark" predefined sets of faces.
 * [PROJ] Indent joined lists properly

== Emacs vw-mode ==

Homepage: https://git.sr.ht/~jemarch/vw-mode

 * Command to get a cross-reference string for rule under point This should follow the conventions in RR, i.e. for referring to 4.3.1.a generate "34a".
 * Command to jump to metaproduction-rule from metanotion
 * Command to follow cross-reference
 * Sanity-check command: no concatenation of metanotions shall give another metanotion
 * Remove newline after end-of-comment whenever appropriate in hidding mode
 * Show metaproduction rule for metanotion under point in echo area
    
== Algol 68 Jargon ==

The Algol 68 Jargon file lives at https://git.sr.ht/~jemarch/a68-jargon.

Published at https://jemarch.net/a68-jargon.

Available in Gentoo as app-doc/a68-jargon.

Definitions to add:

 * monad
 * nomad
 * cast
 * coercend
 * cerceer
 * coercion
 * collateral clause
 * collateral declarations
 * dynamic name
 * fixed name
 * elaboration
 * firmly coercible (RR 2.6.1)
 * firmly related (RR 2.6.1)
 * flat descriptor
 * bound
 * label
 * goto
 * indicant
 * range
 * reach
 * scope
 * skip
 * straightening
 * terminating
 * completing
 * precision
 * nihil
 * size
 * widenable
 * generator
 * minority report
 * butthurt
 * virtual declarer
 * victal
 * viract
 * moid
 * defining identifier
 * nest
 * plain value
 * stowed value
 * denotation
 * deproceduring
 * procedured goto
 * unit
 * environment enquiry
 * van der meulen diagram
 * The Bend
 * selection
 * Three refs trick
 * prelude
 * standard prelude
 * packet
 * module
 * particular program
 * f001
 * unworthy character
 * flip
 * flop
 * modal
 * stropping
 * stropping-regime
 * ortholetter
 * terminal production
 * production rule
 * metaproduction rule
 * hyper rule
 * metanotion
 * notion
 * hypernotion
 * hipping
 * Bower's Principle
 * fulcrum (of a balance)
 * environment
 * locale

== Other ==

 * Add Algol68 to the SARIF spec.
 * [PROJ] Should we join IFIP's subcommittee on Algol 68 support?

== Crazy ideas ==

 * [PROJ] User-defined coercions valid in strong contexts
{{{
{ From JSON_Val to string for example. }

coer JSON_Val to string = (JSON_Val val) string:
   json_str (val);

{ Only valid in strong contexts. They must be ordered somehow.
  With priorities? }
}}}