AltME groups: search

I know. OK, maybe I need an advice. I was looking into some C code 
educatory example, which contained something like:

char multi[5][10];

decomposed to:

    multi[0] = {'0','1','2','3','4','5','6','7','8','9'}
    multi[1] = {'a','b','c','d','e','f','g','h','i','j'}
    multi[2] = {'A','B','C','D','E','F','G','H','I','J'}
    multi[3] = {'9','8','7','6','5','4','3','2','1','0'}
    multi[4] = {'J','I','H','G','F','E','D','C','B','A'}


which gets stored in a memory block of a "0123456789abcdefghijABCDEFGHIJ9876543210JIHGFEDCBA" 
value.


If I would be supposed (for any reason :-), to interface to such 
a construct, I would simply use a pointer in Red, and would be responsible 
to manually decompose/treat the value of arrays, not to break it 
for the C level code?

And, as you know, an array type and a pointer type are (for most 
things) interchangeable, a `char[50]` is the same as a `char*`, therefore 
a `char[5][10]` is also the same as a `char*`.

another question :) how to get pointer to integer! ? as byte-ptr! 
converts the value and doesn't return address.

If I create struct! inside function and return pointer to that struct 
(as I cannot return struct), how can I get the struct from that pointer?

Oh right, the pointer is returned from the function, not the value

You should check the allocation for being a null pointer, though

It looks like we haven't tested floats pointer arithmetic enough.

I've pushed the enhanced get-word syntax support, so it's now possible 
to get a pointer on integer!, byte!, float! and float32! variables 
(without having to wrap them in a struct!). For example:

	s: declare int-ptr!
	a: 123
	s: :a
	print s/value		;-- will output 123


I will add the ARM backend support for that and update the documentation 
tonight.

As c-string! and struct! are already implicit pointers, the only 
pointed datatypes allowed are integer! and byte! (logic! pointer 
is not needed).

Pointer declaration is only required for local pointer variables 
in functions' specification block. In such case, the datatype declaration 
can be omitted and left to the inferencer to guess.

The main drawback right now to support direct Red script execution 
is REBOL inability to execute native code from memory. The workaround 
would be to provide a DLL to pass the memory pointer and call the 
Red code, but as I aim at a single Red binary, this option wouldn't 
be very satisfying.

This is the merge that seems to have caused the problem:

Schulz:Red peter$ git checkout master
Switched to branch 'master'
Schulz:Red peter$ git merge upstream/master
Updating 525097b..ffb1f68
Fast-forward

 red-system/compiler.r                           |   77 ++++++++++++++---------
 red-system/linker.r                             |    2 +-

 red-system/loader.r                             |   67 +++++++++++++++-----

 red-system/targets/IA-32.r                      |   33 ++++++++--
 red-system/targets/target-class.r               |   13 ++--
 red-system/tests/source/compiler/pointer-test.r |    4 +-
 6 files changed, 136 insertions(+), 60 deletions(-)

Well I changed some text in this file, I changed it online in a black 
background box where I could not see my cursor nor the arrow pointer, 
so it sucked :( 

I thought it would be possible to edit the file offline but that 
is something to find out how to do next time ;)

Now I added a comment and it says I want to commit 182 changes into 
the master branch, which is not what I want, but Github says I want 
that. Including my comments it could be I typed in total 182 characters 
including the ones I deleted (?) but the 182 are the commits from 
the 0.3.0 branche I think. 

Me and my friend Github >:|

The compiler is using two ways to encode the fact that a function 
is used as a callback:

- through the CDECL attribute presence (destined to be called by 
external code)

- through the internal CALLBACK flag that is assigned to all functions 
that get their pointer passed as argument (get-word! syntax).

Normally a function can't be used before it's defined. How could 
I pass a pointer to a function that's not defined yet?

Fixed missing function! pointer dereferencing in ARM backend, all 
my Red tests are now running fine on Linux-ARM backend.

Run-All    v0.8.2
Quick-Test v0.9.1
REBOL       2.7.8.4.2
Red/System Test Suite

