/home/gian/Progetti/falcon/core/include/falcon/pcodes.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define FALCON_PCODE_MINOR   8
#define FALCON_PCODE_VERSION   2
#define FLC_PCODE_COUNT   0x70
#define P_ADD   0x20
 ADD: OP1 + OP2 -> A.
#define P_ADDS   0x26
 ADDS: add to self, OP1 + OP2 -> OP1.
#define P_AND   0x4B
 AND: Logical AND if (op1 is true and op2 is true ) true->A.
#define P_ANDS   0x2E
 ANDS: self binary and ( OP1 & OP2 ) -> OP1.
#define P_BAND   0x2B
 BAND: Binary and ( OP1 & OP2 ) -> A.
#define P_BNOT   0x1A
 BNOT: Binary NOT ( ~OP1 ) -> A.
#define P_BOOL   0x08
 BOOL: Check is the parameter is true or false, and sets A to 0 or 1.
#define P_BOR   0x2C
 BOR: Binary OR ( OP1 | OP2 ) -> A.
#define P_BXOR   0x2D
 BXOR: Binary XOR ( OP1 ^ OP2 ) -> A.
#define P_CALL   0x3A
 CALL <int32>, $sym.
#define P_CLOS   0x5C
 Create a closure.
#define P_DEC   0x10
 DEC: Dec prefix DEC OP1: OP1 - 1 -> OP1, OP1-> A.
#define P_DECP   0x57
 DEC Postfix DECP V : V->A, V := V - 1 -> B.
#define P_DIV   0x23
 DIV: OP1 / OP2 -> A.
#define P_DIVS   0x29
 DIVS: divide from self, OP1 / OP2 -> OP1.
#define P_END   0x00
 END: terminate.
#define P_EQ   0x32
 EQ: Compares OP1 and OP2, and if they are equal 1 -> A, else 0 -> A.
#define P_EVAL   0x60
 EVAL Perform functional evaluation, direct call or return the value as-is FORB OP1 -> A := if OP1 is callable if OP1 is array eval(op1) else OP1() else OP1.
#define P_FORB   0x67
 FORB Forward binding FORB OP1, OP2 -> A := lbind( OP1, OP2 ).
#define P_FORK   0x1D
 FORK: Creates a coroutine jumping at OP2 position.
#define P_GE   0x35
 GE: Compares OP1 and OP2, and if OP1 >= OP2 1 -> A, else 0 -> A.
#define P_GENA   0x0A
 GENA: Generates an array given the OP1 previous elements in the stack.
#define P_GEND   0x0B
 GEND: Generates a dictionray given the OP1*2 previous elements in the stack.
#define P_GENR   0x31
 GENR: Generates an range object [OP1, OP2] -> A.
