6 files changed, 129 insertions, 71 deletions

diff --git a/linden/indra/lscript/lscript_byteconvert.h b/linden/indra/lscript/lscript_byteconvert.h
index 9530b63..664a25e 100644
--- a/linden/indra/lscript/lscript_byteconvert.h
+++ b/linden/indra/lscript/lscript_byteconvert.h
@@ -250,7 +250,7 @@ inline void bytestream2vector(LLVector3 &vector, const U8 *stream, S32 &offset)
         }
 }
 
-inline void vector2bytestream(U8 *stream, S32 &offset, LLVector3 &vector)
+inline void vector2bytestream(U8 *stream, S32 &offset, const LLVector3 &vector)
 {
         S32 value = *(S32 *)&vector.mV[VZ];
         integer2bytestream(stream, offset, value);
@@ -292,7 +292,7 @@ inline void bytestream2quaternion(LLQuaternion &quat, const U8 *stream, S32 &off
         }
 }
 
-inline void quaternion2bytestream(U8 *stream, S32 &offset, LLQuaternion &quat)
+inline void quaternion2bytestream(U8 *stream, S32 &offset, const LLQuaternion &quat)
 {
         S32 value = *(S32 *)&quat.mQ[VS];
         integer2bytestream(stream, offset, value);
@@ -528,7 +528,7 @@ inline void lscript_push(U8 *stream, F32 value)
         }
 }
 
-inline void lscript_push(U8 *stream, LLVector3 &value)
+inline void lscript_push(U8 *stream, const LLVector3 &value)
 {
         S32 sp = get_register(stream, LREG_SP);
         sp -= LSCRIPTDataSize[LST_VECTOR];
@@ -539,7 +539,7 @@ inline void lscript_push(U8 *stream, LLVector3 &value)
         }
 }
 
-inline void lscript_push(U8 *stream, LLQuaternion &value)
+inline void lscript_push(U8 *stream, const LLQuaternion &value)
 {
         S32 sp = get_register(stream, LREG_SP);
         sp -= LSCRIPTDataSize[LST_QUATERNION];
@@ -679,13 +679,13 @@ inline void lscript_local_store(U8 *stream, S32 address, F32 value)
                 float2bytestream(stream, address, value);
 }
 
-inline void lscript_local_store(U8 *stream, S32 address, LLVector3 value)
+inline void lscript_local_store(U8 *stream, S32 address, const LLVector3 value)
 {
         if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_VECTOR]))
                 vector2bytestream(stream, address, value);
 }
 
-inline void lscript_local_store(U8 *stream, S32 address, LLQuaternion value)
+inline void lscript_local_store(U8 *stream, S32 address, const LLQuaternion value)
 {
         if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
                 quaternion2bytestream(stream, address, value);
@@ -703,13 +703,13 @@ inline void lscript_global_store(U8 *stream, S32 address, F32 value)
                 float2bytestream(stream, address, value);
 }
 
-inline void lscript_global_store(U8 *stream, S32 address, LLVector3 value)
+inline void lscript_global_store(U8 *stream, S32 address, const LLVector3 value)
 {
         if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_VECTOR]))
                 vector2bytestream(stream, address, value);
 }
 
-inline void lscript_global_store(U8 *stream, S32 address, LLQuaternion value)
+inline void lscript_global_store(U8 *stream, S32 address, const LLQuaternion value)
 {
         if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
                 quaternion2bytestream(stream, address, value);
@@ -1125,7 +1125,7 @@ inline void safe_instruction_bytestream2vector(LLVector3 &value, U8 *stream, S32
         }
 }
 
-inline void safe_instruction_vector2bytestream(U8 *stream, S32 &offset, LLVector3 &value)
+inline void safe_instruction_vector2bytestream(U8 *stream, S32 &offset, const LLVector3 &value)
 {
         if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_VECTOR]))
         {
@@ -1141,7 +1141,7 @@ inline void safe_instruction_bytestream2quaternion(LLQuaternion &value, U8 *stre
         }
 }
 
