Tedds blog ⋆ Page 15 of 16 ⋆ Geekosaurus Tedd

Status on initial SE implementation

With the model described in the two prior postings we will have simple scripts support up and running fairly quickly. Other developers will be able to extend script support while I continue working on Compiler and ScriptEngine. Both incoming events and outgoing LSL builtin commands needs extending. We will lack script yield inserting. This is where the preparation… Read More »

ScriptEngine – Events

The builtin commands for SE is simple enough. But incoming events could need some more planning. SE will have a set of events that is fired based on stuff that happens in OpenSim (EventHandler). This EventHandler will translate the event into a LSL-compatible event, including picking up the required parameters. The EventHandler needs to know what object, and… Read More »

ScriptEngine

The time has come to start implementing script support into OpenSim. ScriptEngine (SE)OpenSim will have an interface for SE. It will load SE dynamically using reflection. SE will be in separate .dll Assembly.During load SE will hook itself up to the necessary events in OpenSim.This includes: Object rez (look for active scripts), object derez and all events relating… Read More »

Current status

Static and global variable support has been added. All push/pop functions added. Simple scripts that use variables, math and internal functions (like llSay) are now supported.Stack and all internal data are ready for serializing, so running script can be moved between servers – but no fibre/user space multitasking/microthreading has been implemented yet – so move has to happen… Read More »

Current OPCODE implementation status

This is the current OPCODE implementation status:

OPCODE                  IL_Processor         Implemented

NOOP                    *                    *
POP                     *                    *
POPS                    *                    *
POPL                    *                    *
POPV                    *                    *
POPQ                    *                    *
POPARG                  *                    *
POPIP
POPBP
POPSP               
POPSLR
DUP
DUPS
DUPL
DUPV
DUPQ
STORE                   *                    *
STORES                  *                    *
STOREL                  *                    *
STOREV                  *                    *
STOREQ                  *                    *
STOREG                  *                    *
STOREGS                 *                    *
STOREGL                 *                    *
STOREGV                 *                    *
STOREGQ                 *                    *
LOADP                   *                    *
LOADSP                  *                    *
LOADLP                  *                    *
LOADVP                  *                    *
LOADQP                  *                    *
LOADGP                  *                    *
LOADGSP                 *                    *
LOADGLP                 *                    *
LOADGVP                 *                    *
LOADGQP                 *                    *
PUSH                    *                    *
PUSHS                   *                    *
PUSHL                   *                    *
PUSHV                   *                    *
PUSHQ                   *                    *
PUSHG                   *                    *
PUSHGS                  *                    *
PUSHGL                  *                    *
PUSHGV                  *                    *
PUSHGQ                  *                    *
PUSHIP
PUSHBP
PUSHSP                  *                    *
PUSHARGB
PUSHARGI                *                    *
PUSHARGF                *                    *
PUSHARGS                *                    *
PUSHARGV
PUSHARGQ
PUSHE                   *                    *
PUSHEV
PUSHEQ
PUSHARGE                *
ADD                     *                    *
SUB                     *                    *
MUL                     *                    *
DIV                     *                    *
MOD                     *                    *
EQ                      *                    *
NEQ                     *                    *
LEQ                     *                    *
GEQ                     *                    *
LESS                    *                    *
GREATER                 *                    *
BITAND                  *                    *
BITOR                   *                    *
BITXOR                  *                    *
BOOLAND                 *                    *
BOOLOR                  *                    *
NEG                     *                    *
BITNOT                  *
BOOLNOT                 *
JUMP
JUMPIF
JUMPNIF
STATE
CALL
RETURN                  *                    *
CAST
STACKTOS
STACKTOL
PRINT
CALLLIB
CALLLIB_TWO_BYTE        *                    *
SHL
SHR

OPCODE IL_Processor Implemented

NOOP * *

POP * *

POPS * *

POPL * *

POPV * *

POPQ * *

POPARG * *

POPIP

POPBP

POPSP

POPSLR

DUP

DUPS

DUPL

DUPV

DUPQ

STORE * *

STORES * *

STOREL * *

STOREV * *

STOREQ * *

STOREG * *

STOREGS * *

STOREGL * *

STOREGV * *

STOREGQ * *

LOADP * *

LOADSP * *

LOADLP * *

LOADVP * *

LOADQP * *

LOADGP * *

LOADGSP * *

LOADGLP * *

LOADGVP * *

LOADGQP * *

PUSH * *

PUSHS * *

PUSHL * *

PUSHV * *

PUSHQ * *

PUSHG * *

PUSHGS * *

PUSHGL * *

PUSHGV * *

PUSHGQ * *

PUSHIP

PUSHBP

PUSHSP * *

PUSHARGB

PUSHARGI * *

PUSHARGF * *

PUSHARGS * *

PUSHARGV

PUSHARGQ

PUSHE * *

PUSHEV

PUSHEQ

PUSHARGE *

ADD * *

SUB * *

MUL * *

DIV * *

MOD * *

EQ * *

NEQ * *

LEQ * *

GEQ * *

LESS * *

GREATER * *

BITAND * *

BITOR * *

BITXOR * *

BOOLAND * *

BOOLOR * *

NEG * *

BITNOT *

BOOLNOT *

JUMP

JUMPIF

JUMPNIF

STATE

CALL

RETURN * *

CAST

STACKTOS

STACKTOL

CALLLIB

CALLLIB_TWO_BYTE * *

SHL

SHR

Book: CLR via C#, Second Edition

This morning I received the book I ordered from Amazon.com. 1 week before estimated arrival. The book is named CLR via C# (Second Edition) and is supposedly the bible of understanding CLR. So 648 pages from now I should be able to utilize my new skills in the LSO project… :)

My other blog

I have another blog: http://teddmaa.blogspot.com/ It is used for blogging about Second Life stuff, specifically the development I’m doing for OpenSim server. I’m writing a program (a) that reads a program (b) and creates a program (c) that will run inside a program (d) as a module.a = My programb = Second Life LSO ByteCode (compiled LSL script)c… Read More »

Hello World!

Hi there everybody! Any articles before this one are copied from my previous blog.

Looking ahead, fibres

Running thousands of scripts simultaneously on a grid requires some special programming. We can not just issue one thread per script and let it run. The resources required by each OS thread,both in terms of memory and thread switching is too high. Instead we want to execute a few instructions of a script, then move to the next… Read More »

Frames, heap and code pointers

LSL ByteCode uses a lot of pointers, both to memory (static frames, local/global, heap) as well as JUMP pointers. Some of these pointers exist during load, for example argument types, static data, jump positions, etc. While others are allocated and created dynamically during run-time. What they all have in common is that they point to a position in… Read More »