~duangle/scopes#2: 
[PATCH] string-interpolation.sc

# HG changeset patch
# User Westerbly Snaydley <westerbly@gmail.com>
# Date 1597276697 18000
#      Wed Aug 12 18:58:17 2020 -0500
# Node ID f0f2584a4dc0137865abec0f1e4540e09d893e55
# Parent  8b3c98d57d7b4111d1db9a8878ff935f299ab705
added UTF-8 pattern support for the interpolation markers

diff -r 8b3c98d57d7b -r f0f2584a4dc0 lib/scopes/string-interpolation.sc
--- a/lib/scopes/string-interpolation.sc	Wed Aug 12 02:44:54 2020 -0500
+++ b/lib/scopes/string-interpolation.sc	Wed Aug 12 18:58:17 2020 -0500
@@ -10,31 +10,42 @@
     expressions inside them.
 
 spice escape-pattern (str)
-    # because patterns are expected to be very small (1-3 characters),
-    # it will be easier and probably even faster to just prepend a \ to every char.
+    import UTF-8
+    using import itertools
+
+    str as:= string
     let new-pattern =
         # TODO: support UTF-8
-        fold (result = "") for c in (str as string)
-            local c = c
-            switch c # characters in "[]\\^$.|?*+(){}"
-            pass 91:i8
-            pass 93:i8
-            pass 92:i8
-            pass 94:i8
-            pass 36:i8
-            pass 46:i8
-            pass 124:i8
-            pass 63:i8
-            pass 42:i8
-            pass 43:i8
-            pass 40:i8
-            pass 41:i8
-            pass 123:i8
-            pass 125:i8
-            do
-                .. result "\\" (string &c 1:usize)
-            default
-                .. result (string &c 1:usize)
+        ->> str UTF-8.decoder
+            retain
+                inline (c)
+                    switch c
+                    pass (UTF-8.char "[")
+                    pass (UTF-8.char "]")
+                    pass (UTF-8.char "\\")
+                    pass (UTF-8.char "^")
+                    pass (UTF-8.char "$")
+                    pass (UTF-8.char ".")
+                    pass (UTF-8.char "|")
+                    pass (UTF-8.char "?")
+                    pass (UTF-8.char "*")
+                    pass (UTF-8.char "+")
+                    pass (UTF-8.char "(")
+                    pass (UTF-8.char ")")
+                    pass (UTF-8.char "{")
+                    pass (UTF-8.char "}")
+                    do
+                        UTF-8.char "\\"
+                    default
+                        -1
+                map
+                    inline (code-point)
+                        code-point
+            flatten
+            filter
+                (x) -> (x != -1)
+            UTF-8.encoder
+            string.collector 256
     `[new-pattern]
 
 run-stage;
diff -r 8b3c98d57d7b -r f0f2584a4dc0 testing/test_string_interpolation.sc
--- a/testing/test_string_interpolation.sc	Wed Aug 12 02:44:54 2020 -0500
+++ b/testing/test_string_interpolation.sc	Wed Aug 12 18:58:17 2020 -0500
@@ -34,3 +34,12 @@
     ==
         fAlt"this is not a very smart interpolation marker abravarargs...cadabra"
         "this is not a very smart interpolation marker 1 2 3 4"
+
+let prefix:f🤔 = (gen-interpolation-macro "🤔" "🤔")
+run-stage;
+let encoding = "UTF-8"
+test
+    ==
+        f🤔"we also support 🤔encoding🤔 markers!"
+        "we also support UTF-8 markers!"
+print f🤔"we also support 🤔encoding🤔 markers!"
# HG changeset patch
# User Westerbly Snaydley <westerbly@gmail.com>
# Date 1597869862 18000
#      Wed Aug 19 15:44:22 2020 -0500
# Node ID 7e6b1b843bcdda5f328a7752edca6230ddab8d8b
# Parent  f0f2584a4dc0137865abec0f1e4540e09d893e55
small adjustments to string-interpolation and its test

diff -r f0f2584a4dc0 -r 7e6b1b843bcd lib/scopes/string-interpolation.sc
--- a/lib/scopes/string-interpolation.sc	Wed Aug 12 18:58:17 2020 -0500
+++ b/lib/scopes/string-interpolation.sc	Wed Aug 19 15:44:22 2020 -0500
@@ -15,7 +15,6 @@
 
     str as:= string
     let new-pattern =
-        # TODO: support UTF-8
         ->> str UTF-8.decoder
             retain
                 inline (c)
diff -r f0f2584a4dc0 -r 7e6b1b843bcd testing/test_string_interpolation.sc
--- a/testing/test_string_interpolation.sc	Wed Aug 12 18:58:17 2020 -0500
+++ b/testing/test_string_interpolation.sc	Wed Aug 19 15:44:22 2020 -0500
@@ -42,4 +42,3 @@
     ==
         f🤔"we also support 🤔encoding🤔 markers!"
         "we also support UTF-8 markers!"
-print f🤔"we also support 🤔encoding🤔 markers!"
# HG changeset patch
# User Westerbly Snaydley <westerbly@gmail.com>
# Date 1597928486 18000
#      Thu Aug 20 08:01:26 2020 -0500
# Node ID 0e745ccc1a1662fa106474ad9af8b84dfb81e34f
# Parent  7e6b1b843bcdda5f328a7752edca6230ddab8d8b
added a check for illegal UTF-8 bytes in the regexp escape

diff -r 7e6b1b843bcd -r 0e745ccc1a16 lib/scopes/string-interpolation.sc
--- a/lib/scopes/string-interpolation.sc	Wed Aug 19 15:44:22 2020 -0500
+++ b/lib/scopes/string-interpolation.sc	Thu Aug 20 08:01:26 2020 -0500
@@ -39,6 +39,8 @@
                         -1
                 map
                     inline (code-point)
+                        if (code-point < 0)
+                            error "illegal byte in UTF-8 stream"
                         code-point
             flatten
             filter
# HG changeset patch
# User Westerbly Snaydley <westerbly@gmail.com>
# Date 1597218294 18000
#      Wed Aug 12 02:44:54 2020 -0500
# Node ID 8b3c98d57d7b4111d1db9a8878ff935f299ab705
# Parent  7173c4a4d444208b80a284be9f52fbff43cb1307
First version of string-interpolation.sc for evaluation

diff -r 7173c4a4d444 -r 8b3c98d57d7b lib/scopes/string-interpolation.sc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lib/scopes/string-interpolation.sc	Wed Aug 12 02:44:54 2020 -0500
@@ -0,0 +1,90 @@
+#
+    The Scopes Compiler Infrastructure
+    This file is distributed under the MIT License.
+    See LICENSE.md for details.
+
+""""string-interpolation
+    ====
+
+    Implements especially formatted strings that can reference variables and
+    expressions inside them.
+
+spice escape-pattern (str)
+    # because patterns are expected to be very small (1-3 characters),
+    # it will be easier and probably even faster to just prepend a \ to every char.
+    let new-pattern =
+        # TODO: support UTF-8
+        fold (result = "") for c in (str as string)
+            local c = c
+            switch c # characters in "[]\\^$.|?*+(){}"
+            pass 91:i8
+            pass 93:i8
+            pass 92:i8
+            pass 94:i8
+            pass 36:i8
+            pass 46:i8
+            pass 124:i8
+            pass 63:i8
+            pass 42:i8
+            pass 43:i8
+            pass 40:i8
+            pass 41:i8
+            pass 123:i8
+            pass 125:i8
+            do
+                .. result "\\" (string &c 1:usize)
+            default
+                .. result (string &c 1:usize)
+    `[new-pattern]
+
+run-stage;
+
+inline gen-interpolation-macro (begin-pattern end-pattern)
+    if ((begin-pattern == "") or (end-pattern == ""))
+        error "interpolation markers must be at least one character long"
+    fn any->string (values...)
+        inline convert (value)
+            static-if ((typeof value) == string)
+                value
+            else
+                tostring value
+
+        let first rest = (va-split 1 values...)
+        va-lfold (convert (first))
+            inline (__ v result)
+                .. result " " (convert v)
+            (rest)
+    let pattern =
+        ..
+            escape-pattern begin-pattern
+            ".*?"
+            escape-pattern end-pattern
+    sugar interpolate (str)
+        str as:= string
+        let chunks =
+            loop (str chunks = str '())
+                let match? start end = ('match? pattern str)
+                if (not match?)
+                    break ('reverse (cons str chunks))
+                let lhs = (lslice str start)
+                let code =
+                    slice str
+                        start + (countof begin-pattern)
+                        end - (countof end-pattern)
+                let parsed-code = (sc_parse_from_string code)
+                _
+                    rslice str end
+                    cons
+                        cons (qq [any->string]) (parsed-code as list)
+                        cons lhs chunks
+
+        if ((countof chunks) > 1)
+            cons (qq [..]) chunks
+        else
+            cons (qq [embed]) chunks
+
+
+do
+    let gen-interpolation-macro
+    let prefix:f = (gen-interpolation-macro "{" "}")
+    locals;
diff -r 7173c4a4d444 -r 8b3c98d57d7b testing/test_string_interpolation.sc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testing/test_string_interpolation.sc	Wed Aug 12 02:44:54 2020 -0500
@@ -0,0 +1,36 @@
+using import string-interpolation
+using import testing
+
+let ABC = 123
+let CDE = 345
+let str = "banana"
+test
+    ==
+        f"ABC is {ABC}, CDE is {CDE}, and the sum is {(+ ABC CDE)}. This other string is {str}"
+        "ABC is 123, CDE is 345, and the sum is 468. This other string is banana"
+
+test
+    ==
+        f"there is nothing to interpolate here, so the string should remain unchanged."
+        "there is nothing to interpolate here, so the string should remain unchanged."
+
+test
+    ==
+        f"{ an expression start token without a corresponding end is ignored"
+        "{ an expression start token without a corresponding end is ignored"
+
+test-compiler-error
+    f"however { if there's an end token at some point, the first start token is considered. {}"
+
+let varargs... = 1 2 3 4
+test
+    ==
+        f"some ... {varargs...} for you!"
+        "some ... 1 2 3 4 for you!"
+
+let prefix:fAlt = (gen-interpolation-macro "abra" "cadabra")
+run-stage;
+test
+    ==
+        fAlt"this is not a very smart interpolation marker abravarargs...cadabra"
+        "this is not a very smart interpolation marker 1 2 3 4"
Status
REPORTED
Submitter
~radgerayden
Assigned to
No-one
Submitted
8 months ago
Updated
8 months ago
Labels
No labels applied.