-inline void safe_instruction_quaternion2bytestream(U8 *stream, S32 &offset, LLQuaternion &value)
+inline void safe_instruction_quaternion2bytestream(U8 *stream, S32 &offset, const LLQuaternion &value)
 {
         if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_QUATERNION]))
         {
diff --git a/linden/indra/lscript/lscript_byteformat.h b/linden/indra/lscript/lscript_byteformat.h
index 1f201d8..fa82e6b 100644
--- a/linden/indra/lscript/lscript_byteformat.h
+++ b/linden/indra/lscript/lscript_byteformat.h
@@ -470,6 +470,7 @@ const U8 LSCRIPTTypeHi4Bits[LST_EOF] =
         LST_VECTOR << 4,
         LST_QUATERNION << 4,
         LST_LIST << 4,
+        LST_UNDEFINED << 4,
 };
 
 const char * const LSCRIPTTypeNames[LST_EOF] =  /*Flawfinder: ignore*/
diff --git a/linden/indra/lscript/lscript_compile/lscript_tree.cpp b/linden/indra/lscript/lscript_compile/lscript_tree.cpp
index 71e7f19..f62b4e7 100644
--- a/linden/indra/lscript/lscript_compile/lscript_tree.cpp
+++ b/linden/indra/lscript/lscript_compile/lscript_tree.cpp
@@ -46,7 +46,8 @@
 
 static void print_cil_box(LLFILE* fp, LSCRIPTType type)
 {
-        switch(type)
+        
+switch(type)
         {
         case LST_INTEGER:
                 fprintf(fp, "box [mscorlib]System.Int32\n");
@@ -1257,10 +1258,10 @@ static void print_cil_init_variable(LLFILE* fp, LSCRIPTType type)
                 fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateVector'(float32, float32, float32)\n");
                 break;
         case LST_QUATERNION:
-                fprintf(fp, "ldc.r8 1\n");
                 fprintf(fp, "ldc.r8 0\n");
                 fprintf(fp, "ldc.r8 0\n");
                 fprintf(fp, "ldc.r8 0\n");
+                fprintf(fp, "ldc.r8 1\n");
                 fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateQuaternion'(float32, float32, float32, float32)\n");
                 break;
         case LST_LIST:
@@ -3517,7 +3518,7 @@ void LLScriptRezEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompile
                 fprintf(fp, " )\n");
                 break;
         case LSCP_SCOPE_PASS1:
-          checkForDuplicateHandler(fp, this, scope, "rez");
+                checkForDuplicateHandler(fp, this, scope, "on_rez");
                 if (scope->checkEntry(mStartParam->mName))
                 {
                         gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
@@ -7885,10 +7886,10 @@ void LLScriptFunctionCall::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCom
                         {
                                 // Prefix function name with g to distinguish from
                                 // event handlers.
-                                fprintf(fp, gScriptp->getClassName());
+                                fprintf(fp, "%s", gScriptp->getClassName());
                                 fprintf(fp, "::'g");
                         }
-                        fprintf(fp, mIdentifier->mName);
+                        fprintf(fp, "%s", mIdentifier->mName);
                         fprintf(fp, "'(");
                         print_cil_arg_list(fp, mIdentifier->mScopeEntry->mFunctionArgs);
                         fprintf(fp, ")\n");
@@ -8689,8 +8690,12 @@ void LLScriptIf::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass p
                 break;
         case LSCP_TYPE:
                 mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
+                if (type == LST_NULL)
+                {
+                        gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
+                }
                 mType = type;
-                mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
+                mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);           
                 break;
         case LSCP_EMIT_BYTE_CODE:
                 {
@@ -8770,6 +8775,10 @@ void LLScriptIfElse::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePa
                 break;
         case LSCP_TYPE:
                 mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
+                if (type == LST_NULL)
+                {
+                        gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
+                }
                 mType = type;
                 mStatement1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
                 mStatement2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
@@ -8869,6 +8878,10 @@ void LLScriptFor::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass
                 if(mSequence)
                         mSequence->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
                 mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
+                if (type == LST_NULL)
+                {
+                        gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
+                }
                 mType = type;
                 if(mExpressionList)
                         mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
@@ -8968,6 +8981,10 @@ void LLScriptDoWhile::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompileP
         case LSCP_TYPE:
                 mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
                 mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
+                if (type == LST_NULL)
+                {
+                        gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
+                }
                 mType = type;
                 break;
         case LSCP_EMIT_BYTE_CODE:
@@ -9039,6 +9056,10 @@ void LLScriptWhile::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePas
                 break;
         case LSCP_TYPE:
                 mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
+                if (type == LST_NULL)
+                {
+                        gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
+                }
                 mType = type;
                 mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
                 break;
@@ -9720,7 +9741,7 @@ void LLScriptEventHandler::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCom
                 // Allows state changing by finding handlers prefixed with new
                 // state name. Prefix disambiguates functions and event handlers.
                 fprintf(fp, "e");
-                fprintf(fp, entry->mIdentifier);
+                fprintf(fp, "%s", entry->mIdentifier);
 
                 // Handler name and arguments.
                 mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
@@ -10152,7 +10173,7 @@ void LLScriptGlobalFunctions::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPT
                         fprintf(fp, ".method public hidebysig instance default ");
                         print_cil_type(fp, mType ? mType->mType : LST_NULL);
                         fprintf(fp, " 'g");
-                        fprintf(fp, mIdentifier->mName);
+                        fprintf(fp, "%s", mIdentifier->mName);
                         fprintf(fp, "'");
                         if (mParameters)
                         {
diff --git a/linden/indra/lscript/lscript_execute.h b/linden/indra/lscript/lscript_execute.h
index ac23ff3..77e9c21 100644
--- a/linden/indra/lscript/lscript_execute.h
+++ b/linden/indra/lscript/lscript_execute.h
@@ -370,7 +370,7 @@ public:
         LLScriptExecute();
         virtual ~LLScriptExecute() {;}
 
-        virtual S32 getVersion() = 0;
+        virtual S32 getVersion() const = 0;
         virtual void deleteAllEvents() = 0;
         virtual void addEvent(LLScriptDataCollection* event) = 0;
         virtual U32 getEventCount() = 0;
@@ -384,12 +384,12 @@ public:
         virtual void setSleep(F32 value) = 0;
         virtual F32 getEnergy() const = 0;
         virtual void setEnergy(F32 value) = 0;
-        virtual U64 getCurrentEvents(S32 version) = 0;
-        virtual void setCurrentEvents(U64 value, S32 version) = 0;
-        virtual U64 getEventHandlers(S32 version) = 0;
-        virtual void setEventHandlers(U64 value, S32 version) = 0;
-        virtual U64 getCurrentHandler(S32 version) = 0;
-        virtual void setCurrentHandler(U64 value, S32 version) = 0;
+        virtual U64 getCurrentEvents() = 0;
+        virtual void setCurrentEvents(U64 value) = 0;
+        virtual U64 getEventHandlers() = 0;
+        virtual void setEventHandlers(U64 value) = 0;
+        virtual U64 getCurrentHandler() = 0;
+        virtual void setCurrentHandler(U64 value) = 0;
         virtual BOOL isFinished() const = 0;
         virtual BOOL isStateChangePending() const = 0;
         virtual S32 writeState(U8 **dest, U32 header_size, U32 footer_size) = 0; // Allocate memory for header, state and footer return size of state.
@@ -409,17 +409,17 @@ public:
 
         // Run handler for event for a maximum of time_slice seconds.
         // Updates current handler and current events registers.
-        virtual void callEventHandler(LSCRIPTStateEventType event, S32 major_version, const LLUUID &id, F32 time_slice) = 0;;
+        virtual void callEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice) = 0;;
 
         // Run handler for next queued event for maximum of time_slice seconds. 
         // Updates current handler and current events registers.
         // Removes processed event from queue.
-        virtual void callNextQueuedEventHandler(U64 event_register, S32 major_version, const LLUUID &id, F32 time_slice) = 0;
+        virtual void callNextQueuedEventHandler(U64 event_register, const LLUUID &id, F32 time_slice) = 0;
 
         // Run handler for event for a maximum of time_slice seconds.
         // Updates current handler and current events registers.
         // Removes processed event from queue.
-        virtual void callQueuedEventHandler(LSCRIPTStateEventType event, S32 major_version, const LLUUID &id, F32 time_slice) = 0;
+        virtual void callQueuedEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice) = 0;
 
         // Switch to next state.
         // Returns new set of handled events.
@@ -428,14 +428,14 @@ public:
         // Returns time taken.
         virtual F32 runQuanta(BOOL b_print, const LLUUID &id,
                                                   const char **errorstr, 
-                                                  BOOL &state_transition, F32 quanta,
+                                                  F32 quanta,
                                                   U32& events_processed, LLTimer& timer);
 
         // Run smallest possible amount of code: an instruction for LSL2, a segment
         // between save tests for Mono
         void runInstructions(BOOL b_print, const LLUUID &id,
                                                  const char **errorstr, 
-                                                 BOOL &state_transition, U32& events_processed,
+                                                 U32& events_processed,
                                                  F32 quanta);
 
         bool isYieldDue() const;
@@ -443,6 +443,12 @@ public:
         void setReset(BOOL b) {mReset = b;}
         BOOL getReset() const { return mReset; }
 
+        // Called when the script is scheduled to be run from newsim/LLScriptData
+        virtual void startRunning() = 0;
+
+        // Called when the script is scheduled to be stopped from newsim/LLScriptData
+        virtual void stopRunning() = 0;
+        
 private:
 
         BOOL mReset;
@@ -455,7 +461,7 @@ public:
         LLScriptExecuteLSL2(const U8* bytecode, U32 bytecode_size);
         virtual ~LLScriptExecuteLSL2();
 
-        virtual S32 getVersion() {return get_register(mBuffer, LREG_VN);}
+        virtual S32 getVersion() const {return get_register(mBuffer, LREG_VN);}
         virtual void deleteAllEvents() {mEventData.mEventDataList.deleteAllData();}
         virtual void addEvent(LLScriptDataCollection* event);
         virtual U32 getEventCount() {return mEventData.mEventDataList.getLength();}
@@ -469,12 +475,12 @@ public:
         virtual void setSleep(F32 value);
         virtual F32 getEnergy() const;
         virtual void setEnergy(F32 value);
-        virtual U64 getCurrentEvents(S32 version) {return get_event_register(mBuffer, LREG_CE, version);}
-        virtual void setCurrentEvents(U64 value, S32 version) {return set_event_register(mBuffer, LREG_CE, value, version);}
-        virtual U64 getEventHandlers(S32 version) {return get_event_register(mBuffer, LREG_ER, version);}
-        virtual void setEventHandlers(U64 value, S32 version) {set_event_register(mBuffer, LREG_ER, value, version);}
-        virtual U64 getCurrentHandler(S32 version);
-        virtual void setCurrentHandler(U64 value, S32 version) {return set_event_register(mBuffer, LREG_IE, value, version);}   
+        virtual U64 getCurrentEvents() {return get_event_register(mBuffer, LREG_CE, getMajorVersion());}
+        virtual void setCurrentEvents(U64 value) {return set_event_register(mBuffer, LREG_CE, value, getMajorVersion());}
+        virtual U64 getEventHandlers() {return get_event_register(mBuffer, LREG_ER, getMajorVersion());}
+        virtual void setEventHandlers(U64 value) {set_event_register(mBuffer, LREG_ER, value, getMajorVersion());}
+        virtual U64 getCurrentHandler();
+        virtual void setCurrentHandler(U64 value) {return set_event_register(mBuffer, LREG_IE, value, getMajorVersion());}      
         virtual BOOL isFinished() const {return get_register(mBuffer, LREG_IP) == 0;}
         virtual BOOL isStateChangePending() const {return get_register(mBuffer, LREG_CS) != get_register(mBuffer, LREG_NS);}
         virtual S32 writeState(U8 **dest, U32 header_size, U32 footer_size); // Not including Events.
@@ -494,17 +500,17 @@ public:
 
         // Run handler for event for a maximum of time_slice seconds.
         // Updates current handler and current events registers.
-        virtual void callEventHandler(LSCRIPTStateEventType event, S32 major_version, const LLUUID &id, F32 time_slice);
+        virtual void callEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice);
 
         // Run handler for next queued event for maximum of time_slice seconds. 
         // Updates current handler and current events registers.
         // Removes processed event from queue.
-        virtual void callNextQueuedEventHandler(U64 event_register, S32 major_version, const LLUUID &id, F32 time_slice);
+        virtual void callNextQueuedEventHandler(U64 event_register, const LLUUID &id, F32 time_slice);
 
         // Run handler for event for a maximum of time_slice seconds.
         // Updates current handler and current events registers.
         // Removes processed event from queue.
-        virtual void callQueuedEventHandler(LSCRIPTStateEventType event, S32 major_version, const LLUUID &id, F32 time_slice);
+        virtual void callQueuedEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice);
 
         // Switch to next state.
         // Returns new set of handled events.