ok - logic.............................81 / 81
ok - byte..............................40 / 40
ok - c-string..........................20 / 20
ok - struct...........................116 / 116
ok - pointer...........................69 / 69
ok - cast..............................88 / 88
ok - alias.............................23 / 23
ok - length............................11 / 11
ok - null..............................11 / 11
ok - enum..............................19 / 19
ok - float.............................60 / 60
ok - float32...........................55 / 55
ok - lib...............................13 / 13
ok - get-pointer........................5 / 5
ok - float-pointer.....................61 / 61
ok - namespace........................109 / 109
ok - not...............................44 / 44
ok - size..............................37 / 37
ok - function...........................6 / 6
ok - case..............................64 / 64
ok - switch............................85 / 85
ok - exit...............................9 / 9
ok - return............................25 / 25
ok - modulo............................29 / 29
ok - math-mixed.......................114 / 114
ok - infix..............................2 / 2
ok - conditional.......................13 / 13
ok - common............................16 / 16
ok - byte-auto.......................3636 / 3636
ok - integer-auto....................2778 / 2778
ok - maths-auto......................1661 / 1661
ok - float-auto......................1617 / 1617
ok - float32-auto....................1023 / 1023
ok - alias-compile......................3 / 3
ok - cast-compile......................16 / 16
ok - comp-err...........................2 / 2
ok - exit-err...........................3 / 3
ok - int-literals-err...................1 / 1
ok - output.............................3 / 3
ok - return-err.........................5 / 5
ok - conditions-required-err...........23 / 23
ok - inference-err......................1 / 1
ok - callback-err.......................2 / 2
ok - infix-compile......................3 / 3
ok - not-compile........................1 / 1
ok - print..............................3 / 3
ok - enumerations compile..............12 / 12
ok - pointer-compile....................2 / 2
ok - namespace compiler tests...........5 / 5

ok - Red/System Test Suite..........12031 / 12031
       in 0:00:42.94891

In R3, a symbol is the internal unique string that a word refers 
to. A word is a pointer to a symbol and another to its binding. Same 
in Red?

People overestimate what linking means. It really is as simple as 
a pointer, the same thing that it means in a linked list.

Jerry: here is a quick overview:


Red values are stored contiguously in series slots (128-bit cells). 
Series buffers are allocated from large chunks of memory of type 
series-frame!. Series value in slots store just a head offset and 
a pointer to a node!. The node! is another pointer to the series 
buffer. So series buffer are indirectly accessed, allowing them to 
be moved in memory (for reallocating with bigger/smaller size or 
moved by GC).

A series buffer has header, with OFFSET and TAIL pointers that define 
respectively the begin and end of series slots. The OFFSET pointer 
allow to reserve space at head of the series for optimizing insertions 
at head. Series slots size can be 1 (binary/UTF-8/Latin-1), 2 (UCS-2), 
4 (UCS-4) or 16 (value!) bytes wide.

Oldes: C does have pointer arithmetic, which is, in many ways, isomorphic 
to SKIP

For handle!, what type are you using to be an opaque pointer-sized 
type that all pointer operations are prohibited on? Can such a thing 
be typedefed?

If you had an ability to create an opaque value of any size that 
will fit in a value slot, or maybe just limited to pointer size, 
only accessible from Red/system code, that would be a good replacement 
for handle!.

Adrian, tablets with styluses are rare now; the iPad led the way 
toward finger-only interfaces. It's been announced that the Surface 
Pro will have a stylus, but it's a passive one. The Android tablets 
with styluses are passive too, just using the stylus for a sharper 
pointer. An active stylus is an expensive peice of electronics, while 
a passive stylus is just plastic with maybe some metal or rubber 
on it, so you can see why they're preferring passive now. Hover is 
going away for a lot of platforms, or was never there for some of 
the new ones.

Red/System Question: In Struct A, there is a menber which points 
to struct B. In Struct B, there is a member which is a function pointer, 
whose parameter is a pointer to Struct A. ... How can I do this in 
Red/System. This is not a fiction case. I am studying SQLite surce 
code, struct sqlite3_file and struct sqlite3_io_methods are exactly 
like this.

There are no arrays in this bootstrap version of Red/System. So you 
have to manage this with a pointer:

Red/System []

s: declare struct! [
  c  [byte!]
  i1 [integer!]
  i2 [integer!]
  i3 [integer!]
]

; intialise the structure
s/c: #"a"
s/i1: 1
s/i2: 2
s/i3: 3

;create a pointer and point it at the first integer
i: as integer! s

i: i + 4                          ;; set i to address of first integer
ip: as pointer! [integer!] i

;; add the integers
sum: 0
count: 3
until [
  sum: sum + ip/value
  ip: ip + 1
  count: count - 1
  count = 0
]

print ["The sum of the integers is " sum lf]

