World: r3wp

In the phrase.  "Print index :x", what does putting a colon before 
a variable do again?

Oops I meant "Print index? :x"

Not sure - I remember seeing it in others' parse rules, so I just 
put it there and it worked  '^^
Take it out and see what happens lol

:)

I think it was like get-word or something

; Did you try this?
data: read/lines to-file Readfile
fields: [note category flag]
foreach x data [
    set fields parse x ","
    ; do something
]

In particular, remember not to use parse/all

>> parse {"Hello, World", "Blah"} ","
== ["Hello, World" "Blah"]

Hi BrianH;

  Yes I did try that and the problem was that even though I specified 
  the "," as the delimiter, it came across an embedded quote #"^"" 
  and split the input at the quote.  Rebol Shouldn't have split it 
  up that way, to my understanding.  I will post some simple data to 
  test.

Embedded quotes should be escaped somehow.

Please include some troublesome data if you could.

This data was exported by PalmOS.  I like the Palm desktop for keeping 
track on notes/,memos addresses but the  search engine sucks badly. 
 Therefore I wanted to export the data to allow a nice Rebol search 
on it..  Therefore, the PalmOS export function does "escape" an embedded 
quote by quoting it again.  Ex:
Press the "Home" button
becomes
Press the 
Home
 button.

truth (as far as i know) is:   word  is is a shortcut for :word  
but there are a few places such as inside parse where the shortcut 
does not work so you need to make it explicit

I will get some troubleshooting data posted in a minute.

Tomc:  Do I understand that :word would be like "get word" except 
in a parse sentence?

Wait I said that wrong

Tomc:  Do I understand that :word would be like "get word" and needed 
in a parse sentence but you can just use the shortcut 'word' most 
everywhere else?

The colon before the word prevents the interpreter from evaluating 
active values like functions and parens. It's a safety thing.

works for me

you can use :word everywhere you would use word

as far as i know

Except when you want an active value assigned to the word to be evaluated, 
like when you are calling a function.

and that would be get 'word  not get word

In parse rules the :word means something different (not in the code 
blocks in parens).

Thanks Tomc and BrianH.  I'll chew on it for a while.  Meanwhile 
I'm working on building some test data for the first problem.

in the pars rume (not the paren) it means  "be here now"

okay so in the parse rules (except in a parenthesized code block) 
it means "be here now"?

but what does 'be here now' mean?

to change to point you are in what you are parsing   backtracking 
or jumping ahead

Thanks

Setting the parse position.

inside the parens it means what is in what I am parsing at the point 
pointed to by :word

BrianH, correct except not, I think, parens:
>> foreach word [(1 + 2)][print mold word]
(1 + 2)

That's interesting. Parens and paths used to be active - oh yeah, 
that was changeda while ago. Still, there are some value types that 
are active (function types, lit-path, lit-word) and if you think 
you will get one of these you should disable their evaluation by 
referencing them with a get-word, unless you intend them to be evaluated.

parens changed at around View 1.2.10

both parens and paths changed between  View 1.2.1 and 1.2.5, actually.

Gordon: I did not read this thread in a whole but as for converting 
CSV string to/from Rebol blocks, here is some fully functionnal functions 
:

;***** Conversion function from/to CSV format
csv-to-block: func [

 "Convert a string of CSV formated data to a Rebol block. First line 
 is header."
	csv-data [string!] "CSV data."

 /separator separ [char!] "Separator to use if different of comma 
 (,)."
	/without-header "Do not include header in the result."

 /local out line start end this-string header record value data chars 
 spaces chars-but-space

 ; CSV format information http://www.creativyst.com/Doc/Articles/CSV/CSV01.htm
] [
	out: copy []
	separ: any [separ #","]
	

 ; This function handle replacement of dual double-quote by quote 
 while copying substring
	this-string: func [s e] [replace/all copy/part s e {""} {"}]
	; CSV parsing rules

 header: [(line: copy []) value any [separ value] (if not without-header 
 [append/only out line])]

 record: [(line: copy []) value any [separ value] (append/only out 
 line)]

 value: [any spaces data any spaces (append line this-string start 
 end)]

 data: [start: some chars-but-space end: | #"^"" start: any [some 
 chars | {""} | #"," | newline] end: #"^""]
	chars: complement charset rejoin [ {"} separ newline]
	spaces: charset exclude { ^-} form separ
	chars-but-space: exclude chars spaces
	
	parse/all csv-data [header any [newline record] any newline end]
	out
]

block-to-csv: func [
	"Convert a block of blocks to a CSV formated string." 
	blk-data [block!] "block of data to convert"
	/separator separ "Separator to use if different of comma (,)."
	/local out csv-string record value v
] [
	out: copy ""
	separ: any [separ #","]
	; This function convert a string to a CSV formated one

 csv-string: func [val] [head insert next copy {""} replace/all copy 
 val {"} {""} ]
	record: [into [some [value (append out #",")]]]

 value: [set v string! (append out csv-string v) | set v any-type! 
 (append out form v)]
	

 parse/all blk-data [any [record (remove back tail out append out 
 newline)]]
	out
]

there's also the sql csv thingy in the library

DideC: Thanks.  I've copied and pasted it for review and added it 
to my local public library.  This script should be useful especially 
with the html help page.   Documentation on a script is very rare 
and much appreciated.


Graham: Did a search using  "librarian" and search term of  "sql 
cvs" and didn't come up with anything.  Although, I think we've got 
it covered now anyhow.

Trying to do some macro expansion in text ...

This is not working :(

expand-macros: func [tmp [string!] macros [block!]
	/local white-rule rule len lexp
] [
	white-rule: charset [#" " #"^/"]
	foreach [macro expansion] macros [
        len: length? macro
		lexp: length? expansion
		rule:  compose/deep copy [

            [ to here: white-rule (macro) white-rule ( change/part here expansion 
            len  ?? macro) lexp skip ]
            to end
        ]
		parse/all tmp [some [rule]]
	]
	tmp
]

Are macros marked by some starting character? That would make this 
easier to implement.

Also, it would help to know whether macro expansions can contain 
further macros.

no, they can be any characters (alphanumeric), but should not contain 
further macros.

ise if the macros are delimited you should be able to do it in one 
pass

What I was trying to do above is to look for the macro text preceded 
by a space or newline, and ending in a space or newline.

and then replace in situ.

leaving the whitespace unaffected.

in that case sorting them from long to short to begin with will foil 
recursive macro rxpansion

at  the macros and expansons single tokens