@@ -521,8 +527,15 @@ public:
         U32                                             mBytecodeSize;
 
 private:
+        S32 getMajorVersion() const;
         void            recordBoundaryError( const LLUUID &id );
         void            setStateEventOpcoodeStartSafely( S32 state, LSCRIPTStateEventType event, const LLUUID &id );
+
+        // Called when the script is scheduled to be run from newsim/LLScriptData
+        virtual void startRunning();
+
+        // Called when the script is scheduled to be stopped from newsim/LLScriptData
+        virtual void stopRunning();
 };
 
 #endif
diff --git a/linden/indra/lscript/lscript_execute/lscript_execute.cpp b/linden/indra/lscript/lscript_execute/lscript_execute.cpp
index 3adfe32..2a6f7e3 100644
--- a/linden/indra/lscript/lscript_execute/lscript_execute.cpp
+++ b/linden/indra/lscript/lscript_execute/lscript_execute.cpp
@@ -60,6 +60,9 @@ const char* LSCRIPTRunTimeFaultStrings[LSRF_EOF] =		/*Flawfinder: ignore*/
         "CLI Exception" // LSRF_CLI
 };
 
+void LLScriptExecuteLSL2::startRunning() {}
+void LLScriptExecuteLSL2::stopRunning() {}
+
 LLScriptExecuteLSL2::LLScriptExecuteLSL2(LLFILE *fp)
 {
         U8  sizearray[4];
@@ -327,8 +330,9 @@ void LLScriptExecuteLSL2::resumeEventHandler(BOOL b_print, const LLUUID &id, F32
         // NOTE: Babbage: all mExecuteFuncs return false.
 }
 
-void LLScriptExecuteLSL2::callEventHandler(LSCRIPTStateEventType event, S32 major_version, const LLUUID &id, F32 time_slice)
+void LLScriptExecuteLSL2::callEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice)
 {
+        S32 major_version = getMajorVersion();
         // push a zero to be popped
         lscript_push(mBuffer, 0);
         // push sp as current bp
@@ -403,8 +407,9 @@ void LLScriptExecuteLSL2::callEventHandler(LSCRIPTStateEventType event, S32 majo
 //      set_ip(mBuffer, opcode_start);
 //}
 
-void LLScriptExecuteLSL2::callQueuedEventHandler(LSCRIPTStateEventType event, S32 major_version, const LLUUID &id, F32 time_slice)
+void LLScriptExecuteLSL2::callQueuedEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice)
 {
+        S32 major_version = getMajorVersion();
         LLScriptDataCollection* eventdata;
 
         for (eventdata = mEventData.mEventDataList.getFirstData(); eventdata; eventdata = mEventData.mEventDataList.getNextData())
@@ -452,8 +457,9 @@ void LLScriptExecuteLSL2::callQueuedEventHandler(LSCRIPTStateEventType event, S3
         }
 }
 
-void LLScriptExecuteLSL2::callNextQueuedEventHandler(U64 event_register, S32 major_version, const LLUUID &id, F32 time_slice)
+void LLScriptExecuteLSL2::callNextQueuedEventHandler(U64 event_register, const LLUUID &id, F32 time_slice)
 {
+        S32 major_version = getMajorVersion();
         LLScriptDataCollection* eventdata = mEventData.getNextEvent();
         if (eventdata)
         {
@@ -541,9 +547,9 @@ void LLScriptExecuteLSL2::setSleep(F32 value)
 }
 
 //virtual 
-U64 LLScriptExecuteLSL2::getCurrentHandler(S32 version)
+U64 LLScriptExecuteLSL2::getCurrentHandler()
 {
-        return get_event_register(mBuffer, LREG_IE, version);
+        return get_event_register(mBuffer, LREG_IE, getMajorVersion());
 }
 
 //virtual 
@@ -724,6 +730,20 @@ void LLScriptExecuteLSL2::reset()
         bytestream2bytestream(mBuffer, dest_offset, src, src_offset, size);
 }
 
+S32 LLScriptExecuteLSL2::getMajorVersion() const
+{
+        S32 version = getVersion();
+        S32 major_version = 0;
+        if (version == LSL2_VERSION1_END_NUMBER){
+                major_version = 1;
+        }
+        else if (version == LSL2_VERSION_NUMBER)
+        {
+                major_version = 2;
+        }
+        return major_version;
+}
+
 LLScriptExecute::LLScriptExecute() :
         mReset(FALSE)
 {
@@ -751,6 +771,10 @@ bool LLScriptExecute::isYieldDue() const
                 return true;
         }
 
+        // State changes can occur within a single time slice,
+        // but LLScriptData's clean up is required. Yield here
+        // to allow LLScriptData to perform cleanup and then call
+        // runQuanta again.
         if(isStateChangePending())
         {
                 return true;
@@ -763,7 +787,6 @@ bool LLScriptExecute::isYieldDue() const
 // a single instruction for LSL2, a segment between save tests for Mono
 void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id, 
                                                                          const char **errorstr, 
-                                                                         BOOL &state_transition, 
                                                                          U32& events_processed,
                                                                          F32 quanta)
 {
@@ -806,17 +829,15 @@ void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id,
         else
         {
                 // make sure that IE is zero
-                setCurrentHandler(0, major_version);
+                setCurrentHandler(0);
 
                 //      if no, we're in a state and waiting for an event
-                U64 current_events = getCurrentEvents(major_version);
-                U64 event_register = getEventHandlers(major_version);
+                U64 current_events = getCurrentEvents();
+                U64 event_register = getEventHandlers();
 
                 //      check NS to see if need to switch states (NS != CS)
                 if (isStateChangePending())
                 {
-                        state_transition = TRUE;
-
                         // ok, blow away any pending events
                         deleteAllEvents();
 
@@ -824,16 +845,16 @@ void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id,
                         if (current_events & LSCRIPTStateBitField[LSTT_STATE_EXIT])
                         {
                                 // if yes, clear state exit flag
-                                setCurrentHandler(LSCRIPTStateBitField[LSTT_STATE_EXIT], major_version);
+                                setCurrentHandler(LSCRIPTStateBitField[LSTT_STATE_EXIT]);
                                 current_events &= ~LSCRIPTStateBitField[LSTT_STATE_EXIT];
-                                setCurrentEvents(current_events, major_version);
+                                setCurrentEvents(current_events);
 
                                 // check state exit event handler
                                 // if there is a handler, call it
                                 if (event_register & LSCRIPTStateBitField[LSTT_STATE_EXIT])
                                 {
                                         ++events_processed;
-                                        callEventHandler(LSTT_STATE_EXIT, major_version, id, quanta);
+                                        callEventHandler(LSTT_STATE_EXIT, id, quanta);
                                         return;
                                 }
                         }
@@ -841,32 +862,32 @@ void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id,
                         // if no handler or no state exit flag switch to new state
                         // set state entry flag and clear other CE flags
                         current_events = LSCRIPTStateBitField[LSTT_STATE_ENTRY];
-                        setCurrentEvents(current_events, major_version);
+                        setCurrentEvents(current_events);
 
                         U64 handled_events = nextState();
-                        setEventHandlers(handled_events, major_version);
+                        setEventHandlers(handled_events);
                 }
 
                 // try to get next event from stack
                 BOOL b_done = FALSE;
                 LSCRIPTStateEventType event = LSTT_NULL;
 
-                current_events = getCurrentEvents(major_version);
-                event_register = getEventHandlers(major_version);
+                current_events = getCurrentEvents();
+                event_register = getEventHandlers();
 
                 // first, check to see if state_entry or onrez are raised and handled
                 if ((current_events & LSCRIPTStateBitField[LSTT_STATE_ENTRY])
                         &&(current_events & event_register))
                 {
                         ++events_processed;
-                        callEventHandler(LSTT_STATE_ENTRY, major_version, id, quanta);
+                        callEventHandler(LSTT_STATE_ENTRY, id, quanta);
                         b_done = TRUE;
                 }
                 else if ((current_events & LSCRIPTStateBitField[LSTT_REZ])
                                  &&(current_events & event_register))
                 {
                         ++events_processed;
-                        callQueuedEventHandler(LSTT_REZ, major_version, id, quanta);
+                        callQueuedEventHandler(LSTT_REZ, id, quanta);
                         b_done = TRUE;
                 }
 
@@ -876,7 +897,7 @@ void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id,
                         if(getEventCount() > 0)
                         {
                                 ++events_processed;
-                                callNextQueuedEventHandler(event_register, major_version, id, quanta);
+                                callNextQueuedEventHandler(event_register, id, quanta);
                                 b_done = TRUE;
                         }
                         else
@@ -887,7 +908,7 @@ void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id,
                                 {
                                         event = return_first_event((S32)handled_current);
                                         ++events_processed;
-                                        callEventHandler(event, major_version, id, quanta);
+                                        callEventHandler(event, id, quanta);
                                 }
                                 b_done = TRUE;
                         }
@@ -895,8 +916,8 @@ void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id,
         }
 }
 
