~radgerayden/patchtesting#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
2 years ago
Updated
2 years ago
Labels
No labels applied.