Red/System Questions:


I am translating a piece of code from C to Red/System, I don't know 
how to translate the following C code:


success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone,  (void 
* volatile *)&_zone_); // C

my problems are: 

1. In Red/Sys, _sqliteZone_ is a struct! (which is a pointer in Red/Sys), 
so I cannot use :_zone_ to get it's address.
2. "(void * volatile *)" in C => "as byte-ptr!" in Red/Sys ??

Thanks!

1. _zone_ is a struct pointer. I need to pass a pointer to a struct 
pointer as the 3rd parameter, that's why I try to use get-word here.

For 1., you can achieve it this way:

    s: declare struct! [n [integer!]]
    p: declare int-ptr!
    p/value: as-integer s

then `p` becomes a pointer on `s`.


I might extend get-word syntax to struct! and pointer! too, someone 
just needs to add a ticket to Github to remind me of that.

I usually solve such double references by wrapping the needed pointer 
in an extra struct. See the *-reference! types here:

You should wait for me to add the marshalling and unmarshalling functions 
(that will be used everywhere Red needs to interface with non-Red 
code). In your code example, it should be: 1 + length? version (as 
it needs to account for terminal NUL character). Also, you need to 
get sure that the source c-string! buffer is always available or 
make a copy of it (a pointer to it is stored as a UTF-8 cache, unused 
yet, but intended for speeding up I/O, still experimental, not sure 
it will stay for v1.0).

With the implementation of a random function on Red/System I have 
some questions:

#DEFINE seems to become obsolete towards version 2, no preprocessor 
anymore, so any progress on a decision? https://github.com/dockimbel/Red/wiki/Alternatives-to-Red-System-pre-processor-%23define


How are you supposed to implement an array, I can figure out some 
things about using a pointer, but I cannot believe it will work with 
the example value of 40000000h 

http://static.red-lang.org/red-system-specs.html#section-4.8(.3)

I do not have a clue if this is a realistic value as a memory-address, 
that is why a simple array could come in handy.


At this moment I will not worry about support of a L(ong) or 64 bit 
type, I'll work with 32 bits for now.

How are you supposed to implement an array, I can figure out some 
things about using a pointer, but I cannot believe it will work with 
the example value of 40000000h

What are you missing from using pointers?


I do not have a clue if this is a realistic value as a memory-address, 
that is why a simple array could come in handy.


The example is just showing how to do a dereferencing. It will probably 
crash on most systems if you use it with that value (reading should 
be safe on Windows, but writing not, as it is the default read-only 
memory starting page for PE executables). If you have a better alternative 
example that can work for real on all OS, feel free to submit a pull 
request. For example, retrieving the pointer value from an OS or 
C lib call would maybe be better (but much longer). My intention 
in this example was just to show how to dereference a pointer, how 
the pointer is initialized is a lesser concern.

Can I pass function pointer as an argument to another function in 
Red/System?

Also, in some places you have to cast the function pointer to an 
integer to pass it

Since Red needed jump tables, you can also go the other way around, 
and cast an integer/pointer to a function, then call it

Thanks!  When I use load-image, it looks like it is returning a pointer. 
 Is that correct?

If 'load-image returns a pointer, how do I know when I have reached 
the end of the image?

Better yet, assuming 'load-image returns a pointer, how do I access 
the first memory location referenced by the pointer?

See the function spec in GDK.reds. It returns a pointer to an image! 
struct, so if you want to access the image internally, you have to 
go by that struct definition

I have fixed a pointer arithmetic bug on ARM backend. Now all Red 
tests, including interpreter's one are passing (same as for IA-32), 
console is working fully too. I have a few more tests to add before 
making the 0.3.2 release tomorrow (finally!).

I plan to write an HOW-TO guide for that someday, but in the meantime 
and in a nutshell, this is what is required:

1) NAT_<name> enum entry in %macros.reds (order matters!)


2) pointer entry in REGISTER argument block (same order as in macros) 
in %natives.reds