#define P_GEOR   0x16
 GEOR: Generates an open range object [OP1,*[ -> A.
#define P_GT   0x34
 GT: Compares OP1 and OP2, and if OP1 > OP2 1 -> A, else 0 -> A.
#define P_IFF   0x39
 IFF <int32>, $sym If OP2 is false then jumps to OP1 (OP1 -> PC).
#define P_IFT   0x38
 IFT <int32>, $sym If OP2 is true then jumps to OP1 (OP1 -> PC).
#define P_IN   0x46
 IN: sets A to 1 if OP1 is in set OP2, else sets A to 0.
#define P_INC   0x0F
 INC: Inc prefix INC OP1: OP1 + 1 -> OP1, OP1-> A.
#define P_INCP   0x56
 INC postfix INCP V : V->A, V := V + 1 -> B.
#define P_INDI   0x62
 INDI: Indirect symbol reference; get the value of the string OP1.
#define P_INST   0x3B
 INST $sym, <int32>.
#define P_IPOP   0x14
 IPOP: Pops last OP1 elements from the stack.
#define P_JMP   0x09
 JMP <int32>: Jumps at given position, OP1 -> PC.
#define P_JTRY   0x18
 JTRY: jump out of a try, going at OP1 and popping the try stack.
#define P_LD   0x1E
 LD: Loads OP1 in OP2 OP1 -> OP2.
#define P_LDAS   0x40
 LDAS <int32>, V: Load all in stack.
#define P_LDP   0x3E
 LDV: Load from object OP1 the property OP2 in A, OP1.OP2 -> A.
#define P_LDPT   0x52
 LDPT: Load from object OP1 the property OP2 in OP3, OP1.OP2 -> OP3.
#define P_LDRF   0x1F
 LDRF: Loads a reference to OP1 in OP2, &OP1 -> OP2.
#define P_LDV   0x3D
 LDV: Load from vector OP1 the item at OP2 in A, OP1[ OP2 ] -> A.
#define P_LDVT   0x51
 LDVT: Load from vector OP1 the item at OP2 in OP3, OP1[ OP2 ] -> OP3.
#define P_LE   0x37
 LE: Compares OP1 and OP2, and if OP1 <= OP2 1 -> A, else 0 -> A.
#define P_LNIL   0x05
 LNIL: Load nil into the parameter, nil -> OP1.
#define P_LSB   0x5F
 Load from byte or character from sting.
#define P_LT   0x36
 LT: Compares OP1 and OP2, and if OP1 < OP2 1 -> A, else 0 -> A.
#define P_MOD   0x24
 MOD: OP1 % OP2 -> A.
#define P_MODS   0x2A
 MODS: self module, OP1 % OP2 -> OP1.
#define P_MUL   0x22
 MUL: OP1 * OP2 -> A.
#define P_MULS   0x28
 MULS: multiply to self, OP1 * OP2 -> OP1.
#define P_NEG   0x11
 NEG: Negates OP1, - OP1 -> OP1.
#define P_NEQ   0x33
 NEQ: Compares OP1 and OP2, and if they are equal 0 -> A, else 1 -> A.
#define P_NOIN   0x47
 NOIN: sets A to 0 if OP1 is in set OP2, else sets A to 1.
#define P_NOP   0x01
 NOP: No operation.
#define P_NOT   0x12
 NOT: sets OP1 to 0 if it's true, and to 1 if it's false.
#define P_NOTS   0x1B
 NOTS: Binary self NOT ( ~OP1 ) -> OP1.
#define P_ONCE   0x3C
 ONCE: Execute a code portion only once.
#define P_OOB   0x68
 OOB Marks, unmarks or checks the code to be an oob.
#define P_OR   0x4C
 AND: Logical OR if (op1 is true or op2 is true ) true->A.
#define P_ORS   0x2F
 ORS: self binary OR ( OP1 | OP2 ) -> OP1.
#define P_PARAM_FALSE   0x0C
#define P_PARAM_GLOBID   0x06
#define P_PARAM_INT32   0x01
#define P_PARAM_INT64   0x05
#define P_PARAM_LBIND   0x0A
#define P_PARAM_LOCID   0x07
#define P_PARAM_NIL   0x04
#define P_PARAM_NOTUSED   0x00
#define P_PARAM_NTD32   0x0E
#define P_PARAM_NTD64   0x0F
#define P_PARAM_NUM   0x03
#define P_PARAM_PARID   0x08
#define P_PARAM_REGA   0x10
#define P_PARAM_REGB   0x11
#define P_PARAM_REGL1   0x14
#define P_PARAM_REGL2   0x15
#define P_PARAM_REGS1   0x12
#define P_PARAM_STRID   0x02
#define P_PARAM_TRUE   0x0B
#define P_PEEK   0x1C
 PEEK: peeks the stack top and copies it in the operand.
#define P_POP   0x0E
 POP OP1: pops OP1 from the stack.
#define P_POW   0x25
 POW: OP1^OP2 -> A.
#define P_POWS   0x5E
 free
#define P_PROV   0x48
 PROV: sets A to 1 if OP1 has property OP2, else sets A to 0.
#define P_PSHL   0x5D
 PUSH LITERAL PSHL OP1 -> OP1 => stack.
#define P_PSHN   0x02
 PSHN: Push a NIL on top of stack.
#define P_PSHR   0x0D
 PSHR: pushes a reference to OP1 in the stack.
#define P_PTRY   0x06
 RET: Pop last N TRY position from the TRY stack.
#define P_PUSH   0x0C
 PUSH: pushes OP1 in the stack.
#define P_RET   0x03
 RET: Return from a function, nil -> A.
#define P_RETA   0x04
 RET: Return from a function, assuming A is the return value.
#define P_RETV   0x07
 RETV: Return from a function and sets A to the operand, OP1 -> A.
#define P_RIS   0x19
 RIS: Raise an exception whose value is OP1.
#define P_SELE   0x61
 SELECT: Select a branch depending on a variable type.
#define P_SHL   0x58
 Shift left op1 of op2 positions and place the result in A.
#define P_SHLS   0x5A
 Shift left op1 of op2 positions and place the result in OP1.
#define P_SHR   0x59
 Shift right op1 of op2 positions and place the result in A.
#define P_SHRS   0x5B
 Shift right op1 of op2 positions and place the result in OP1.
#define P_SHRS   0x5B
 Shift right op1 of op2 positions and place the result in OP1.
#define P_STEX   0x63
 STEX: String expansion; expand string in OP1.
#define P_STO   0x66
 STO: STO OP1, OP2 -> OP1 := OP2.
#define P_STP   0x50
 STP: Store OP3 into Property OP2 of OP1: OP3 -> OP1.OP2.
#define P_STPR   0x54
 STPR: store reference to OP3 into property OP2 of OP1: &OP3 -> OP1.OP2.
#define P_STPS   0x4A
 STPS: Store the topmost stack element into position OP2 of OP1: STACK -> OP1[OP2].
#define P_STV   0x4F
 STV: Store OP3 into vector OP1 at position OP2, OP3 -> OP1[OP2].
#define P_STVR   0x53
 STVR: store reference to OP3 into vector OP1 at pos OP2: &OP3 -> OP1[OP2].
#define P_STVS   0x49
 STVS: Store the topmost stack element into property OP2 of OP1: STACK -> OP1.OP2.
#define P_SUB   0x21
 SUB: OP1 - OP2 -> A.
#define P_SUBS   0x27
 SUBS: subtract from self, OP1 - OP2 -> OP1.
#define P_SWCH   0x41
 SWCH: switch.
#define P_TRAC   0x64
 TRAC: Traverse change.
#define P_TRAL   0x13
 TRAL <int32>: Traverse last.
#define P_TRAN   0x3F
 TRAN <int32>, <int32> Traverse next.
#define P_TRAV   0x55
 TRAV, Traverse an iterable Sequence.
#define P_TRDN   0x69
 TRDN: Traverse dropping next.
#define P_TRY   0x17
 TRY: push OP1 in the try stack.
#define P_WRT   0x65
 WRT: Write on standard output (TODO: also other vm streams using parameters).
#define P_XORS   0x30
 XORS: self binary XOR ( OP1 ^ OP2 ) -> OP1.
#define P_XPOP   0x15
 XPOP: exchange OP1 and the topmost stack element.


Define Documentation

#define FALCON_PCODE_MINOR   8

#define FALCON_PCODE_VERSION   2

#define FLC_PCODE_COUNT   0x70

#define P_ADD   0x20

ADD: OP1 + OP2 -> A.

#define P_ADDS   0x26

ADDS: add to self, OP1 + OP2 -> OP1.

#define P_AND   0x4B

AND: Logical AND if (op1 is true and op2 is true ) true->A.

#define P_ANDS   0x2E

ANDS: self binary and ( OP1 & OP2 ) -> OP1.

#define P_BAND   0x2B

BAND: Binary and ( OP1 & OP2 ) -> A.

#define P_BNOT   0x1A

BNOT: Binary NOT ( ~OP1 ) -> A.

#define P_BOOL   0x08

BOOL: Check is the parameter is true or false, and sets A to 0 or 1.

#define P_BOR   0x2C

BOR: Binary OR ( OP1 | OP2 ) -> A.

#define P_BXOR   0x2D

BXOR: Binary XOR ( OP1 ^ OP2 ) -> A.

#define P_CALL   0x3A

CALL <int32>, $sym.

calls subroutine at OP2; at subroutine returns, removes OP1 params from the stack.

#define P_CLOS   0x5C

Create a closure.

CLOS N, <tgt>, <src>

N elements from the stack are extracted and an array is made as for GENA; The function in src is cloned into <tgt>, and the closed array is added in tgt.

#define P_DEC   0x10

DEC: Dec prefix DEC OP1: OP1 - 1 -> OP1, OP1-> A.

#define P_DECP   0x57

DEC Postfix DECP V : V->A, V := V - 1 -> B.

#define P_DIV   0x23

DIV: OP1 / OP2 -> A.

#define P_DIVS   0x29

DIVS: divide from self, OP1 / OP2 -> OP1.

#define P_END   0x00

END: terminate.

#define P_EQ   0x32

EQ: Compares OP1 and OP2, and if they are equal 1 -> A, else 0 -> A.

#define P_EVAL   0x60

EVAL Perform functional evaluation, direct call or return the value as-is FORB OP1 -> A := if OP1 is callable if OP1 is array eval(op1) else OP1() else OP1.

#define P_FORB   0x67

FORB Forward binding FORB OP1, OP2 -> A := lbind( OP1, OP2 ).

#define P_FORK   0x1D

FORK: Creates a coroutine jumping at OP2 position.

OP1 is the amount of stack elements to be passed to the new thread. Both ops are fixed

#define P_GE   0x35

GE: Compares OP1 and OP2, and if OP1 >= OP2 1 -> A, else 0 -> A.

#define P_GENA   0x0A

GENA: Generates an array given the OP1 previous elements in the stack.

#define P_GEND   0x0B

GEND: Generates a dictionray given the OP1*2 previous elements in the stack.

#define P_GENR   0x31

GENR: Generates an range object [OP1, OP2] -> A.

#define P_GEOR   0x16

GEOR: Generates an open range object [OP1,*[ -> A.

#define P_GT   0x34

GT: Compares OP1 and OP2, and if OP1 > OP2 1 -> A, else 0 -> A.

#define P_IFF   0x39

IFF <int32>, $sym If OP2 is false then jumps to OP1 (OP1 -> PC).

#define P_IFT   0x38

IFT <int32>, $sym If OP2 is true then jumps to OP1 (OP1 -> PC).

#define P_IN   0x46

IN: sets A to 1 if OP1 is in set OP2, else sets A to 0.

#define P_INC   0x0F

INC: Inc prefix INC OP1: OP1 + 1 -> OP1, OP1-> A.

#define P_INCP   0x56

INC postfix INCP V : V->A, V := V + 1 -> B.

#define P_INDI   0x62

INDI: Indirect symbol reference; get the value of the string OP1.

#define P_INST   0x3B

INST $sym, <int32>.

As call, but does not changes self register.

#define P_IPOP   0x14

IPOP: Pops last OP1 elements from the stack.

#define P_JMP   0x09

JMP <int32>: Jumps at given position, OP1 -> PC.

#define P_JTRY   0x18

JTRY: jump out of a try, going at OP1 and popping the try stack.

#define P_LD   0x1E

LD: Loads OP1 in OP2 OP1 -> OP2.

#define P_LDAS   0x40

LDAS <int32>, V: Load all in stack.

OP1: size to be loaded in the stack. OP2: vector to be unpacked. Each element in V is verbatim copied in the stack, the highest stack element becomes the last element in the array.

#define P_LDP   0x3E

LDV: Load from object OP1 the property OP2 in A, OP1.OP2 -> A.

#define P_LDPT   0x52

LDPT: Load from object OP1 the property OP2 in OP3, OP1.OP2 -> OP3.

#define P_LDRF   0x1F

LDRF: Loads a reference to OP1 in OP2, &OP1 -> OP2.

IF OP2 is immediate, then break the reference pointed by OP1

Todo:
: add opcode to break reference.

#define P_LDV   0x3D

LDV: Load from vector OP1 the item at OP2 in A, OP1[ OP2 ] -> A.

#define P_LDVT   0x51

LDVT: Load from vector OP1 the item at OP2 in OP3, OP1[ OP2 ] -> OP3.

#define P_LE   0x37

LE: Compares OP1 and OP2, and if OP1 <= OP2 1 -> A, else 0 -> A.

#define P_LNIL   0x05

LNIL: Load nil into the parameter, nil -> OP1.

#define P_LSB   0x5F

Load from byte or character from sting.

#define P_LT   0x36

LT: Compares OP1 and OP2, and if OP1 < OP2 1 -> A, else 0 -> A.

#define P_MOD   0x24

MOD: OP1 % OP2 -> A.

#define P_MODS   0x2A

MODS: self module, OP1 % OP2 -> OP1.

#define P_MUL   0x22

MUL: OP1 * OP2 -> A.

#define P_MULS   0x28

MULS: multiply to self, OP1 * OP2 -> OP1.

#define P_NEG   0x11

NEG: Negates OP1, - OP1 -> OP1.

#define P_NEQ   0x33

NEQ: Compares OP1 and OP2, and if they are equal 0 -> A, else 1 -> A.

#define P_NOIN   0x47

NOIN: sets A to 0 if OP1 is in set OP2, else sets A to 1.

#define P_NOP   0x01

NOP: No operation.

#define P_NOT   0x12

NOT: sets OP1 to 0 if it's true, and to 1 if it's false.

#define P_NOTS   0x1B

NOTS: Binary self NOT ( ~OP1 ) -> OP1.

#define P_ONCE   0x3C

ONCE: Execute a code portion only once.

If the function OP2 has not been executed, then proceeds, else jumps at OP1.

#define P_OOB   0x68

OOB Marks, unmarks or checks the code to be an oob.

OOB NTD32, OP if NTD32 == 0 -> A := deOob( OP ) if NTD32 == 1 -> A := oob( OP ) if NTD32 == 2 -> A := isOob( OP ) ? deOob( OP ) : oob( OP ) if NTD32 == 3 (or else ) A := isOob( OP )

#define P_OR   0x4C

AND: Logical OR if (op1 is true or op2 is true ) true->A.

#define P_ORS   0x2F

ORS: self binary OR ( OP1 | OP2 ) -> OP1.

#define P_PARAM_FALSE   0x0C

#define P_PARAM_GLOBID   0x06

#define P_PARAM_INT32   0x01

#define P_PARAM_INT64   0x05

#define P_PARAM_LBIND   0x0A

#define P_PARAM_LOCID   0x07

#define P_PARAM_NIL   0x04

#define P_PARAM_NOTUSED   0x00

#define P_PARAM_NTD32   0x0E

#define P_PARAM_NTD64   0x0F

#define P_PARAM_NUM   0x03

#define P_PARAM_PARID   0x08

#define P_PARAM_REGA   0x10

#define P_PARAM_REGB   0x11

#define P_PARAM_REGL1   0x14

#define P_PARAM_REGL2   0x15

#define P_PARAM_REGS1   0x12

#define P_PARAM_STRID   0x02

#define P_PARAM_TRUE   0x0B

#define P_PEEK   0x1C

PEEK: peeks the stack top and copies it in the operand.

STACK[top] -> OP1

#define P_POP   0x0E

POP OP1: pops OP1 from the stack.

#define P_POW   0x25

POW: OP1^OP2 -> A.

#define P_POWS   0x5E

free

POWS: self power, OP1 ** OP2 -> OP1

#define P_PROV   0x48

PROV: sets A to 1 if OP1 has property OP2, else sets A to 0.

#define P_PSHL   0x5D

PUSH LITERAL PSHL OP1 -> OP1 => stack.

This opcode pushes the operand on the stack without peforming any check (and without dereferencing it). It allows to push raw references in the stack.

#define P_PSHN   0x02

PSHN: Push a NIL on top of stack.

#define P_PSHR   0x0D

PSHR: pushes a reference to OP1 in the stack.

#define P_PTRY   0x06

RET: Pop last N TRY position from the TRY stack.

#define P_PUSH   0x0C

PUSH: pushes OP1 in the stack.

#define P_RET   0x03

RET: Return from a function, nil -> A.

#define P_RETA   0x04

RET: Return from a function, assuming A is the return value.

#define P_RETV   0x07

RETV: Return from a function and sets A to the operand, OP1 -> A.

#define P_RIS   0x19

RIS: Raise an exception whose value is OP1.

#define P_SELE   0x61

SELECT: Select a branch depending on a variable type.

Similar to switch.

#define P_SHL   0x58

Shift left op1 of op2 positions and place the result in A.

#define P_SHLS   0x5A

Shift left op1 of op2 positions and place the result in OP1.

#define P_SHR   0x59

Shift right op1 of op2 positions and place the result in A.

#define P_SHRS   0x5B

Shift right op1 of op2 positions and place the result in OP1.

#define P_SHRS   0x5B

Shift right op1 of op2 positions and place the result in OP1.

#define P_STEX   0x63

STEX: String expansion; expand string in OP1.

#define P_STO   0x66

STO: STO OP1, OP2 -> OP1 := OP2.

Works as LD, but it overwrites target value even if it's a reference.

#define P_STP   0x50

STP: Store OP3 into Property OP2 of OP1: OP3 -> OP1.OP2.

#define P_STPR   0x54

STPR: store reference to OP3 into property OP2 of OP1: &OP3 -> OP1.OP2.

#define P_STPS   0x4A

STPS: Store the topmost stack element into position OP2 of OP1: STACK -> OP1[OP2].

#define P_STV   0x4F

STV: Store OP3 into vector OP1 at position OP2, OP3 -> OP1[OP2].

#define P_STVR   0x53

STVR: store reference to OP3 into vector OP1 at pos OP2: &OP3 -> OP1[OP2].

#define P_STVS   0x49

STVS: Store the topmost stack element into property OP2 of OP1: STACK -> OP1.OP2.

#define P_SUB   0x21

SUB: OP1 - OP2 -> A.

#define P_SUBS   0x27

SUBS: subtract from self, OP1 - OP2 -> OP1.

#define P_SWCH   0x41

SWCH: switch.

Todo:
explain

#define P_TRAC   0x64

TRAC: Traverse change.

TRAC OP1 => OP1-> current value Change current (value) item in traversal loops to shallow copy of OP1

See also:
TRAV

#define P_TRAL   0x13

TRAL <int32>: Traverse last.

See also:
P_TRAV

#define P_TRAN   0x3F

TRAN <int32>, <int32> Traverse next.

See also:
P_TRAV

#define P_TRAV   0x55

TRAV, Traverse an iterable Sequence.

TRAV is a complex instruction that involves the stack, a set of target variables, and 3 other opcodes (TRAN traverse next, TRDN, Traverse dropping next and TRAL, traverse last). This instructions are meant to map the for/in loop at Falcon language level.

TRAV initializes the loop adding an iterator to the SOURCE variable on top of the stack, or eventually skips the loop altogether if the source is empty (or nil).

TRAV declares how many variables will receive elements from source. Those variables are then stored immediately below as NOP opcodes with a single parameter (a target variable).

If source is a dictionary sequence, TRAV must be provided with exactly two variables that will receive the key and the value of each element; otherwise, if provided with one variable, TRAV will store the current item in that variable, and if provided with more variables, it will try to consider each element as an array and unpack it in the variables.

TRAN and TRDN work similarly to TRAN, but they use the variable at stack top as the current iterator.

A for/in loop is divided in 4 areas, all of which optional. The main area (MAIN) is executed for each item in the collection. The FIRST block is executed only BEFORE the first time MAIN is executed, the MIDDLE block is executed after each MAIN block execution except for the last one (when the iterator has not a "next" element), and the LAST block which is executed after the MAIN for the last element.

If a MIDDLE block is provided, then then loop is configured as if there was a LAST block, possibly left empty if there isn't any code for that.

TRAN skips to the next element and loads the variables in its var block. If there is a loop to be performed, it loops to the MAIN block, otherwise it proceeds.

TRDN is similar to TRAN, but instead advancing to the next element, it deletes the current element, and loads the loop variables with the new value of the iterator. It is generated 1:1 on "continue dropping" instruction.

BOTH TRAN and TRDN are meant to execute the last block after the last element main block for the last element has been executed. If there isn't any last block, it is simply left empty and the jump label lands at the same position of the loop end (same target as a "break" instruction).

TRAL simply jumps to its label if the current item is the last item in the sequence (i.e. if the iterator on stack top ! hasNext()). This switches the middle and last blocks.

      TRAV NV, p_label_loop_end, $S    ==> push iterator($S)
      {VARBLOCK: NV rep of NOP $v }

      [FIRST BLOCK
         ...
         TRDN  NV, label_loop_begin, label_loop_last
         {VARBLOCK: NV rep of NOP $v }
         ...
      ]

      label_loop_begin:
      [MAIN BLOCK
         ...
         TRDN  NV, label_loop_begin, label_loop_last
         {VARBLOCK: NV rep of NOP $v }
         ...
      ]

      [MIDDLE BLOCK
         ; this skips this block if the current element is the last one.
         TRAL label_loop_last
         ...
         TRDN NV, label_loop_begin, label_loop_last
         {VARBLOCK: NV rep of NOP $v }
         ...
      ]

      label_loop_next:
      TRAN NV, label_loop_begin
      {VARBLOCK: NV rep of NOP $v }

      label_loop_last:
      [LAST BLOCK
         ...
         TRDN  0, label_loop_end, label_loop_end
         ...
      ]

      label_loop_end:
      POP

      p_label_loop_end:

Note:
TRAV, TRAN and TRDN VARBLOCK elements can contain only global, local or parameter symbols.

TRDN has a special behavior when OP1 == 0: it pops the last element in the sequence and goes to loop end, instead of erasing the current element and preparing the loop variables.

TRAL also advances the iterator past the last element, to have the position of the iterator at last block after the last element, as TRDN and TRAV would leave it, and so that "TRDN 0, .., .." can go back one position and delete the element.

#define P_TRDN   0x69

TRDN: Traverse dropping next.

TRDN <int32>, <int32>, <int32>

See also:
TRAV

#define P_TRY   0x17

TRY: push OP1 in the try stack.

#define P_WRT   0x65

WRT: Write on standard output (TODO: also other vm streams using parameters).

#define P_XORS   0x30

XORS: self binary XOR ( OP1 ^ OP2 ) -> OP1.

#define P_XPOP   0x15

XPOP: exchange OP1 and the topmost stack element.


Generated on Mon Oct 19 10:11:19 2009 for Falcon_Core by  doxygen 1.5.8