Cleanup parsing of macros (#66)

* Cleanup parsing of macros

The symbol macro W"" no longer supports $ interpolation
The expression macro W`` supports $ interpolation, but now does it directly rather than converting via text

* fix printing of exponents

* update README

Author: simonbyrne

README.md

@@ -20,16 +20,16 @@ julia> W"Sin"
 W"Sin"
 
 julia> sin1 = W"Sin"(1.0)
-W"Sin"(1.0)
+W`Sin[1.0]`
 
 julia> sinx = W"Sin"(W"x")
-W"Sin"(W"x")
+W`Sin[x]`
 ```
 
 To parse an expression in the Wolfram Language, you can use the `W` cmd macro (note the backticks):
 ```julia
 julia> W`Sin[1]`
-W"Sin"(1)
+W`Sin[1]`
 ```
 
 `weval` evaluates an expression:
@@ -38,10 +38,10 @@ julia> weval(sin1)
 0.8414709848078965
 
 julia> weval(sinx)
-W"Sin"(W"x")
+W`Sin[x]`
 
 julia> weval(W"Integrate"(sinx, (W"x", 0, 1)))
-W"Plus"(1, W"Times"(-1, W"Cos"(1)))
+W`Plus[1, Times[-1, Cos[1]]]`
 ```
 
 Keyword arguments can be used to pass local variables
@@ -58,24 +58,25 @@ MathLink also overloads the `+`, `-`, `*`, `/`  operations.
 julia> using MathLink
 
 julia> W"a"+W"b"
-W"Plus"(W"a",W"b")
+W`Plus[a, b]`
 
 julia> W"a"+W"a"
-W"Plus"(W"a",W"a")
+W`Plus[a, a]`
 
 julia> W"a"-W"a"
-W"Plus"(W"a",W"Minus"(W"a"))
+W`Plus[a, Minus[a]]`
 ```
 
 One can toggle automatic use of `weval`  on-and-off using `set_GreedyEval(x::Bool)`
 
 ```julia
-julia>set_GreedyEval(true)
+julia> set_GreedyEval(true);
+
 julia> W"a"+W"b"
-W"Plus"(W"a",W"b")
+W`Plus[a, b]`
 
 julia> W"a"+W"a"
-W"Times"(2,W"a")
+W`Times[2, a]`
 
 julia> W"a"-W"a"
 0
@@ -88,23 +89,23 @@ The package also contains extensions to handle fractions.
 
 ```julia
 julia> weval(1//2)
-W"Rational"(1, 2)
+W`Rational[1, 2]`
 
 julia> (4//5)*W"a"
-W"Times"(W"Rational"(4, 5), W"a")
+W`Times[Rational[4, 5], a]`
 
 julia> W"a"/(4//5)
-W"Times"(W"Rational"(5, 4), W"a")
+W`Times[Rational[5, 4], a]`
 ```
 
 and complex numbers
 
 ```julia
 julia> im*W"a"
-W"Times"(W"Complex"(0, 1), W"a")
+W`Times[Complex[0, 1], a]`
 
 julia> im*(im*W"c")
-W"Times"(-1, W"c")
+W`Times[-1, c]`
 ```
 
 

src/display.jl

@@ -26,7 +26,7 @@ export HasGraphicsHead, HasRecursiveGraphicsHead, W2Tex
 
 
 #### Code to produce LaTex strings
-W2Tex(x::WTypes) = weval(W`ToString@TeXForm[#]&`(x))
+W2Tex(x::WTypes) = weval(W"ToString"(W"TeXForm"(x)))
 
 #### Allow latex string to be shown when supported. Relevant for the jupyter notebook.
 

src/eval.jl

@@ -59,11 +59,55 @@ end
 wevalstr(T, expr) = wevalstr(_defaultlink(), T, expr)
 wevalstr(expr) = wevalstr(Any, expr)
 
+"""
+    MathLink.parseexpr(str::AbstractString)
+
+Parse a string `str` as a Wolfram Language expression.
+"""
 function parseexpr(str::AbstractString)
     r = weval(W"ToExpression"(str, W"StandardForm", W"Hold"))
     r.args[1]
 end
 
+"""
+    W`expr`
+
+Parse a string `expr` as a Wolfram Language expression. 
+"""
 macro W_cmd(str)
-    quote parseexpr($(esc(Meta.parse("\"$(escape_string(str))\"")))) end
+    #quote parseexpr($(esc(Meta.parse("\"$(escape_string(str))\"")))) end
+    string_expr = Meta.parse("\"$(escape_string(str))\"")
+    subst_dict = Dict{WSymbol,Any}()
+    if string_expr isa String
+        string = string_expr
+    elseif string_expr isa Expr && string_expr.head == :string
+        for i in eachindex(string_expr.args)
+            arg = string_expr.args[i]
+            if !(arg isa String)
+                sym = weval(W"Unique"(W"JuliaWSTP"))
+                subst_dict[sym] = arg
+                string_expr.args[i] = "($(sym.name))"
+            end
+        end
+        string = join(string_expr.args)
+    else
+        error("Invalid string expression: $string_expr")
+    end
+    wexpr = parseexpr(string)
+    to_julia_expr(wexpr, subst_dict)
+end
+
+function to_julia_expr(wexpr::WExpr, subst_dict)
+    head = to_julia_expr(wexpr.head, subst_dict)
+    args = map(x->to_julia_expr(x, subst_dict), wexpr.args)
+    :(WExpr($head, [$(args...)]))
 end
+function to_julia_expr(wsym::WSymbol, dict)
+    if haskey(dict, wsym)
+        return esc(dict[wsym])
+    else
+        return wsym
+    end
+end
+to_julia_expr(val, dict) = val
+

src/link.jl

@@ -35,6 +35,23 @@ function open!(link::Link, args::AbstractString)
     return link
 end
 
+function open!(link::Link, args::Vector)
+    # MLOpenString
+    # local link
+    err = Ref{Cint}()
+    ptr = ccall((:MLOpenArgcArgv, mlib), CLink,
+                 (Env, Cint, Ptr{Cstring}, Ptr{Cint}),
+                 env, length(args), args, err)
+    if err[] != 0
+        error("Could not open MathLink link")
+    end
+    link.ptr = ptr
+
+    refcount_inc()
+    finalizer(close, link)
+    return link
+end
+
 open(args::AbstractString) = open!(Link(C_NULL), args)
 
 function Base.close(link::Link)
@@ -45,9 +62,37 @@ function Base.close(link::Link)
     end
 end
 
+function getname(link::Link)
+    # WSLINK WSGetLinkName(WSLINK link)
+    ptr = ccall((:MLUTF8LinkName, mlib), Cstring, (CLink,), link)
+    ptr == C_NULL && throw(MathLinkError(link))
+    str = unsafe_string(ptr)
+    ccall((:MLReleaseUTF8LinkName, mlib), Cvoid, (CLink,Cstring), link, ptr)
+    return str
+end
+
+function duplicate(link::Link, name::AbstractString)
+    # WSLINK WSDuplicateLink(WSLINK link, int *errp)
+    err = Ref{Cint}()
+    ptr = ccall((:MLDuplicateLink, mlib), CLink, (CLink, Cstring, Ptr{Cint}), link, name, err)
+    if err[] != 0
+        throw(MathLinkError(link))
+    end
+    newlink = Link(ptr)
+    refcount_inc()
+    finalizer(close, newlink)
+    return newlink
+end
+
+
 function _defaultlink()
     if defaultlink.ptr == C_NULL
-        args = "-linkname '\"$mker\" -mathlink' -linkmode launch"
+        args = [
+            "-linkname",
+            "\"$mker\" -mathlink",
+            "-linkmode",
+            "launch",
+        ]
         open!(defaultlink, args)
 
         # Ignore first input packet

src/types.jl

@@ -40,7 +40,7 @@ Base.show(io::IO, s::WSymbol) = print(io, 'W', '"', s.name, '"')
 Base.:(==)(a::WSymbol, b::WSymbol) = a.name == b.name
 
 macro W_str(str)
-    quote WSymbol($(esc(Meta.parse("\"$(escape_string(str))\"")))) end
+    :(WSymbol($str))
 end
 
 """
@@ -81,7 +81,7 @@ julia> weval(W`Function[x,x+1]`(2))
 3
 ```
 """
-struct WExpr <: WTypes
+mutable struct WExpr <: WTypes
     head
     args
 end
@@ -94,20 +94,40 @@ function Base.:(==)(a::WExpr, b::WExpr)
     return true
 end
 
-function Base.show(io::IO, w::WExpr)
-    show(io, w.head)
-    print(io, '(')
-    isfirst = true
-    for arg in w.args
-        if !isfirst
+function Base.show(io::IO, wexpr::WExpr)
+    print(io, "W`")
+    print_wexpr(io, wexpr)
+    print(io, "`")
+end
+
+function print_wexpr(io::IO, wexpr::WExpr)
+    print_wexpr(io, wexpr.head)
+    print(io, '[')
+    if length(wexpr.args) > 0
+        print_wexpr(io, wexpr.args[1])
+        for arg in wexpr.args[2:end]
             print(io, ", ")
-        else
-            isfirst = false
+            print_wexpr(io, arg)
         end
-        show(io, arg)
     end
-    print(io, ')')
+    print(io, ']')
+end
+print_wexpr(io::IO, wsym::WSymbol) = print(io, wsym.name)
+print_wexpr(io::IO, wreal::WReal) = print(io, wreal.value)
+print_wexpr(io::IO, wint::WInteger) = print(io, wint.value)
+function print_wexpr(io::IO, x::Float64) 
+    s = split(string(x),'e')
+    if length(s) == 1
+        print(io, x)
+    else
+        print(io, s[1], "*^", s[2])
+    end
 end
+print_wexpr(io::IO, x::Int) = print(io, x)
+print_wexpr(io::IO, x::String) = show(io, x)
+print_wexpr(io::IO, x) = print(io, "\$(", x, ")")
+
+
 
 
 function (w::WSymbol)(args...; kwargs...)

test/runtests.jl

@@ -137,9 +137,11 @@ end
 
 @testset "interpolation" begin
     x = exp(1)
-    @test W`Sin[$x]` == W"Sin"(x)
-
+    @test W`Sin[$x]` == W"Sin"(x)    
     @test W`Cos[$(log(2))]` == W"Cos"(log(2))
+
+    @test W`Sin[$(1.2e19)]` == W`Sin[1.2*^19]`
+    @test string(W`Sin[$(1.2e19)]`) == "W`Sin[1.2*^19]`"
 end
 
 
@@ -284,15 +286,12 @@ end
 
     ###Testing that MIME form exists for the text/latex option of show.
     io = IOBuffer();
-    ioc = IOContext(io, :limit => true, :displaysize => (10, 10)) 
-    show(ioc,"text/plain",W"a")
-    @test String(take!(io)) == "W\"a\""
-    show(ioc,"text/plain",W"a"+W"b")
-    @test String(take!(io)) == "W\"Plus\"(W\"a\", W\"b\")"
+    context = IOContext(io, :limit => true, :displaysize => (10, 10)) 
+    @test sprint(show,"text/plain",W"a"; context) == "W\"a\""
+    @test sprint(show,"text/plain",W"a"+W"b"; context) == "W`Plus[a, b]`"
 
     set_texOutput(true)
-    show(ioc,"text/latex",W"a"+W"b")
-    @test String(take!(io)) == "\$a+b\$"
+    @test sprint(show,"text/latex",W"a"+W"b") == "\$a+b\$"
     @test showable("text/latex",W"a"+W"b")
     set_texOutput(false)
     @test !showable("text/latex",W"a"+W"b")