Is there a way to do so including creating an other build-markup function ?
Sadly,build-markup uses only global variables: link text says: Note that variables used within tags are always global variables.
Here's a slightly cranky way of doing it using an inner object (bm-1 demonstrates the problem: a and b are printed with their global values; bm-2 is the cranky work around):
a: "global-a"
b: "global-b"
bm-1: func [a b][
print build-markup "<%a%> <%b%>"
]
bm-2: func [a b][
cont: context [
v-a: a
v-b: b
]
print build-markup "<%cont/v-a%> <%cont/v-b%>"
]
bm-1 "aaa" "bbb"
bm-2 "aaa" "bbb"
REBOL3 has reword rather than build-markup. That is much more flexible.
I've patched the build-markup function to be able to use local contexts:
build-markup: func [
{Return markup text replacing <%tags%> with their evaluated results.}
content [string! file! url!]
/bind obj [object!] "Object to bind" ;ability to run in a local context
/quiet "Do not show errors in the output."
/local out eval value
][
content: either string? content [copy content] [read content]
out: make string! 126
eval: func [val /local tmp] [
either error? set/any 'tmp try [either bind [do system/words/bind load val obj] [do val]] [
if not quiet [
tmp: disarm :tmp
append out reform ["***ERROR" tmp/id "in:" val]
]
] [
if not unset? get/any 'tmp [append out :tmp]
]
]
parse/all content [
any [
end break
| "<%" [copy value to "%>" 2 skip | copy value to end] (eval value)
| copy value [to "<%" | to end] (append out value)
]
]
out
]
Here are some example usages:
>> x: 1 ;global
>> context [x: 2 print build-markup/bind "a <%x%> b" self]
"a 2 b"
>> print build-markup/bind "a <%x%> b" context [x: 2]
"a 2 b"
Related
Rebol has apply Creating map function in Red language what's the equivalent of Rebol apply in Red if any ?
Currently, there's no native apply in Red. You can write apply on your own:
apply: func [
"Apply a function to a block of arguments"
fn [any-function!] "Function value to apply"
args [block!] "Block of arguments (to quote refinement use QUOTE keyword)"
/local refs vals val
][
refs: copy []
vals: copy []
set-val: [set val skip (append/only vals val)]
parse args [
some [
'quote set-val
| set val refinement! (append refs to word! val)
| set-val
]
]
do compose [(make path! head insert refs 'fn) (vals)]
]
It works bit differently than Rebol's apply (because I don't like Rebol's apply syntax). If you define some function:
f: func [
foo
/bar
baz
][
reduce [foo bar baz]
]
then here's how to use this apply:
>> apply :f [1 /bar 1]
== [1 true 1]
>> apply :f [quote /bar]
== [/bar false none]
>> apply :f [quote /bar /bar 1]
== [/bar true 1]
See http://red.qyz.cz/apply-and-ufcs.html for details.
I don't really understand if it can be done with bind or anything else, the documentation http://www.rebol.com/docs/words/wbind.html doesn't help as for me. I want to pass block argument from f2 to f1 :
f1: func[block][
foreach b block [
print b
]
]
f2: func[][
a: 1
b: 2
block: [a b]
f1 block
]
When calling
f2
It prints out
a
b
How to make it print out
1
2
while passing [a b] (I don't want to pass [1 2] since it can change all the time and that is not elegant) ? Is it possible with bind or anything else ?
f1: func[block /local i][
foreach i block [
print get i
]
]
or
f1: func[block /local b][
foreach b reduce block [
print b
]
]
There is a need for the local word in Red, as the foreach variable word in Red is not local to the foreach loop.
Would like to detect esc key to escape the forever loop in pseudo code:
forever [
url: ask "Url: "
if (url = esc) [
break
]
]
Is this possible ?
There is no simple answer, you must use own console-port to handle it correctly, here is the part of it taken from one of my old projects:
REBOL [title: "Console port"]
set 'ctx-console make object! [
system/console/busy: none
system/console/break: false
buffer: make string! 512
history: system/console/history
prompt: "## " ;system/console/prompt
spec-char: none
port: none
init: func[][
port: open/binary [scheme: 'console]
set 's-print get in system/words 'print
set 's-prin get in system/words 'prin
set 'prin func[msg /err /inf /user user-data][
ctx-console/clear-line
s-prin reform msg
ctx-console/print-line
]
set 'print func[msg /err /inf /user user-data][
prin rejoin [reform msg newline]
]
s-prin prompt
]
print-line: func[][
s-prin rejoin [ prompt head buffer "^(1B)[" length? buffer "D"]
]
clear-line: func[][
s-prin rejoin [
"^(1B)[" (
(index? buffer) +
(length? prompt) +
(length? buffer))
"D^(1B)[K"
]
]
key-actions: make block! [
#{08} [;BACK
if 0 < length? head buffer [
buffer: remove back buffer
s-prin rejoin [
"^(back)^(1B)[K"
buffer
"^(1B)["
length? buffer "D"
]
]
]
#{7E} [;HOME
s-prin rejoin ["^(1B)[" (index? buffer) - 1 "D"]
buffer: head buffer
]
#{7F} [;DELETE
buffer: remove buffer
s-prin rejoin ["^(1B)[K" buffer "^(1B)[" length? buffer "D"]
]
#{1B} [;ESCAPE
spec-char: copy/part port 1
either spec-char = #{1B} [
print "ESCAPE"
clear-line
set 'print :s-print
set 'prin :s-prin
system/console/break: true
on-escape
][
switch append spec-char copy/part port 1 [
#{5B41} [;ARROW UP
if not tail? history [
clear-line
clear head buffer
s-prin join prompt buffer: copy history/1
history: next history
buffer: tail buffer
]
]
#{5B42} [;ARROW DOWN
clear-line
buffer: head buffer
clear buffer
if all [
not error? try [history: back history]
not none? history/1
] [
buffer: copy history/1
]
s-prin join prompt buffer
buffer: tail buffer
]
#{5B43} [;ARROW RIGHT
if not tail? buffer [
s-prin "^(1B)[C"
buffer: next buffer
]
]
#{5B44} [;ARROW LEFT
if 1 < index? buffer [
s-prin "^(1B)[D"
buffer: back buffer
]
]
]
]
]
]
do-command: func[comm /local e][
set/any 'e attempt compose [do (comm)]
if all [
not unset? 'e
value? 'e
not object? :e
not port? :e
not function? :e
][
print head clear skip rejoin [system/console/result mold :e] 127
if (length? mold :e) > 127 [
print "...^/"
]
]
]
on-enter: func[input-str /local e][
print rejoin [system/console/prompt input-str]
do-command input-str
]
on-escape: func[][halt]
process: func[/local ch c tmp spec-char err][
ch: to-char pick port 1
either (ch = newline) or (ch = #"^M") [;ENTER
tmp: copy head buffer
if empty? tmp [return none]
history: head history
if any [empty? history tmp <> first history ] [
insert history tmp
]
clear-line
buffer: head buffer
clear buffer
print-line
on-enter tmp
][
switch/default to-binary ch key-actions [
either tail? buffer [
s-prin ch ;either local-echo [ch]["*"]
][
s-prin rejoin ["^(1B)[#" ch]
]
buffer: insert buffer ch
]
]
]
]
ctx-console/init
;and now do something with your own console:
wait-list: reduce [ctx-console/port]
forever [
attempt [ready: wait/all wait-list]
if ready [
ctx-console/process
]
]
You will probably like to change the ctx-console/on-escape and ctx-console/on-enter functions.
As a pure console application, I'm pretty sure the answer is no.
esc is used to cancel the execution of the script.
You can disable that use of esc....
system/console/break: false
....And the esc key now does nothing.
If you switch to REBOL/VIEW and are happy to use a pop up request-text box rather than a console ask line, then you may be able to trap esc using insert-event-func.
Let's say I want to generate this output:
public String toString() {
return this.getFirstName() + "," + this.getLastName() + "," + this.getAge();
}
from the template below and a custom recursive build-markup function:
template-toString: {this.get<%property%>() <%either not context.build-markup/EOB [{+ "," +}][""]%> }
build-markup/vars template-toString [property] ["FirstName" "LastName" "Age"]
My problem is to avoid the last element to be concatenate with {+ "," +}
My idea was to use a context.build-markup with an EOB property (End Of Block) that would be set to true when last element is processed. Then I could use in template-toString above either not context.build-markup/EOB [{+ "," +}][""] to concatenate or not with {+ "," +} :
context.build-markup: context [
EOB: false
set 'build-markup func [
{Return markup text replacing <%tags%> with their evaluated results.}
content [string! file! url!]
/vars block-fields block-values
/quiet "Do not show errors in the output."
/local out eval value n max i
][
out: make string! 126
either not vars [
content: either string? content [copy content] [read content]
eval: func [val /local tmp] [
either error? set/any 'tmp try [do val] [
if not quiet [
tmp: disarm :tmp
append out reform ["***ERROR" tmp/id "in:" val]
]
] [
if not unset? get/any 'tmp [append out :tmp]
]
]
parse/all content [
any [
end break
| "<%" [copy value to "%>" 2 skip | copy value to end] (eval value)
| copy value [to "<%" | to end] (append out value)
]
]
][
n: length? block-fields
self/EOB: false
actions: copy []
repeat i n [
append actions compose/only [
;set in self 'EOB (i = n)
set in system/words (to-lit-word pick (block-fields) (i)) get pick (block-fields) (i)
]
]
append actions compose/only [
append out build-markup content
]
foreach :block-fields block-values actions
if any [(back tail out) = "^/" (back tail out) = " " (back tail out) = "," (back tail out) = ";" (back tail out) = "/" (back tail out) = "\"] [
remove back tail out
]
]
out
]
]
But my attempt failed (so I commented ;set in self 'EOB (i = n) because it doesn't work). How to correct the code to get what I want ?
I'm quite certain you could be achieving your goal in a cleaner way than this. Regardless, I can tell you why what you're doing isn't working!
Your n is the expression length? block-fields, and your repeat loop goes up to n. But block-fields contains the single parameter [property]! Hence, it loops from 1 to 1.
You presumably wanted to test against something enumerating over block-values (in this example a range from 1 to 3) and then handle it uniquely if the index reached 3. In other words, your set in self 'EOB expression needs to be part of your enumeration over block-values and NOT block-fields.
This would have given you the behavior you wanted:
n: length? block-values
i: 1
foreach :block-fields block-values compose/only [
set in self 'EOB equal? i n
do (actions)
++ i
]
This absolutely won't work:
append actions compose/only [
set in self 'EOB (i = n)
set in system/words (to-lit-word pick (block-fields) (i)) get pick (block-fields) (i)
]
...because you are dealing with a situation where i and n are both 1, for a single iteration of this loop. Which means (i = n) is true. So the meta-code you get for "actions" is this:
[
set in self 'EOB true
set in system/words 'property get pick [property] 1
]
Next you run the code with a superfluous composition (because there are no PAREN!s, you could just omit COMPOSE/ONLY):
append actions compose/only [
append out build-markup content
]
Which adds a line to your actions meta-code, obviously:
[
set in self 'EOB true
set in system/words 'property get pick [property] 1
append out build-markup content
]
As per usual I'll suggest you learn to use PROBE and PRINT to look and check your expectations at each phase. Rebol is good about dumping variables and such...
You seem to making something simple very complicated:
>> a: make object! [
[ b: false
[ set 'c func[i n] [b: i = n]
[ ]
>> a/b
== false
>> c 1 4
== false
>> a/b
== false
>> c 1 1
== true
>> a/b
== true
It is possible to overide rebol system words like print, make etc., so is it possible to do the same with the path operator ? Then what's the syntax ?
Another possible approach is to use REBOL meta-programming capabilities and preprocess your own code to catch path accesses and add your handler code. Here's an example :
apply-my-rule: func [spec [block!] /local value][
print [
"-- path access --" newline
"object:" mold spec/1 newline
"member:" mold spec/2 newline
"value:" mold set/any 'value get in get spec/1 spec/2 newline
"--"
]
:value
]
my-do: func [code [block!] /local rule pos][
parse code rule: [
any [
pos: path! (
pos: either object? get pos/1/1 [
change/part pos reduce ['apply-my-rule to-block pos/1] 1
][
next pos
]
) :pos
| into rule ;-- dive into nested blocks
| skip ;-- skip every other values
]
]
do code
]
;-- example usage --
obj: make object! [
a: 5
]
my-do [
print mold obj/a
]
This will give you :
-- path access --
object: obj
member: a
value: 5
--
5
Another (slower but more flexible) approach could also be to pass your code in string mode to the preprocessor allowing freeing yourself from any REBOL specific syntax rule like in :
my-alternative-do {
print mold obj..a
}
The preprocessor code would then spot all .. places and change the code to properly insert calls to 'apply-my-rule, and would in the end, run the code with :
do load code
There's no real limits on how far you can process and change your whole code at runtime (the so-called "block mode" of the first example being the most efficient way).
You mean replace (say)....
print mold system/options
with (say)....
print mold system..options
....where I've replaced REBOL's forward slash with dot dot syntax?
Short answer: no. Some things are hardwired into the parser.