https://gcc.gnu.org/g:83b35da8f581e93ba130ded8afb4487f3c15124f

commit r16-8094-g83b35da8f581e93ba130ded8afb4487f3c15124f
Author: Jose E. Marchesi <[email protected]>
Date:   Sat Mar 14 16:57:08 2026 +0100

    a68: fix string and character multiplication
    
    This patch fixes the string operator for string and character
    multiplication, to adjust to the semantics specified by the RR.  In
    particular, multiplying by a negative number or zero must result in
    the empty string.
    
    Signed-off-by: Jose E. Marchesi <[email protected]>
    
    gcc/algol68/ChangeLog
    
            * a68-low-strings.cc (a68_string_mult): Adjust to RR semantics for
            negative or zero factor argument.
            * ga68.texi (String operators): Adjust documentation accordingly.
    
    gcc/testsuite/ChangeLog
    
            * algol68/execute/mult-char-1.a68: Multiplying a char or string by
            negative or zero factor results in the empty string.
            * algol68/execute/mult-string-3.a68: Likewise.
            * algol68/execute/mult-string-2.a68: Likewise.
            * algol68/execute/mult-string-1.a68: Likewise.

Diff:
---
 gcc/algol68/a68-low-strings.cc                  | 9 ++++++---
 gcc/algol68/ga68.texi                           | 6 +++---
 gcc/testsuite/algol68/execute/mult-char-1.a68   | 6 ++++--
 gcc/testsuite/algol68/execute/mult-string-1.a68 | 8 ++++----
 gcc/testsuite/algol68/execute/mult-string-2.a68 | 8 ++++----
 gcc/testsuite/algol68/execute/mult-string-3.a68 | 8 ++++----
 6 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/gcc/algol68/a68-low-strings.cc b/gcc/algol68/a68-low-strings.cc
index 5af83bf944dd..ea02397e9af4 100644
--- a/gcc/algol68/a68-low-strings.cc
+++ b/gcc/algol68/a68-low-strings.cc
@@ -191,16 +191,19 @@ a68_string_mult (tree str, tree factor)
 
   str = save_expr (str);
   tree ssize_one_node = ssize_int (1);
-  tree res = a68_lower_tmpvar ("res%", CTYPE (M_STRING), str);
+  tree res = a68_lower_tmpvar ("res%", CTYPE (M_STRING),
+                              fold_build1 (INDIRECT_REF, CTYPE(M_STRING),
+                                           a68_low_gen (M_STRING, 0, NULL,
+                                                        false /* use_heap 
*/)));
   tree index = a68_lower_tmpvar ("index%", ssizetype, ssize_one_node);
 
   /* Begin of loop body.  */
   a68_push_range (NULL);
 
