Problem with context and property

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开发者_C百科 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