refactor(strings): replace compiler builtins with the STRING library

Construct literals as STRING values and route string operations through
ordinary library functions and operators. Preserve value ownership in
records, arrays, constants and file I/O.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

4 files changed, 186 insertions, 151 deletions

diff --git a/pseudocode-lib/_exp_string.cps b/pseudocode-lib/_exp_string.cps
deleted file mode 100644
index 975a583..0000000
--- a/pseudocode-lib/_exp_string.cps
+++ /dev/null
@@ -1,123 +0,0 @@
-#LIB
-INCLUDE_OBJ "_exp_string.o"
-TYPE _EXP_STRING_HANDLE = C_TYPE("void*")
-TYPE _EXP_STRING_C_INTEGER = C_TYPE("long long")
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_new() RETURNS _EXP_STRING_HANDLE
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_copy(_EXP_STRING_HANDLE) RETURNS _EXP_STRING_HANDLE
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_from_cstr(C_STRING) RETURNS _EXP_STRING_HANDLE
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_from_count_char(_EXP_STRING_C_INTEGER, C_CHAR) RETURNS _EXP_STRING_HANDLE
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_delete(_EXP_STRING_HANDLE)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_assign(_EXP_STRING_HANDLE, _EXP_STRING_HANDLE)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_assign_cstr(_EXP_STRING_HANDLE, C_STRING)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_concat(_EXP_STRING_HANDLE, _EXP_STRING_HANDLE, _EXP_STRING_HANDLE)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_from_int(_EXP_STRING_HANDLE, _EXP_STRING_C_INTEGER)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_from_real(_EXP_STRING_HANDLE, C_DOUBLE)
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_to_real(_EXP_STRING_HANDLE) RETURNS C_DOUBLE
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_length(_EXP_STRING_HANDLE) RETURNS _EXP_STRING_C_INTEGER
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_left(_EXP_STRING_HANDLE, _EXP_STRING_HANDLE, _EXP_STRING_C_INTEGER)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_right(_EXP_STRING_HANDLE, _EXP_STRING_HANDLE, _EXP_STRING_C_INTEGER)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_mid(_EXP_STRING_HANDLE, _EXP_STRING_HANDLE, _EXP_STRING_C_INTEGER, _EXP_STRING_C_INTEGER)
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_lcase(_EXP_STRING_HANDLE, _EXP_STRING_HANDLE)
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_lcase_char(C_CHAR) RETURNS C_CHAR
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_ucase(_EXP_STRING_HANDLE, _EXP_STRING_HANDLE)
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_ucase_char(C_CHAR) RETURNS C_CHAR
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_asc(_EXP_STRING_HANDLE) RETURNS _EXP_STRING_C_INTEGER
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_asc_char(C_CHAR) RETURNS _EXP_STRING_C_INTEGER
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_chr(_EXP_STRING_HANDLE, _EXP_STRING_C_INTEGER)
-EXTERN "C" EXTERN_FUNCTION _exp_string_impl_is_num(_EXP_STRING_HANDLE) RETURNS C_INT
-EXTERN "C" EXTERN_PROCEDURE _exp_string_impl_output(_EXP_STRING_HANDLE)
-
-CLASS _EXP_STRING
-    PUBLIC _HANDLE : _EXP_STRING_HANDLE
-    OVERLOAD PROCEDURE NEW()
-        _HANDLE <- _exp_string_impl_new()
-    ENDPROCEDURE
-    OVERLOAD PROCEDURE NEW(BYREF Other : _EXP_STRING)
-        _HANDLE <- _exp_string_impl_copy(Other._HANDLE)
-    ENDPROCEDURE
-    OVERLOAD PROCEDURE NEW(Text : C_STRING)
-        _HANDLE <- _exp_string_impl_from_cstr(Text)
-    ENDPROCEDURE
-    OVERLOAD PROCEDURE NEW(Count : INTEGER, Ch : C_CHAR)
-        _HANDLE <- _exp_string_impl_from_count_char((_EXP_STRING_C_INTEGER)Count, Ch)
-    ENDPROCEDURE
-    PROCEDURE DELETE()
-        CALL _exp_string_impl_delete(_HANDLE)
-    ENDPROCEDURE
-    OVERLOAD PROCEDURE OPERATOR<-(BYREF Other : _EXP_STRING)
-        CALL _exp_string_impl_assign(_HANDLE, Other._HANDLE)
-    ENDPROCEDURE
-    OVERLOAD PROCEDURE OPERATOR<-(Text : C_STRING)
-        CALL _exp_string_impl_assign_cstr(_HANDLE, Text)
-    ENDPROCEDURE
-ENDCLASS
-
-OVERLOAD FUNCTION OPERATOR&(A : _EXP_STRING, B : _EXP_STRING) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_concat(Result._HANDLE, A._HANDLE, B._HANDLE)
-    RETURN Result
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_NUM_TO_STR(Number : INTEGER) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_from_int(Result._HANDLE, (_EXP_STRING_C_INTEGER)Number)
-    RETURN Result
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_NUM_TO_STR(Number : REAL) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_from_real(Result._HANDLE, (C_DOUBLE)Number)
-    RETURN Result
-ENDFUNCTION
-FUNCTION _EXP_STRING_STR_TO_NUM(S : _EXP_STRING) RETURNS REAL
-    RETURN (REAL)_exp_string_impl_to_real(S._HANDLE)
-ENDFUNCTION
-FUNCTION _EXP_STRING_LENGTH(S : _EXP_STRING) RETURNS INTEGER
-    RETURN (INTEGER)_exp_string_impl_length(S._HANDLE)
-ENDFUNCTION
-PROCEDURE _EXP_STRING_OUTPUT(S : _EXP_STRING)
-    CALL _exp_string_impl_output(S._HANDLE)
-ENDPROCEDURE
-FUNCTION _EXP_STRING_LEFT(S : _EXP_STRING, Count : INTEGER) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_left(Result._HANDLE, S._HANDLE, (_EXP_STRING_C_INTEGER)Count)
-    RETURN Result
-ENDFUNCTION
-FUNCTION _EXP_STRING_RIGHT(S : _EXP_STRING, Count : INTEGER) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_right(Result._HANDLE, S._HANDLE, (_EXP_STRING_C_INTEGER)Count)
-    RETURN Result
-ENDFUNCTION
-FUNCTION _EXP_STRING_MID(S : _EXP_STRING, Start : INTEGER, Count : INTEGER) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_mid(Result._HANDLE, S._HANDLE, (_EXP_STRING_C_INTEGER)Start, (_EXP_STRING_C_INTEGER)Count)
-    RETURN Result
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_LCASE(S : _EXP_STRING) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_lcase(Result._HANDLE, S._HANDLE)
-    RETURN Result
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_LCASE(Ch : CHAR) RETURNS CHAR
-    RETURN (CHAR)_exp_string_impl_lcase_char((C_CHAR)Ch)
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_UCASE(S : _EXP_STRING) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_ucase(Result._HANDLE, S._HANDLE)
-    RETURN Result
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_UCASE(Ch : CHAR) RETURNS CHAR
-    RETURN (CHAR)_exp_string_impl_ucase_char((C_CHAR)Ch)
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_ASC(S : _EXP_STRING) RETURNS INTEGER
-    RETURN (INTEGER)_exp_string_impl_asc(S._HANDLE)
-ENDFUNCTION
-OVERLOAD FUNCTION _EXP_STRING_ASC(Ch : CHAR) RETURNS INTEGER
-    RETURN (INTEGER)_exp_string_impl_asc_char((C_CHAR)Ch)
-ENDFUNCTION
-FUNCTION _EXP_STRING_CHR(Code : INTEGER) RETURNS _EXP_STRING
-    DECLARE Result : _EXP_STRING
-    CALL _exp_string_impl_chr(Result._HANDLE, (_EXP_STRING_C_INTEGER)Code)
-    RETURN Result
-ENDFUNCTION
-FUNCTION _EXP_STRING_IS_NUM(S : _EXP_STRING) RETURNS BOOLEAN
-    RETURN (BOOLEAN)_exp_string_impl_is_num(S._HANDLE)
-ENDFUNCTION
diff --git a/pseudocode-lib/std.cps b/pseudocode-lib/std.cps
index 955e7da..0ec4b9d 100644
--- a/pseudocode-lib/std.cps
+++ b/pseudocode-lib/std.cps
@@ -1,2 +1,2 @@
 #LIB
