https://gcc.gnu.org/g:4b22e5581bb3276598d9e4ec46bbb6a541e8dbe6

commit r17-6032-g4b22e5581bb3276598d9e4ec46bbb6a541e8dbe6
Author: Jose E. Marchesi <[email protected]>
Date:   Sat Oct 31 11:49:28 2026 +0100

    a68: add GNU extensions in Algol 68 to libga68
    
    This patch adds and implementation of the `word compl' extended
    stanard operators to libga68.  To this effect, a new module GNU is
    added to libga68.  The prelude sources are pre-processed by sppp.
    
    Additionally, this patch makes sure that the extended standard modes
    are always built in the M_* globals, even if they are only available
    for Algol 68 programs if -std=gnu68.  This is necessary because the
    M_* standard modes are used by a68_decode_modes.  This last funtion is
    also hardened to make sure all required modes exist.
    
    gcc/algol68/ChangeLog
    
            * a68-parser-prelude.cc (gnu_moids): New function.
            (stand_prelude): Move extended moids definition to gnu_moids.
            (gnu_prelude): Load Algol 68 parts from gnu.a68.
            Call gnu_moids.
            * a68-imports.cc (SET_MOID): Define.
            (complete_encoded_mode): Use SET_MOID.
    
    libga68/ChangeLog
    
            * gnu.a68.in: New file.
            * Makefile.am (gnu.a68): New rule.
            (BUILT_SOURCES): Add gnu.a68.
            (libga68_la_DEPENDENCIES): Add gnu.lo
            (libga68_la_LIBADD): Likewise.
            * Makefile.in: Regenerate.

Diff:
---
 gcc/algol68/a68-imports.cc        |  64 +++++++++++++----------
 gcc/algol68/a68-parser-prelude.cc | 103 +++++++++++++++++++++++++-------------
 libga68/Makefile.am               |   9 ++--
 libga68/Makefile.in               |   9 ++--
 libga68/gnu.a68.in                |  86 +++++++++++++++++++++++++++++++
 5 files changed, 203 insertions(+), 68 deletions(-)

diff --git a/gcc/algol68/a68-imports.cc b/gcc/algol68/a68-imports.cc
index da3e7f48d6e8..ba3bf9d260c0 100644
--- a/gcc/algol68/a68-imports.cc
+++ b/gcc/algol68/a68-imports.cc
@@ -730,21 +730,29 @@ complete_encoded_mode (encoded_modes_map_t 
&encoded_modes, uint64_t offset)
   if (em->moid != NO_MOID)
     return em->moid;
 
+#define SET_MOID(M)                            \
+  do                                           \
+    {                                          \
+    gcc_assert ((M) != NO_MOID);               \
+    em->moid = (M);                            \
+    }                                          \
+  while (0)
+
   switch (em->kind)
     {
-    case GA68_MODE_VOID:   em->moid = M_VOID; break;
-    case GA68_MODE_CHAR:   em->moid = M_CHAR; break;
-    case GA68_MODE_BOOL:   em->moid = M_BOOL; break;
-    case GA68_MODE_STRING: em->moid = M_FLEX_ROW_CHAR; break;
+    case GA68_MODE_VOID:   SET_MOID (M_VOID); break;
+    case GA68_MODE_CHAR:   SET_MOID (M_CHAR); break;
+    case GA68_MODE_BOOL:   SET_MOID (M_BOOL); break;
+    case GA68_MODE_STRING: SET_MOID (M_FLEX_ROW_CHAR); break;
     case GA68_MODE_INT:
       switch (em->sizety)
        {
-       case 0: em->moid = M_INT; break;
-       case 1: em->moid = M_LONG_INT; break;
-       case 2: em->moid = M_LONG_LONG_INT; break;
-       case -1: em->moid = M_SHORT_INT; break;
-       case -2: em->moid = M_SHORT_SHORT_INT; break;
-       case 100: em->moid = M_WORD_INT; break;
+       case 0: SET_MOID (M_INT); break;
+       case 1: SET_MOID (M_LONG_INT); break;
+       case 2: SET_MOID (M_LONG_LONG_INT); break;
+       case -1: SET_MOID (M_SHORT_INT); break;
+       case -2: SET_MOID (M_SHORT_SHORT_INT); break;
+       case 100: SET_MOID (M_WORD_INT); break;
        default:
          gcc_unreachable ();
        }
@@ -752,12 +760,12 @@ complete_encoded_mode (encoded_modes_map_t 
&encoded_modes, uint64_t offset)
     case GA68_MODE_BITS:
       switch (em->sizety)
        {
-       case 0: em->moid = M_BITS; break;
-       case 1: em->moid = M_LONG_BITS; break;
-       case 2: em->moid = M_LONG_LONG_BITS; break;
-       case -1: em->moid = M_SHORT_BITS; break;
-       case -2: em->moid = M_SHORT_SHORT_BITS; break;
-       case 100: em->moid = M_WORD_BITS; break;
+       case 0: SET_MOID (M_BITS); break;
+       case 1: SET_MOID (M_LONG_BITS); break;
+       case 2: SET_MOID (M_LONG_LONG_BITS); break;
+       case -1: SET_MOID (M_SHORT_BITS); break;
+       case -2: SET_MOID (M_SHORT_SHORT_BITS); break;
+       case 100: SET_MOID (M_WORD_BITS); break;
        default:
          gcc_unreachable ();
        }
@@ -765,20 +773,21 @@ complete_encoded_mode (encoded_modes_map_t 
&encoded_modes, uint64_t offset)
     case GA68_MODE_BYTES:
       switch (em->sizety)
        {
-       case 0: em->moid = M_BYTES; break;
-       case 1: em->moid = M_LONG_BYTES; break;
-       case 100: em->moid = M_WORD_BYTES; break;
+       case 0: SET_MOID (M_BYTES); break;
+       case 1: SET_MOID (M_LONG_BYTES); break;
+       case 100: SET_MOID (M_WORD_BYTES); break;
        default:
          gcc_unreachable ();
        }
       break;
     case GA68_MODE_REAL:
+      gcc_assert (M_REAL != NO_MOID);
       switch (em->sizety)
        {
-       case 0: em->moid = M_REAL; break;
-       case 1: em->moid = M_LONG_REAL; break;
-       case 2: em->moid = M_LONG_LONG_REAL; break;
-       case 100: em->moid = M_WORD_REAL; break;
+       case 0: SET_MOID (M_REAL); break;
+       case 1: SET_MOID (M_LONG_REAL); break;
+       case 2: SET_MOID (M_LONG_LONG_REAL); break;
+       case 100: SET_MOID (M_WORD_REAL); break;
        default:
          gcc_unreachable ();
        }
@@ -786,10 +795,10 @@ complete_encoded_mode (encoded_modes_map_t 
&encoded_modes, uint64_t offset)
     case GA68_MODE_CMPL:
       switch (em->sizety)
        {
-       case 0: em->moid = M_COMPLEX; break;
-       case 1: em->moid = M_LONG_COMPLEX; break;
-       case 2: em->moid = M_LONG_LONG_COMPLEX; break;
-       case 100: em->moid = M_WORD_COMPLEX; break;
+       case 0: SET_MOID (M_COMPLEX); break;
+       case 1: SET_MOID (M_LONG_COMPLEX); break;
+       case 2: SET_MOID (M_LONG_LONG_COMPLEX); break;
+       case 100: SET_MOID (M_WORD_COMPLEX); break;
        default:
          gcc_unreachable ();
        }
@@ -900,6 +909,7 @@ complete_encoded_mode (encoded_modes_map_t &encoded_modes, 
uint64_t offset)
     default:
       gcc_unreachable ();
     }
+#undef SET_MOID
 
   return em->moid;
 }
diff --git a/gcc/algol68/a68-parser-prelude.cc 
b/gcc/algol68/a68-parser-prelude.cc
index e7208412a689..c9c66f2f355c 100644
--- a/gcc/algol68/a68-parser-prelude.cc
+++ b/gcc/algol68/a68-parser-prelude.cc
@@ -357,6 +357,66 @@ stand_moids (void)
   SLICE (M_ROW_SIMPLOUT) = M_SIMPLOUT;
 }
 
+/* Enter GNU extended modes in standenv.  */
+static void
+gnu_moids (void)
+{
+  /* First, create the extended modes in the M_* globals.  These are necessary
+     even if we are building in strict mode. */
+
+  MOID_T *m = NO_MOID;
+
+  a68_mode (100, "INT", &M_WORD_INT);
+  a68_mode (100, "BITS", &M_WORD_BITS);
+  a68_mode (100, "BYTES", &M_WORD_BYTES);
+  a68_mode (100, "REAL", &M_WORD_REAL);
+
+  a68_mode (100, "COMPL", &M_WORD_COMPLEX);
+  PACK_T *z = NO_PACK;
+  (void) a68_add_mode_to_pack (&z, M_WORD_REAL,
+                              TEXT (a68_add_token (&A68 (top_token), "im")),
+                              NO_NODE);
+  (void) a68_add_mode_to_pack (&z, M_WORD_REAL,
+                              TEXT (a68_add_token (&A68 (top_token), "re")),
+                              NO_NODE);
+  m = a68_add_mode (&TOP_MOID (&A68_JOB), STRUCT_SYMBOL,
+                   a68_count_pack_members (z), NO_NODE, NO_MOID, z);
+  EQUIVALENT (M_WORD_COMPLEX) = m;
+
+  M_REF_WORD_INT = a68_create_mode (REF_SYMBOL, 0, NO_NODE,
+                                   M_WORD_INT, NO_PACK);
+  M_REF_WORD_REAL = a68_create_mode (REF_SYMBOL, 0, NO_NODE,
+                                    M_WORD_REAL, NO_PACK);
+  M_REF_WORD_COMPLEX = a68_create_mode (REF_SYMBOL, 0, NO_NODE,
+                                       M_WORD_COMPLEX, NO_PACK);
+  z = NO_PACK;
+  (void) a68_add_mode_to_pack (&z, M_REF_WORD_REAL,
+                              TEXT (a68_add_token (&A68 (top_token), "im")),
+                              NO_NODE);
+  (void) a68_add_mode_to_pack (&z, M_REF_WORD_REAL,
+                              TEXT (a68_add_token (&A68 (top_token), "re")),
+                              NO_NODE);
+  m = a68_add_mode (&TOP_MOID (&A68_JOB),
+                   STRUCT_SYMBOL, a68_count_pack_members (z),
+                   NO_NODE, NO_MOID, z);
+  NAME (M_REF_WORD_COMPLEX) = m;
+
+  /* Make the extended modes visible only if we are not in strict Algol 68
+     mode.  */
+
+  if (!OPTION_STRICT (&A68_JOB))
+    {
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_WORD_INT);
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_WORD_BITS);
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_WORD_BYTES);
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_WORD_REAL);
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_WORD_COMPLEX);
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_REF_WORD_INT);
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_REF_WORD_REAL);
+      a68_register_extra_mode (&TOP_MOID (&A68_JOB), M_REF_WORD_COMPLEX);
+    }
+}
+
 /* Set up standenv - general RR including transput.  */
 
 static void
@@ -1220,41 +1280,6 @@ static void
 gnu_prelude (void)
 {
   MOID_T *m = NO_MOID;
-  /* Modes.  */
-  a68_mode (100, "INT", &M_WORD_INT);
-  a68_mode (100, "BITS", &M_WORD_BITS);
-  a68_mode (100, "BYTES", &M_WORD_BYTES);
-  a68_mode (100, "REAL", &M_WORD_REAL);
-
-  a68_mode (100, "COMPL", &M_WORD_COMPLEX);
-  PACK_T *z = NO_PACK;
-  (void) a68_add_mode_to_pack (&z, M_WORD_REAL,
-                              TEXT (a68_add_token (&A68 (top_token), "im")),
-                              NO_NODE);
-  (void) a68_add_mode_to_pack (&z, M_WORD_REAL,
-                              TEXT (a68_add_token (&A68 (top_token), "re")),
-                              NO_NODE);
-  m = a68_add_mode (&TOP_MOID (&A68_JOB), STRUCT_SYMBOL,
-                   a68_count_pack_members (z), NO_NODE, NO_MOID, z);
-  EQUIVALENT (M_WORD_COMPLEX) = m;
-
-  M_REF_WORD_INT = a68_add_mode (&TOP_MOID (&A68_JOB), REF_SYMBOL, 0, NO_NODE,
-                                M_WORD_INT, NO_PACK);
-  M_REF_WORD_REAL = a68_add_mode (&TOP_MOID (&A68_JOB), REF_SYMBOL, 0, NO_NODE,
-                                 M_WORD_REAL, NO_PACK);
-
-  M_REF_WORD_COMPLEX = a68_add_mode (&TOP_MOID (&A68_JOB), REF_SYMBOL, 0, 
NO_NODE,
-                                    M_WORD_COMPLEX, NO_PACK);
-  z = NO_PACK;
-  (void) a68_add_mode_to_pack (&z, M_REF_WORD_REAL,
-                              TEXT (a68_add_token (&A68 (top_token), "im")),
-                              NO_NODE);
-  (void) a68_add_mode_to_pack (&z, M_REF_WORD_REAL,
-                              TEXT (a68_add_token (&A68 (top_token), "re")),
-                              NO_NODE);
-  m = a68_add_mode (&TOP_MOID (&A68_JOB), STRUCT_SYMBOL, 
a68_count_pack_members (z),
-                   NO_NODE, NO_MOID, z);
-  NAME (M_REF_WORD_COMPLEX) = m;
 
   /* Priorities.  */
   a68_prio ("ELEMS", 8);
@@ -1555,6 +1580,11 @@ gnu_prelude (void)
   a68_op (A68_STD, "MINUSAB", m);
   a68_op (A68_STD, "TIMESAB", m);
   a68_op (A68_STD, "DIVAB", m);
+
+  /* Load Algol 68 parts.  */
+  if (!flag_building_libga68)
+    a68_extract_revelation (A68_STANDENV, LINE (INFO (TOP_NODE (&A68_JOB))),
+                           "GNU", "ga68");
 }
 
 /* POSIX prelude.  */
@@ -1571,6 +1601,8 @@ void
 a68_make_standard_environ (void)
 {
   stand_moids ();
+  gnu_moids ();
+
   A68_MCACHE (proc_bool) = a68_proc (M_BOOL, NO_MOID);
   A68_MCACHE (proc_char) = a68_proc (M_CHAR, NO_MOID);
   A68_MCACHE (proc_complex_complex) = a68_proc (M_COMPLEX, M_COMPLEX, NO_MOID);
@@ -1591,6 +1623,7 @@ a68_make_standard_environ (void)
   A68_MCACHE (proc_real_real_real_real_real_real) = a68_proc (M_REAL, M_REAL, 
M_REAL, M_REAL, M_REAL, M_REAL, NO_MOID);
   A68_MCACHE (proc_real_ref_real_ref_int_void) = a68_proc (M_VOID, M_REAL, 
M_REF_REAL, M_REF_INT, NO_MOID);
   A68_MCACHE (proc_void) = a68_proc (M_VOID, NO_MOID);
+
   stand_prelude ();
   if (!OPTION_STRICT (&A68_JOB))
     {
diff --git a/libga68/Makefile.am b/libga68/Makefile.am
index 0f7c028e4095..7730045231bd 100644
--- a/libga68/Makefile.am
+++ b/libga68/Makefile.am
@@ -136,8 +136,8 @@ libga68_la_CFLAGS = $(LIBGA68_GCFLAGS) 
$(LIBGA68_BOEHM_GC_INCLUDES)
 libga68_la_LDFLAGS = -version-info `grep -v '^\#' $(srcdir)/libtool-version` \
                     $(version_arg) $(lt_host_flags) \
                     $(LIBM) $(extra_darwin_ldflags_libga68)
-libga68_la_DEPENDENCIES = libga68.spec $(version_dep) standard.lo posix.lo
-libga68_la_LIBADD = $(LIBGA68_BOEHM_GC_LIBS) standard.lo posix.lo
+libga68_la_DEPENDENCIES = libga68.spec $(version_dep) standard.lo posix.lo 
gnu.lo
+libga68_la_LIBADD = $(LIBGA68_BOEHM_GC_LIBS) standard.lo posix.lo gnu.lo
 
 # Rules to build the Algol 68 code in the library.
 
@@ -153,7 +153,10 @@ LTA68COMPILE = $(LIBTOOL) --tag=A68 $(AM_LIBTOOLFLAGS) 
$(LIBTOOLFLAGS) \
 standard.a68 : standard.a68.in
        $(AWK) -f $(srcdir)/sppp.awk $< > $@
 
-BUILT_SOURCES = standard.a68
+gnu.a68 : gnu.a68.in
+       $(AWK) -f $(srcdir)/sppp.awk $< > $@
+
+BUILT_SOURCES = standard.a68 gnu.a68
 
 # target overrides
 -include $(tmake_file)
diff --git a/libga68/Makefile.in b/libga68/Makefile.in
index 8e428016c85c..0dc0917d95eb 100644
--- a/libga68/Makefile.in
+++ b/libga68/Makefile.in
@@ -480,14 +480,14 @@ libga68_la_LDFLAGS = -version-info `grep -v '^\#' 
$(srcdir)/libtool-version` \
                     $(version_arg) $(lt_host_flags) \
                     $(LIBM) $(extra_darwin_ldflags_libga68)
 
-libga68_la_DEPENDENCIES = libga68.spec $(version_dep) standard.lo posix.lo
-libga68_la_LIBADD = $(LIBGA68_BOEHM_GC_LIBS) standard.lo posix.lo
+libga68_la_DEPENDENCIES = libga68.spec $(version_dep) standard.lo posix.lo 
gnu.lo
+libga68_la_LIBADD = $(LIBGA68_BOEHM_GC_LIBS) standard.lo posix.lo gnu.lo
 
 # Rules to build the Algol 68 code in the library.
 LTA68COMPILE = $(LIBTOOL) --tag=A68 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
        --mode=compile $(A68) $(AM_A68FLAGS)
 
-BUILT_SOURCES = standard.a68
+BUILT_SOURCES = standard.a68 gnu.a68
 MULTISRCTOP = 
 MULTIBUILDTOP = 
 MULTIDIRS = 
@@ -917,6 +917,9 @@ uninstall-am: uninstall-toolexeclibDATA \
 standard.a68 : standard.a68.in
        $(AWK) -f $(srcdir)/sppp.awk $< > $@
 
+gnu.a68 : gnu.a68.in
+       $(AWK) -f $(srcdir)/sppp.awk $< > $@
+
 # target overrides
 -include $(tmake_file)
 
diff --git a/libga68/gnu.a68.in b/libga68/gnu.a68.in
new file mode 100644
index 000000000000..4e9ef9820924
--- /dev/null
+++ b/libga68/gnu.a68.in
@@ -0,0 +1,86 @@
+{ Process this file with sppp.awk  -*- mode: a68 -*- }
+
+{ gnu.a68 - GNU prelude.
+
+  Copyright (C) 2026 Jose E. Marchesi
+
+  GCC is free software; you can redistribute it and/or modify it under
+  the terms of the GNU General Public License as published by the Free
+  Software Foundation; either version 3, or (at your option) any later
+  version.
+
+  GCC is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+  License for more details.
+
+  Under Section 7 of GPL version 3, you are granted additional
+  permissions described in the GCC Runtime Library Exception, version
+  3.1, as published by the Free Software Foundation.
+
+  You should have received a copy of the GNU General Public License
+  and a copy of the GCC Runtime Library Exception along with this
+  program; see the files COPYING3 and COPYING.RUNTIME respectively.
+  If not, see <http://www.gnu.org/licenses/>. }
+
+module GNU =
+def
+    { GNU68-2026-004-fixed-sized-modes }
+
+    {iter L  {} {word}}
+    {iter K  {} {WORDEN}}
+    {iter L_ {} {word_}}
+    pub op = = ({L} compl a,b) bool: (re'a = re'b AND im'a = im'b);
+    pub op EQ = ({L} compl a,b) bool: a = b;
+
+    pub op /= = ({L} compl a,b) bool: NOT (a = b);
+    pub op NE = ({L} compl a,b) bool: a /= b;
+
+    pub op + = ({L} compl a,b) {L} compl: (re'a + re'b, im'a + im'b);
+    pub op +:= = (ref {L} compl a, {L} compl b) ref {L} compl:
+       (a := a + b; a);
+    pub op PLUSAB = (ref {L} compl a, {L} compl b) ref {L} compl:
+       a +:= b;
+
+    pub op - = ({L} compl a) {L} compl: (-re'a, -im'a);
+    pub op - = ({L} compl a,b) {L} compl: (re'a - re'b, im'a - im'b);
+    pub op -:= = (ref {L} compl a, {L} compl b) ref {L} compl:
+       (a := a - b; a);
+    pub op MINUSAB = (ref {L} compl a, {L} compl b) ref {L} compl:
+       a -:= b;
+
+    pub op * = ({L} compl a,b) {L} compl:
+       (re'a * re'b - im'a * im'b, re'a * im'b + im'a * re'b);
+    pub op *:= = (ref {L} compl a, {L} compl b) ref {L} compl:
+       (a := a * b; a);
+    pub op TIMESAB = (ref {L} compl a, {L} compl b) ref {L} compl:
+       a *:= b;
+
+    pub op / = ({L} compl a,b) {L} compl:
+    begin
+          {L} real d = re'(b * CONJ b);
+          {L} compl n = a * CONJ b;
+          (re'n/d, im'n/d)
+    end;
+
+    pub op /:= = (ref {L} compl a, {L} compl b) ref {L} compl:
+       (a := a / b; a);
+    pub op DIVAB = (ref {L} compl a, {L} compl b) ref {L} compl:
+       a /:= b;
+
+    pub op CONJ = ({L} compl z) {L} compl: (re'z, -im'z);
+    pub op ABS  = ({L} compl z) {L} real: {L_}sqrt(re'z*re'z + im'z*im'z);
+
+    pub op ARG = ({L} compl z) {L} real:
+       if {L} real zr = re'z, zi = im'z;
+          zr /= {L} 0 OR zi /= {L} 0
+       then if ABS zr > ABS zi
+            then {L_}arctan(zi/zr)
+                 + {L_}pi/{L} 2*(zi<{L} 0 | {K} SIGN zr - {L} 1 | {L} 1 - {K} 
SIGN zr)
+            else -{L_}arctan(zr/zi) + {L_}pi/{L} 2*{K} SIGN zi
+            fi
+       fi;
+    {reti}
+
+    skip
+fed

Reply via email to