3) an entry point implementation in %natives.reds (if the code is 
too big you can move it elsewhere as long as the entry point is in 
natives.

What if I want native, which takes one integer! argument? stack/arguments 
seems to return pointer

stack/arguments will return you a pointer on a series slot in stack. 
If you want to access it's data value, you need:

    int: as red-integer! stack/arguments
    print int/value

Modifying is straightforward:
    int/value: int/value + 1		;-- incrementing example.


Last return value should be at stack/arguments position, in this 
case, it is already.

From a routine, if str is a red-string! pointer, this is the dispatch 
code you would need to use:

s: GET_BUFFER(str)
switch GET_UNIT(str) [
	Latin-1 [...conversion code...]
	UCS-2 [...conversion code...]
	UCS-4 [...conversion code...]
]

Currently no, the freeing function requires a memory frame pointer 
in addition to the buffer pointer. It is meant for internal use only 
for now.

So I must call some commands in the middle, instead of just data 
and setting pointer to it, right?

Line 369: it's for getting the memory pointer for last section, but 
it seems it's lacking an offset for skipping that last section size.

Ok, so the main problem will be, that oh/headers-size = 1024, but 
the pointer to code as a first section is 512. Now I must find why.

The pointer initialisation earlier needs to be

It should actually crash on what you have now, but if it doesn't, 
it pokes a value over an unitialised pointer, so any value in your 
program could be corrupted

OTOH, you can always use pointer arithmetics to get a 0-base indexing 
model.

About the pointer, I got the example of pointer/value: value somewhere, 
not saying from the fossil repository but might very well be so. 
The pointer: :value suggested confuses me. I tend to stick to what 
I had figured out. I prefer to avoid pointers almost always at all 
costs because of the trouble they can be. A good description is needed 
of how they are best used in  Red(/System).

pointer/value: value

pointer: :value

initialises the pointer itself. It sets the address of where the 
array is in memory

You have to initialise a pointer before you can use it

Yes, but the C code is not dereferencing the pointer there; it's 
initialising the pointer

You can always have an unsigned integer using a simple pointer.

The deobfuscating Knuth's random program project is progressing into 
its final stage. It turned out that with getting the results of the 
program the same only the first part of the puzzle got solved. To 
use it in real programs you use the provided ran_arr_next function. 
This involved some pointer aritmetic that is not 100%  supported 
by Red/System. I finally got the function to produce the same results 
as the C version. The downside is it is now quite a mess with pointer 
indeces and other variables, so a lot of cleaning up to do and/or 
rework only using the index on the array approach.

This involved some pointer aritmetic that is not 100%  supported 
by Red/System.
 What is it lacking precisely?

It is just slightly different. The possibility to go back to the 
first element of the array or store that address. :(ran_arr_buf/1) 
would make it a lot easier. 

I already had a lot of help from Peter on this (thumbs up!) and I 
made good progress by now.

I get the pointer of the array and I can go up and down  using + 
and -, this works great, and the pointer is going along with it then 
and I suspect that if I do 
ptr: ran_arr_buf 
and I progress ran_arr_buf by 1 that I progress ptr too.

I now kinda solved it by using an additional variable. When I reach 
a 100, I subtract 100 from the array ran_array_buf to go back. 

Tonight and tomorrow I have some time to clean up my code and I can 
experiment some more. 

It is proven it can be done, but keeping the extra variable is surely 
slowing down compared to C's pure pointer solution.

my trouble seems to arise from the different roles the array and 
the pointer play in the C code vs the Red/System code. In C the pointer 
is used as indicator for initialisation and signals when a kind of 
reshuffle is required and it points to the next generated value. 
In Red/System the array points to the current/next value and a pointer 
is not needed, and you can no longer use it as before to signal the 
status. This complicates things in this case.

Oh nice effect. array1: 1 2 3 4 5 
m: 2
;;print array/m ;; 2
array1: array1 + 2
;;print array/m ;; 5

it is tricky to move the array pointer around, beware of the dog 
;)

You seem quite confused about pointers in Red/System. 


1) There's no "array" as distinct entity in Red/System, but you have 
indexed access, so you can "simulate" arrays to some extent.


2) "In C the pointer is used as indicator for initialisation and 
signals when a kind of reshuffle is required and it points to the 
next generated value." I don't understand this sentence, you should 
stick to C terminology (terms like "signals", "reshuffle" and "generated 
value" are alien to me in a C language context).


3) "In Red/System the array points to the current/next value and 
a pointer is not needed, and you can no longer use it as before to 
signal the status." I don't understand this one either... There's 
no array, only pointers. "to signal the status" has no meaning to 
me...sorry.

You should try passing the function! pointer as integer! then type-cast 
it inside the function. IIRC, function! cannot be  yet used in a 
Red/System func spec block.