-INCLUDE "_exp_string.cps"
+INCLUDE "string.cps"
diff --git a/pseudocode-lib/_exp_string.cc b/pseudocode-lib/string.cc
index 4cfd650..f2f03f6 100644
--- a/pseudocode-lib/_exp_string.cc
+++ b/pseudocode-lib/string.cc
@@ -23,40 +23,40 @@ std::string &text(void *Handle) { return *static_cast<std::string *>(Handle); }
 }
 
 extern "C" {
-void *_exp_string_impl_new() {
+void *_string_impl_new() {
     return checked([] { return new std::string; });
 }
-void *_exp_string_impl_copy(void *Other) {
+void *_string_impl_copy(void *Other) {
     return checked([&] { return new std::string(text(Other)); });
 }
-void *_exp_string_impl_from_cstr(const char *Text) {
+void *_string_impl_from_cstr(const char *Text) {
     return checked([&] { return new std::string(Text); });
 }
-void *_exp_string_impl_from_count_char(long long Count, char Ch) {
+void *_string_impl_from_count_char(long long Count, char Ch) {
     return checked([&] {
         if (Count < 0) throw std::invalid_argument("negative string length");
         return new std::string(static_cast<std::size_t>(Count), Ch);
     });
 }
-void _exp_string_impl_delete(void *Handle) {
+void _string_impl_delete(void *Handle) {
     checked([&] { delete static_cast<std::string *>(Handle); });
 }
-void _exp_string_impl_assign(void *Target, void *Other) {
+void _string_impl_assign(void *Target, void *Other) {
     checked([&] { text(Target) = text(Other); });
 }
-void _exp_string_impl_assign_cstr(void *Target, const char *Text) {
+void _string_impl_assign_cstr(void *Target, const char *Text) {
     checked([&] { text(Target) = Text; });
 }
-void _exp_string_impl_concat(void *Target, void *A, void *B) {
+void _string_impl_concat(void *Target, void *A, void *B) {
     checked([&] { text(Target) = text(A) + text(B); });
 }
-void _exp_string_impl_from_int(void *Target, long long Number) {
+void _string_impl_from_int(void *Target, long long Number) {
     checked([&] { text(Target) = std::to_string(Number); });
 }
-void _exp_string_impl_from_real(void *Target, double Number) {
+void _string_impl_from_real(void *Target, double Number) {
     checked([&] { text(Target) = std::to_string(Number); });
 }
-double _exp_string_impl_to_real(void *Handle) {
+double _string_impl_to_real(void *Handle) {
     return checked([&] {
         std::size_t Consumed = 0;
         double Number = std::stod(text(Handle), &Consumed);
@@ -65,24 +65,24 @@ double _exp_string_impl_to_real(void *Handle) {
         return Number;
     });
 }
-long long _exp_string_impl_length(void *Handle) {
+long long _string_impl_length(void *Handle) {
     return checked([&] { return static_cast<long long>(text(Handle).size()); });
 }
-void _exp_string_impl_left(void *Target, void *Handle, long long Count) {
+void _string_impl_left(void *Target, void *Handle, long long Count) {
     checked([&] {
         const auto &Source = text(Handle);
         auto Length = Count <= 0 ? 0 : std::min(static_cast<std::size_t>(Count), Source.size());
         text(Target) = Source.substr(0, Length);
     });
 }
-void _exp_string_impl_right(void *Target, void *Handle, long long Count) {
+void _string_impl_right(void *Target, void *Handle, long long Count) {
     checked([&] {
         const auto &Source = text(Handle);
         auto Length = Count <= 0 ? 0 : std::min(static_cast<std::size_t>(Count), Source.size());
         text(Target) = Source.substr(Source.size() - Length, Length);
     });
 }
-void _exp_string_impl_mid(void *Target, void *Handle, long long Start, long long Count) {
+void _string_impl_mid(void *Target, void *Handle, long long Start, long long Count) {
     checked([&] {
         const auto &Source = text(Handle);
         auto Position = Start <= 1 ? 0 : std::min(static_cast<std::size_t>(Start - 1), Source.size());
@@ -90,45 +90,45 @@ void _exp_string_impl_mid(void *Target, void *Handle, long long Start, long long
         text(Target) = Source.substr(Position, Length);
     });
 }
-void _exp_string_impl_lcase(void *Target, void *Handle) {
+void _string_impl_lcase(void *Target, void *Handle) {
     checked([&] {
         text(Target) = text(Handle);
         for (char &Ch : text(Target))
             Ch = static_cast<char>(std::tolower(static_cast<unsigned char>(Ch)));
     });
 }
-char _exp_string_impl_lcase_char(char Ch) {
+char _string_impl_lcase_char(char Ch) {
     return checked([&] {
         return static_cast<char>(std::tolower(static_cast<unsigned char>(Ch)));
     });
 }
-void _exp_string_impl_ucase(void *Target, void *Handle) {
+void _string_impl_ucase(void *Target, void *Handle) {
     checked([&] {
         text(Target) = text(Handle);
         for (char &Ch : text(Target))
             Ch = static_cast<char>(std::toupper(static_cast<unsigned char>(Ch)));
     });
 }
-char _exp_string_impl_ucase_char(char Ch) {
+char _string_impl_ucase_char(char Ch) {
     return checked([&] {
         return static_cast<char>(std::toupper(static_cast<unsigned char>(Ch)));
     });
 }
-long long _exp_string_impl_asc(void *Handle) {
+long long _string_impl_asc(void *Handle) {
     return checked([&]() -> long long {
         const auto &Source = text(Handle);
         return Source.empty() ? 0 : static_cast<unsigned char>(Source.front());
     });
 }
-long long _exp_string_impl_asc_char(char Ch) {
+long long _string_impl_asc_char(char Ch) {
     return checked([&]() -> long long { return static_cast<unsigned char>(Ch); });
 }
-void _exp_string_impl_chr(void *Target, long long Code) {
+void _string_impl_chr(void *Target, long long Code) {
     checked([&] {
         text(Target).assign(1, static_cast<char>(static_cast<unsigned char>(Code)));
     });
 }
-int _exp_string_impl_is_num(void *Handle) {
+int _string_impl_is_num(void *Handle) {
     return checked([&]() -> int {
         const auto &Source = text(Handle);
         char *End = nullptr;
@@ -136,11 +136,23 @@ int _exp_string_impl_is_num(void *Handle) {
         return !Source.empty() && End == Source.c_str() + Source.size();
     });
 }
-void _exp_string_impl_output(void *Handle) {
+const char *_string_impl_c_str(void *Handle) {
+    return text(Handle).c_str();
+}
+int _string_impl_compare(void *A, void *B) {
+    return checked([&] { return text(A).compare(text(B)); });
+}
+void _string_impl_input(void *Handle) {
     checked([&] {
-        const auto &Text = text(Handle);
-        std::fwrite(Text.data(), 1, Text.size(), stdout);
-        std::fputc('\n', stdout);
+        std::string Value;
+        int Ch;
+        do { Ch = std::getchar(); } while (Ch != EOF && std::isspace(static_cast<unsigned char>(Ch)));
+        while (Ch != EOF && !std::isspace(static_cast<unsigned char>(Ch))) {
+            Value.push_back(static_cast<char>(Ch));
+            Ch = std::getchar();
+        }
+        if (Ch != EOF) std::ungetc(Ch, stdin);
+        text(Handle) = std::move(Value);
     });
 }
 }
diff --git a/pseudocode-lib/string.cps b/pseudocode-lib/string.cps
new file mode 100644
index 0000000..41181c4
--- /dev/null
+++ b/pseudocode-lib/string.cps
@@ -0,0 +1,146 @@
+#LIB
+INCLUDE_OBJ "string.o"
+TYPE _STRING_HANDLE = C_TYPE("void*")
+TYPE _STRING_C_INTEGER = C_TYPE("long long")
+EXTERN "C" EXTERN_FUNCTION _string_impl_new() RETURNS _STRING_HANDLE
+EXTERN "C" EXTERN_FUNCTION _string_impl_copy(_STRING_HANDLE) RETURNS _STRING_HANDLE
+EXTERN "C" EXTERN_FUNCTION _string_impl_from_cstr(C_STRING) RETURNS _STRING_HANDLE
+EXTERN "C" EXTERN_FUNCTION _string_impl_from_count_char(_STRING_C_INTEGER, C_CHAR) RETURNS _STRING_HANDLE
+EXTERN "C" EXTERN_PROCEDURE _string_impl_delete(_STRING_HANDLE)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_assign(_STRING_HANDLE, _STRING_HANDLE)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_assign_cstr(_STRING_HANDLE, C_STRING)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_concat(_STRING_HANDLE, _STRING_HANDLE, _STRING_HANDLE)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_from_int(_STRING_HANDLE, _STRING_C_INTEGER)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_from_real(_STRING_HANDLE, C_DOUBLE)
+EXTERN "C" EXTERN_FUNCTION _string_impl_to_real(_STRING_HANDLE) RETURNS C_DOUBLE
+EXTERN "C" EXTERN_FUNCTION _string_impl_length(_STRING_HANDLE) RETURNS _STRING_C_INTEGER
+EXTERN "C" EXTERN_PROCEDURE _string_impl_left(_STRING_HANDLE, _STRING_HANDLE, _STRING_C_INTEGER)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_right(_STRING_HANDLE, _STRING_HANDLE, _STRING_C_INTEGER)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_mid(_STRING_HANDLE, _STRING_HANDLE, _STRING_C_INTEGER, _STRING_C_INTEGER)
+EXTERN "C" EXTERN_PROCEDURE _string_impl_lcase(_STRING_HANDLE, _STRING_HANDLE)
+EXTERN "C" EXTERN_FUNCTION _string_impl_lcase_char(C_CHAR) RETURNS C_CHAR
+EXTERN "C" EXTERN_PROCEDURE _string_impl_ucase(_STRING_HANDLE, _STRING_HANDLE)
+EXTERN "C" EXTERN_FUNCTION _string_impl_ucase_char(C_CHAR) RETURNS C_CHAR
+EXTERN "C" EXTERN_FUNCTION _string_impl_asc(_STRING_HANDLE) RETURNS _STRING_C_INTEGER
+EXTERN "C" EXTERN_FUNCTION _string_impl_asc_char(C_CHAR) RETURNS _STRING_C_INTEGER
+EXTERN "C" EXTERN_PROCEDURE _string_impl_chr(_STRING_HANDLE, _STRING_C_INTEGER)
+EXTERN "C" EXTERN_FUNCTION _string_impl_is_num(_STRING_HANDLE) RETURNS C_INT
+EXTERN "C" EXTERN_FUNCTION _string_impl_c_str(_STRING_HANDLE) RETURNS C_STRING
+EXTERN "C" EXTERN_PROCEDURE _string_impl_input(_STRING_HANDLE)
+EXTERN "C" EXTERN_FUNCTION _string_impl_compare(_STRING_HANDLE, _STRING_HANDLE) RETURNS C_INT
+
+CLASS STRING
+    PUBLIC _HANDLE : _STRING_HANDLE
+    OVERLOAD PROCEDURE NEW()
+        _HANDLE <- _string_impl_new()
+    ENDPROCEDURE
+    OVERLOAD PROCEDURE NEW(BYREF Other : STRING)
+        _HANDLE <- _string_impl_copy(Other._HANDLE)
+    ENDPROCEDURE
+    OVERLOAD PROCEDURE NEW(Text : C_STRING)
+        _HANDLE <- _string_impl_from_cstr(Text)
+    ENDPROCEDURE
+    OVERLOAD PROCEDURE NEW(Count : INTEGER, Ch : C_CHAR)
+        _HANDLE <- _string_impl_from_count_char((_STRING_C_INTEGER)Count, Ch)
+    ENDPROCEDURE
+    PROCEDURE DELETE()
+        CALL _string_impl_delete(_HANDLE)
+    ENDPROCEDURE
+    OVERLOAD PROCEDURE OPERATOR<-(BYREF Other : STRING)
+        CALL _string_impl_assign(_HANDLE, Other._HANDLE)
+    ENDPROCEDURE
+    OVERLOAD PROCEDURE OPERATOR<-(Text : C_STRING)
+        CALL _string_impl_assign_cstr(_HANDLE, Text)
+    ENDPROCEDURE
+    FUNCTION C_STR() RETURNS C_STRING
+        RETURN _string_impl_c_str(_HANDLE)
+    ENDFUNCTION
+    PROCEDURE READ_INPUT()
+        CALL _string_impl_input(_HANDLE)
+    ENDPROCEDURE
+ENDCLASS
+
+OVERLOAD FUNCTION OPERATOR&(A : STRING, B : STRING) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_concat(Result._HANDLE, A._HANDLE, B._HANDLE)
+    RETURN Result
+ENDFUNCTION
+OVERLOAD FUNCTION NUM_TO_STR(Number : INTEGER) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_from_int(Result._HANDLE, (_STRING_C_INTEGER)Number)
+    RETURN Result
+ENDFUNCTION
+OVERLOAD FUNCTION NUM_TO_STR(Number : REAL) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_from_real(Result._HANDLE, (C_DOUBLE)Number)
+    RETURN Result
+ENDFUNCTION
+FUNCTION STR_TO_NUM(S : STRING) RETURNS REAL
+    RETURN (REAL)_string_impl_to_real(S._HANDLE)
+ENDFUNCTION
+FUNCTION LENGTH(S : STRING) RETURNS INTEGER
+    RETURN (INTEGER)_string_impl_length(S._HANDLE)
+ENDFUNCTION
+FUNCTION LEFT(S : STRING, Count : INTEGER) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_left(Result._HANDLE, S._HANDLE, (_STRING_C_INTEGER)Count)
+    RETURN Result
+ENDFUNCTION
+FUNCTION RIGHT(S : STRING, Count : INTEGER) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_right(Result._HANDLE, S._HANDLE, (_STRING_C_INTEGER)Count)
+    RETURN Result
+ENDFUNCTION
+FUNCTION MID(S : STRING, Start : INTEGER, Count : INTEGER) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_mid(Result._HANDLE, S._HANDLE, (_STRING_C_INTEGER)Start, (_STRING_C_INTEGER)Count)
+    RETURN Result
+ENDFUNCTION
+OVERLOAD FUNCTION LCASE(S : STRING) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_lcase(Result._HANDLE, S._HANDLE)
+    RETURN Result
+ENDFUNCTION
+OVERLOAD FUNCTION LCASE(Ch : CHAR) RETURNS CHAR
+    RETURN (CHAR)_string_impl_lcase_char((C_CHAR)Ch)
+ENDFUNCTION
+OVERLOAD FUNCTION UCASE(S : STRING) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_ucase(Result._HANDLE, S._HANDLE)
+    RETURN Result
+ENDFUNCTION
+OVERLOAD FUNCTION UCASE(Ch : CHAR) RETURNS CHAR
+    RETURN (CHAR)_string_impl_ucase_char((C_CHAR)Ch)
+ENDFUNCTION
+OVERLOAD FUNCTION ASC(S : STRING) RETURNS INTEGER
+    RETURN (INTEGER)_string_impl_asc(S._HANDLE)
+ENDFUNCTION
+OVERLOAD FUNCTION ASC(Ch : CHAR) RETURNS INTEGER
+    RETURN (INTEGER)_string_impl_asc_char((C_CHAR)Ch)
+ENDFUNCTION
+FUNCTION CHR(Code : INTEGER) RETURNS STRING
+    DECLARE Result : STRING
+    CALL _string_impl_chr(Result._HANDLE, (_STRING_C_INTEGER)Code)
+    RETURN Result
+ENDFUNCTION
+FUNCTION IS_NUM(S : STRING) RETURNS BOOLEAN
+    RETURN (BOOLEAN)_string_impl_is_num(S._HANDLE)
+ENDFUNCTION
+OVERLOAD FUNCTION OPERATOR=(A : STRING, B : STRING) RETURNS BOOLEAN
+    RETURN (INTEGER)_string_impl_compare(A._HANDLE, B._HANDLE) = 0
+ENDFUNCTION
+OVERLOAD FUNCTION OPERATOR<>(A : STRING, B : STRING) RETURNS BOOLEAN
+    RETURN (INTEGER)_string_impl_compare(A._HANDLE, B._HANDLE) <> 0
+ENDFUNCTION
+OVERLOAD FUNCTION OPERATOR<(A : STRING, B : STRING) RETURNS BOOLEAN
+    RETURN (INTEGER)_string_impl_compare(A._HANDLE, B._HANDLE) < 0
+ENDFUNCTION
+OVERLOAD FUNCTION OPERATOR>(A : STRING, B : STRING) RETURNS BOOLEAN
+    RETURN (INTEGER)_string_impl_compare(A._HANDLE, B._HANDLE) > 0
+ENDFUNCTION
+OVERLOAD FUNCTION OPERATOR<=(A : STRING, B : STRING) RETURNS BOOLEAN
+    RETURN (INTEGER)_string_impl_compare(A._HANDLE, B._HANDLE) <= 0
+ENDFUNCTION
+OVERLOAD FUNCTION OPERATOR>=(A : STRING, B : STRING) RETURNS BOOLEAN
+    RETURN (INTEGER)_string_impl_compare(A._HANDLE, B._HANDLE) >= 0
+ENDFUNCTION