World: r3wp

hum... in any case, thanks for remining me about APPLY IN  :-)  you've 
revived my interest in rebcode (even if I might now rely on some 
features of 2.7)

here am i ^^^

It is really the best way to work with objects in efficient code, 
so much so that I requested an IN opcode.

Hi Steeve!

glad you did  :-)

IN doesn't work with structs though, so I requested a set of struct 
opcodes to work with them (SET.S, GET.S, ...).

that would probably be even faster.

since its a simple shift

I meant offset

For structs, yes. For objects, IN and GETW/SETW would be faster since 
you can cache the looked-up word.

It's not that bad a technique in REBOL code either.

Path evaluation has a lot of overhead.

Any questions, Steeve?

BrianH, what is the most rapid, to use a do [my-func var] or an apply 
?

Apply.

hum, and if i have severall apply to do (in sequence) ?

APPLY in a LOOP block or something. Even then, it is much more efficient 
to translate to rebcode and inline when you can - APPLY overhead 
is significant, and DO overhead much more so.

ok

have another question on system/internal/assembly*

can i disactivate the label parsing/replacecing to gain speed when 
i build rebcode functions

?

i d'ont use labels

but i build many many rebcode functions in real time, i need speed

i use a parser to convert Z80 opcodes into rebol opcodes

i attempt to do a Z80 emulator

It really doesn't gain you much speed. The label fixups are done 
once, at rebcode function creation time. After that it just calls 
the offsets - the label statement is a noop. I only do straight offsets 
when generating code (like you are). Be careful though, as the offsets 
are calculated from the end of the branch statement, not the beginning.

This only matters when writing your own offsets. I only noticed when 
I started using the BRAB opcode, and its predecessor BRAW.

anyway, can i replace assembly* by a dummy function ?

You can replace assembly* with a Z80 assembler even.

ok

i noticed that i can join the code of  2 rebcode function without 
re-assemble them

Remember that the current assembler* doesn't do much, and even that 
is done at rebcode function creation time. It has no effect on execution 
time.

If you join these function blocks after the rebcode function is created, 
you may have context issues. It is better to join them before assembly.

yes but i try to do emulation + a debugger , so Z80 opcodes are converts 
step by step

i have no context issues, cause all words i use have the same context

there is no local words in my rebcode functions

You can do code snippets for your emulation/debugger, and concatenation 
for direct execution.

it's what i do

As long as you are careful the semantics shouldn't change.

Remember that these branch statements group statements together into 
basic blocks, so you should break up your code into snippets on boundaries 
between these blocks.

that why i don't use branch statements

branchements are controled outside rebcodes functions

For non-generated code, the only useful branch statement in rebcode 
is BRAB. All others have better structured equivalents.

BTW, the English word for branchements is branches.

i have a main loop wich do the branchements and call the rebcode 
routines

sorry

Just trying to help :)

Are you doing a compiler or an interpreter? A compiler would be faster, 
but would require you to translate branches.

it's an hybrid way

i try to do the two things