I ask this obviously because I want to replicate the REBOL behaviour 
of the random function that takes different arguments like random 
"abcdef" shuffeling the string; random 1.0 giving a random real between 
0 and 1; random 6 giving an integer from 1 up and to 6. 

So in a sense I need a return type that differs too. REBOL (R3) solves 
this as far as I understand it by returning the pointer to the value 
(and somehow the type of the variable).I ask this obviously because 
I want to replicate the REBOL behaviour of the random function that 
takes different arguments like random "abcdef" shuffeling the string; 
random 1.0 giving a random real between 0 and 1; random 6 giving 
an integer from 1 up and to 6. 

So in a sense I need a return type that differs too. REBOL (R3) solves 
this as far as I understand it by returning the pointer to the value 
(and somehow the type of the variable).

img1 is a pointer to an array of those bytes, I should have said.

Further, the bumping of r, g and b each iteration is relatively much 
work, because you're also having to use them as indexes. It's more 
efficient to make a byte pointer for each and advance those

But it's probably even faster to iterate through the image with one 
integer pointer, because the pixels happen to be four bytes, and 
then use indexes of 2, 3 and 4 for r, g and b

So are you saying that if 'img1 is a pointer, to do the following?

	img1r: img1 + 2
	img1g: img1 + 3
	img1b: img1 + 4

and then

	img1r: img1r + 4
	img1g: img1g + 4
	img1b: img1b + 4

would be faster than what I'm doing now?

Finished my first crack at recursion in Red/System.  Works great! 
 Uncovered a bug (not in recursion, but in pointer indexing), but 
found a way to work around it for now.

In Red/System:

p: declare int-ptr! 				;; pointer 

i: 1                                                             
             ;; integer

p: :i						;; set p to address of i
print as integer! p				;; prints the address of p

      ;; the cast (as integer!) is to allow print to treat the value as
						;; an intteger
print p/value					;;  prints the value of i
						;; no cast needed as i is already an integer!
print p/1					;; equivalent to print p/value

Hope this helps.

gives you a pointer to memory address 64, which is invalid

Remember that a c-string! is a pointer to a memory address. Much 
like a string! in REBOL is a reference to the storage of a series 
value that can be referenced by multiple string!s, each with their 
own index

In the case of read-string you get a c-string!, so you can get the 
size with LENGTH?. For read-file-binary that's not possible, so you 
pass a pointer to an integer! to be informed about the read size

If you want to print an integer in hex format in Red/System, you 
can also achieve it by a simple casting to a pointer type:

    print as byte-ptr! int

Red/System: Could it be that if you 
#define MAX-SIZE 100
my-array: as int-ptr! allocate MAX-SIZE * size? integer!
then using  
my-array/MAX-SIZE 
gives a compilation error??
*** Compilation Error: undefined pointer index variable

It was enabled by the function pointer casting in Red 0.3.0 and the 
new functionality of the preprocessor. It proves that such a low 
level and performance critical thing can be done with Red

Guiseppe: "Could it be written as: ..."
TO ANY doesn't work.
but ANY [TO "..." BREAK | TO "..." BREAK] works.