-  /* if (index == FACTOR) break;  */
+  /* if (index > FACTOR) break;  */
   a68_add_stmt (fold_build1 (EXIT_EXPR,
                             void_type_node,
-                            fold_build2 (GE_EXPR, ssizetype,
+                            fold_build2 (GT_EXPR, ssizetype,
                                          index,
                                          fold_convert (ssizetype, factor))));
 
diff --git a/gcc/algol68/ga68.texi b/gcc/algol68/ga68.texi
index bbf2387b61e4..da19ddbb329a 100644
--- a/gcc/algol68/ga68.texi
+++ b/gcc/algol68/ga68.texi
@@ -2754,9 +2754,9 @@ Dyadic operator that yields the concatenation of the 
given string
 
 @deftypefn Operator {} {*} (= (@B{int} a, @B{string} b) @B{string})
 @deftypefnx Operator {} {*} (= (@B{string} b, @B{int} a) @B{string})
-Dyadic operator that yields the string @code{a} concatenated @code{a}
-times to itself.  If @code{a} is less than zero then it is interpreted
-to be zero.
+Dyadic operator that yields the string composed of @code{a}
+concatenated copies of @code{b}.  If @code{a} is less than zero then
+it is interpreted to be zero.
 @end deftypefn
 
 @subsection Composition combined with assignation
diff --git a/gcc/testsuite/algol68/execute/mult-char-1.a68 
b/gcc/testsuite/algol68/execute/mult-char-1.a68
index 67af07323b4a..5760697a5fe4 100644
--- a/gcc/testsuite/algol68/execute/mult-char-1.a68
+++ b/gcc/testsuite/algol68/execute/mult-char-1.a68
@@ -1,8 +1,10 @@
 # { dg-options "-fstropping=upper" }  #
 BEGIN ASSERT ("a" * 3 = "aaa");
       ASSERT ("" * 1 = "");
-      ASSERT ("x" * 0 = "x");
+      ASSERT ("x" * -1= "");
+      ASSERT ("x" * 0 = "");
       ASSERT (3 * "a" = "aaa");
       ASSERT (1 * "" = "");
-      ASSERT (0 * "x" = "x")
+      ASSERT (0 * "x" = "");
+      ASSERT (-20 * "" = "")
 END
diff --git a/gcc/testsuite/algol68/execute/mult-string-1.a68 
b/gcc/testsuite/algol68/execute/mult-string-1.a68
index b0d49178bd1e..db3afc658caf 100644
--- a/gcc/testsuite/algol68/execute/mult-string-1.a68
+++ b/gcc/testsuite/algol68/execute/mult-string-1.a68
@@ -1,9 +1,9 @@
 # { dg-options "-fstropping=upper" }  #
 BEGIN STRING foo = "foo";
-      ASSERT (foo * -10 = "foo");
-      ASSERT (-10 * foo = "foo");
-      ASSERT (foo * 0 = "foo");
-      ASSERT (0 * foo = "foo");
+      ASSERT (foo * -10 = "");
+      ASSERT (-10 * foo = "");
+      ASSERT (foo * 0 = "");
+      ASSERT (0 * foo = "");
       ASSERT (foo * 1 = "foo");
       ASSERT (1 * foo = "foo");
       ASSERT (foo * 2 = "foofoo");
diff --git a/gcc/testsuite/algol68/execute/mult-string-2.a68 
b/gcc/testsuite/algol68/execute/mult-string-2.a68
index 670dcbf16d60..b14083828d5f 100644
--- a/gcc/testsuite/algol68/execute/mult-string-2.a68
+++ b/gcc/testsuite/algol68/execute/mult-string-2.a68
@@ -1,9 +1,9 @@
 # { dg-options "-fstropping=upper" }  #
 BEGIN []CHAR foo = ("f","o","o");
-      ASSERT (foo * -10 = "foo");
-      ASSERT (-10 * foo = "foo");
-      ASSERT (foo * 0 = "foo");
-      ASSERT (0 * foo = "foo");
+      ASSERT (foo * -10 = "");
+      ASSERT (-10 * foo = "");
+      ASSERT (foo * 0 = "");
+      ASSERT (0 * foo = "");
       ASSERT (foo * 1 = "foo");
       ASSERT (1 * foo = "foo");
       ASSERT (foo * 2 = "foofoo");
diff --git a/gcc/testsuite/algol68/execute/mult-string-3.a68 
b/gcc/testsuite/algol68/execute/mult-string-3.a68
index a8d3726d0dfa..54a859535b3e 100644
--- a/gcc/testsuite/algol68/execute/mult-string-3.a68
+++ b/gcc/testsuite/algol68/execute/mult-string-3.a68
@@ -1,9 +1,9 @@
 # { dg-options "-fstropping=upper" }  #
 BEGIN FLEX[3]CHAR foo := ("f","o","o");
-      ASSERT (foo * -10 = "foo");
-      ASSERT (-10 * foo = "foo");
-      ASSERT (foo * 0 = "foo");
-      ASSERT (0 * foo = "foo");
+      ASSERT (foo * -10 = "");
+      ASSERT (-10 * foo = "");
+      ASSERT (foo * 0 = "");
+      ASSERT (0 * foo = "");
       ASSERT (foo * 1 = "foo");
       ASSERT (1 * foo = "foo");
       ASSERT (foo * 2 = "foofoo");

Reply via email to