-// Run for a single timeslice, or until a yield is due
-F32 LLScriptExecute::runQuanta(BOOL b_print, const LLUUID &id, const char **errorstr, BOOL &state_transition, F32 quanta, U32& events_processed, LLTimer& timer)
+// Run for a single timeslice, or until a yield or state transition is due
+F32 LLScriptExecute::runQuanta(BOOL b_print, const LLUUID &id, const char **errorstr, F32 quanta, U32& events_processed, LLTimer& timer)
 {
         U32 timer_checks = 0;
         F32 inloop = 0;
@@ -907,7 +928,7 @@ F32 LLScriptExecute::runQuanta(BOOL b_print, const LLUUID &id, const char **erro
         // on current execution speed.
         while(true)
         {
-                runInstructions(b_print, id, errorstr, state_transition, 
+                runInstructions(b_print, id, errorstr,
                                                 events_processed, quanta);
                 
                 static const S32 lsl_timer_check_skip = 4;
@@ -3277,7 +3298,7 @@ BOOL run_state(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
         {
                 major_version = 2;
         }
-
+                                        
         S32 current_state = get_register(buffer, LREG_CS);
         if (state != current_state)
         {
@@ -3985,7 +4006,6 @@ void lscript_run(const std::string& filename, BOOL b_debug)
         LLTimer timer;
 
         const char *error;
-        BOOL b_state;
         LLScriptExecuteLSL2 *execute = NULL;
 
         if (filename.empty())
@@ -4009,7 +4029,7 @@ void lscript_run(const std::string& filename, BOOL b_debug)
 
                 do {
                         LLTimer timer2;
-                        execute->runQuanta(b_debug, LLUUID::null, &error, b_state, 
+                        execute->runQuanta(b_debug, LLUUID::null, &error,
                                                            time_slice, events_processed, timer2);
                 } while (!execute->isFinished());
 
@@ -4044,7 +4064,8 @@ void lscript_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
                 break;
         case 'k':
                 data->mType = LST_KEY;
-
+                data->mKey = NULL;
+                
                 base_address = lscript_pop_int(buffer);
         // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
         // and function clean up of ref counts isn't based on scope (a mistake, I know)
@@ -4063,7 +4084,7 @@ void lscript_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
                         }
                         lsa_decrease_ref_count(buffer, base_address);
                 }
-                else
+                if (data->mKey == NULL)
                 {
                         data->mKey = new char[1];
                         data->mKey[0] = 0;
@@ -4071,6 +4092,7 @@ void lscript_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
                 break;
         case 's':
                 data->mType = LST_STRING;
+                data->mString = NULL;
 
                 base_address = lscript_pop_int(buffer);
         // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
@@ -4090,7 +4112,7 @@ void lscript_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
                         }
                         lsa_decrease_ref_count(buffer, base_address);
                 }
-                else
+                if (data->mString == NULL)
                 {
                         data->mString = new char[1];
                         data->mString[0] = 0;
diff --git a/linden/indra/lscript/lscript_library/lscript_library.cpp b/linden/indra/lscript/lscript_library/lscript_library.cpp
index e7d8284..505b123 100644
--- a/linden/indra/lscript/lscript_library/lscript_library.cpp
+++ b/linden/indra/lscript/lscript_library/lscript_library.cpp
@@ -448,6 +448,7 @@ void LLScriptLibrary::init()
         addFunction(new LLScriptLibraryFunction(10.f, 0.f, dummy_func, "llDetectedTouchBinormal", "v", "i", "vector llDetectedTouchBinormal(integer number)\nreturns the surface binormal for a triggered touch event"));
         addFunction(new LLScriptLibraryFunction(10.f, 0.f, dummy_func, "llDetectedTouchST", "v", "i", "vector llDetectedTouchST(integer number)\nreturns the s and t coordinates in the first two components of a vector, for a triggered touch event"));
 
+        addFunction(new LLScriptLibraryFunction(10.f, 0.f, dummy_func, "llSHA1String", "s", "s", "string llSHA1String(string sr)\nPerforms a SHA1 security Hash.  Returns a 40 character hex string."));
 
 
         // energy, sleep, dummy_func, name, return type, parameters, help text, gods-only