just be careful using ANY and TO together, because they both don't 
advance the series pointer. So you can easily put the console in 
an infinit loop (escape key also doesn't work)

How can I convert an integer! that is a pointer to a C struct returned 
by a library function to a binary! ?

With more C code that copies the binary to a REBOL-allocated buffer. 
You can't deallocate a pointer in REBOL.

Will this work?

    LPINT-def: [value [integer!]] none
    LPINT: make struct! LPINT-def none

    make-LPINT: does [make struct! LPINT-def none]

    get-dereferenced-data: func [

        {Given a pointer to memory, copy the target data into a REBOL struct.}
        pointer [struct!]   "LPINT structure"

        struct-def [block!] "Contains a sub-struct that is the real struct 
        you want."
        /local struct data orig-pointer result
    ] [

        struct: make struct! compose/deep/only [ ; make wrapper struct
            sub [struct! (struct-def)]
        ] none

        orig-pointer: third struct              ; store original inner pointer

        change third struct third pointer       ; change inner pointer to 
        ref'd data

        data: copy third struct/sub             ; copy data from the inner 
        struct
        ;print mold data

        change third struct orig-pointer        ; restore inner pointer

        result: make struct! struct-def none    ; make result struct

        change third result data                ; change data in result struct
        ;probe result
        struct: data: orig-pointer: none
        ;recycle
        result
    ]

It's from some old code, so no guarantees.

ok it seems to work. it becomes:

 integer-address: get-address "hello" ; function courtesy of Anton 
 Rolls
	pointer: make-LPINT
	pointer/value: integer-address
	probe third get-dereferenced-data pointer [l1 [int] l2 [int]]

You can't deallocate a pointer in REBOL.

 - that is false, use the http://www.fm.tul.cz/~ladislav/rebol/library-utils.r

thanks graham. 
endo - looking at cURL...thanks for the pointer

Question about an example from the R3 docs:

str: "abcdef"
end: find str "d"
for s str end 1 [print s]
abcdef
bcdef
cdef
def


find finds the d at position 4, if I replace end with 4, I get the 
same result.
However: type? end says string! and no pointer

If I replace the text in str, end still equals to "def", so it does 
not point
at str any more.
Can someone explane this?

In Rebol, there is no "pointer" (C like).

string!, binary! are series. Series are groups of elements (character, 
octet) so a word! (like str or end) associated to a serie hold also 
a position on it.

I discovered some interesting PARSE functionality, which I have not 
known about before. TO and THRU with integer arguments seem to do 
absolute positioning:

>> parse "abcd" ["abc" to 2 "bcd"]
== true


Anyone seen this before? I added a CC ticket as a reminder to document 
it (http://issue.cc/r3/1964) -- if anyone knows about a place where 
this is documented already, I'd be happy about a pointer.

Ah, I see. A "gob value" is just a pointer to the real gob structure.

(when summing REBGOB and REBGBO while subtracting the pointer.

Some exmplanation:


W->top_of_series is a stack holding the different types of series 
being entered in the lexer, defined as:

#define BLOCK_BEGIN_T		58
#define PAREN_BEGIN_T		59
#define LONG_STRING_BEGIN_T	60
#define PATH_BEGIN_T		61
#define GET_PATH_BEGIN_T	62
#define LIT_PATH_BEGIN_T	63
#define BINARY_BEGIN_T		64
#define SET_GET_PATH_T		65


The code about trace is just, if tracing is on or off in World. W->top_of_code 
is a pointer to where the code for the virtual machine in World is 
being created, and W->code is the bottom of that stack in instructions, 
W->top the top. do_string executes a string of World code.

thank you ladislave for single int variable that's easy (like header) 
but for file content it's ver hard and harder I think to attribute 
to a REBOL struct based pointer the content of the file

that's not that way it has to be done sorry I made a mistake. It's 
only a: SMD2Header

but in this case you can't have a declaration like SMD2Header *myheader; 
that is the common way to do it in C SMD2Header struct will became 
a type in C, In rebol you only make a pointer to the struct so with 
vectorials struct based array mofifying one data will modify all 
data in the array

if you want to load 3 MD2 files you need only to make other main 
pointer to the information you retrieve from the file

Gabriele, That is great !

I hadn't noticed the extra info poping up. Just that simple extra 
info is very helpful when inspecting/reading code (well for me anyway). 
Thank you.

The fact I hadn't noticed it might be a counter argument to Sunanda's 
fear of being annoyed by it. You really have to leave your pointer 
on it.


Any new language (natural or artificial) feels like "Scriptio continua" 
( http://en.wikipedia.org/wiki/Scriptio_continua) 

at first and all these visual cues are very helpfull in building 
the program's tree in your mind.


Imagine yourself a beginner at german reading a text that would have 
been colorized to accentuate its different elements. Hovering over 
a colored word would give you a translation or even maybe just a 
picture to prevent you from thinking in your first language.

I think of Rebol very differently than most people I assume, but 
I have created languages, so I look at them from the inside out.


To Rebol is a giant state-machine that operates on strings.  It is 
a statemachine because it "remembers" what you did to a string last.



Imagine if all you had was sets of strings: "abcdefghijklmnopqrstuvwxyz" 
"1234567890" "one two three four" "name: Bob phone: 123-4567 Age: 
46"


Rebol tracks these strings, and keeps some overhead information for 
them such as where the current pointer (cursor) is in them.  That 
is about it.

Now, lets create 400 variations of string commands.


We will want a way to pull just the age out of that last string. 
 We create a word called "Select"  you pass Select a word (a substring) 
such as "age", and it return the next separate substring, in this 
case "46"


So there really are not 400 commands, actually there are more like 
5, and all these other commands are variations.

So all no pointer math here.

No pointer math, like in Java. But maybe they are pointers anyway, 
of similar.