util_string: dynamically allocate and expand string lists

String lists grow dynamically, removing the need for preallocated arrays. This simplifies handling of large variable groups in the icon initialization phase.

The output lists of add_to_list are now ALLOCATABLE. They may be passed an unallocated argument, which is treated like an empty list and allocated using the new new_list subroutine. That subroutine initially allocates space for 8 strings. Every time the list needs to grow, the allocated size doubles. This ensures constant amortized runtime for adding to the list. No provisions are made for shrinking the list size, because they are usually short-lived.

The tests for add_to_list are adapted for the new interface, checking list expansion. A new test for new_list is added.

test/fortran/test_util_string.f90

@@ -123,16 +123,18 @@ CONTAINS
     CHARACTER(len=30), ALLOCATABLE, DIMENSION(:) :: str_list1
     CHARACTER(len=30), DIMENSION(2) :: str_list2
     INTEGER :: nitems1, nitems2
-    CALL TAG_TEST("TEST_add_to_list")
-    CALL add_to_list(str_list1, nitems1, ['word1', 'word2', 'word3'])
+    CALL add_to_list(str_list1, nitems1, ['word1', 'word2', 'word3']) ! Implicit allocation
+    CALL TAG_TEST("TEST_add_to_list (1)")
     CALL ASSERT_EQUAL(nitems1 == 3 .AND. ALLOCATED(str_list1) .AND. SIZE(str_list1) >= nitems1, .TRUE.)
     str_list2 = ['word2', 'word4']
     nitems2 = SIZE(str_list2)
     CALL add_to_list(str_list1, nitems1, str_list2, nitems2)
+    CALL TAG_TEST("TEST_add_to_list (2)")
     CALL ASSERT_EQUAL((nitems1 == 4 .AND. str_list1(1) == 'word1' .AND. &
                        str_list1(2) == 'word2' .AND. str_list1(3) == 'word3' &
                        .AND. str_list1(4) == 'word4'), .TRUE.)
     CALL add_to_list(str_list1, nitems1, ['5', '6', '7', '8', '9'])
+    CALL TAG_TEST("TEST_add_to_list (3)")
     CALL ASSERT_EQUAL(nitems1 == 9 .AND. ALLOCATED(str_list1) .AND. SIZE(str_list1) >= nitems1 .AND. &
                       ALL(str_list1(1:nitems1) == [ &
                           'word1', 'word2', 'word3', 'word4', '5    ', '6    ', '7    ', '8    ', '9    ']), .TRUE.)
@@ -141,0+143,0 @@
   SUBROUTINE TEST_add_to_list_1
     CHARACTER(len=30), ALLOCATABLE, DIMENSION(:) :: str_list
     INTEGER :: nitems
-    CHARACTER(len=30) :: str
-    CALL TAG_TEST("TEST_add_to_list_1")
-    CALL add_to_list(str_list, nitems, ['word1', 'word2', 'word3'])
-    str = 'word4'
-    CALL add_to_list(str_list, nitems, str)
+    CALL add_to_list(str_list, nitems, 'word1') ! Implicit allocation
+    CALL TAG_TEST("TEST_add_to_list_1 (1)")
+    CALL ASSERT_EQUAL(nitems == 1 .AND. ALLOCATED(str_list) .AND. SIZE(str_list) >= nitems, .TRUE.)
+    CALL add_to_list(str_list, nitems, 'word2')
+    CALL add_to_list(str_list, nitems, 'word3')
+    CALL add_to_list(str_list, nitems, 'word4')
+    CALL add_to_list(str_list, nitems, 'word2') ! Try to add duplicate
+    CALL TAG_TEST("TEST_add_to_list_1 (2)")
     CALL ASSERT_EQUAL((nitems == 4 .AND. str_list(1) == 'word1' &
                        .AND. str_list(2) == 'word2' .AND. str_list(3) == 'word3' &
                        .AND. str_list(4) == 'word4'), .TRUE.)
-    CALL add_to_list(str_list, nitems, ['5', '6', '7', '8'])
-    CALL add_to_list(str_list, nitems, '9')
+    CALL add_to_list(str_list, nitems, ['5', '6', '7', '8']) ! Fill to allocated size
+    CALL add_to_list(str_list, nitems, '9') ! Expand list
+    CALL TAG_TEST("TEST_add_to_list_1 (3)")
     CALL ASSERT_EQUAL(nitems == 9 .AND. ALLOCATED(str_list) .AND. SIZE(str_list) >= nitems .AND. &
                       ALL(str_list(1:nitems) == [ &
                           'word1', 'word2', 'word3', 'word4', '5    ', '6    ', '7    ', '8    ', '9    ']), .TRUE.)