Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Imported existing code

Browse Source
This commit is contained in:
Hazim Gazov
2010-04-02 02:48:44 -03:00
parent 48fbc5ae91
commit 7a86d01598
13996 changed files with 2468699 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
indra/lscript/CMakeLists.txt Normal file
View File

@@ -0,0 +1,21 @@
# -*- cmake -*-
set(lscript_HEADER_FILES
llscriptresource.h
llscriptresourceconsumer.h
llscriptresourcepool.h
lscript_alloc.h
lscript_byteconvert.h
lscript_byteformat.h
lscript_execute.h
lscript_export.h
lscript_http.h
lscript_library.h
lscript_rt_interface.h
)
add_subdirectory(lscript_compile)
add_subdirectory(lscript_execute)
add_subdirectory(lscript_library)

75
indra/lscript/llscriptresource.h Normal file
View File

@@ -0,0 +1,75 @@
/**
* @file llscriptresource.h
* @brief LLScriptResource class definition
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLSCRIPTRESOURCE_H
#define LL_LLSCRIPTRESOURCE_H
#include "stdtypes.h"
// An LLScriptResource is a limited resource per ID.
class LLScriptResource
{
public:
LLScriptResource();
// If amount resources are available will mark amount resouces
// used and returns true
// Otherwise returns false and doesn't mark any resources used.
bool request(S32 amount = 1);
// Release amount resources from use if at least amount resources are used and return true
// If amount is more than currently used no resources are released and return false
bool release(S32 amount = 1);
// Returns how many resources are available
S32 getAvailable() const;
// Sets the total amount of available resources
// It is possible to set the amount to less than currently used
// Most likely to happen on parcel ownership change
void setTotal(S32 amount);
// Get the total amount of available resources
S32 getTotal() const;
// Get the number of resources used
S32 getUsed() const;
// true if more resources used than total available
bool isOverLimit() const;
private:
S32 mTotal; // How many resources have been set aside
S32 mUsed; // How many resources are currently in use
};
#endif // LL_LLSCRIPTRESOURCE_H

67
indra/lscript/llscriptresourceconsumer.h Normal file
View File

@@ -0,0 +1,67 @@
/**
* @file llscriptresourceconsumer.h
* @brief An interface for a script resource consumer.
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLSCRIPTRESOURCECONSUMER_H
#define LL_LLSCRIPTRESOURCECONSUMER_H
#include "linden_common.h"
class LLScriptResourcePool;
// Entities that use limited script resources
// should implement this interface
class LLScriptResourceConsumer
{
public:
LLScriptResourceConsumer();
virtual ~LLScriptResourceConsumer() { }
// Get the number of public urls used by this consumer.
virtual S32 getUsedPublicURLs() const = 0;
// Get the resource pool this consumer is currently using.
LLScriptResourcePool& getScriptResourcePool();
const LLScriptResourcePool& getScriptResourcePool() const;
bool switchScriptResourcePools(LLScriptResourcePool& new_pool);
bool canUseScriptResourcePool(const LLScriptResourcePool& resource_pool);
bool isInPool(const LLScriptResourcePool& resource_pool);
protected:
virtual void setScriptResourcePool(LLScriptResourcePool& pool);
LLScriptResourcePool* mScriptResourcePool;
};
#endif // LL_LLSCRIPTRESOURCECONSUMER_H

57
indra/lscript/llscriptresourcepool.h Normal file
View File

@@ -0,0 +1,57 @@
/**
* @file llscriptresourcepool.h
* @brief A collection of LLScriptResources
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLSCRIPTRESOURCEPOOL_H
#define LL_LLSCRIPTRESOURCEPOOL_H
#include "llscriptresource.h"
// This is just a holder for LLSimResources
class LLScriptResourcePool
{
public:
LLScriptResourcePool();
// ~LLSimResourceMgr();
LLScriptResource& getPublicURLResource();
const LLScriptResource& getPublicURLResource() const;
// An empty resource pool.
static LLScriptResourcePool null;
private:
LLScriptResource mLSLPublicURLs;
};
#endif

299
indra/lscript/lscript_alloc.h Normal file
View File

@@ -0,0 +1,299 @@
/**
* @file lscript_alloc.h
* @brief General heap management for scripting system
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_ALLOC_H
#define LL_LSCRIPT_ALLOC_H
// #define at top of file accelerates gcc compiles
// Under gcc 2.9, the manual is unclear if comments can appear above #ifndef
// Under gcc 3, the manual explicitly states comments can appear above the #ifndef
#include "lscript_byteconvert.h"
#include "lscript_library.h"
void reset_hp_to_safe_spot(const U8 *buffer);
// supported data types
// basic types
// integer 4 bytes of integer data
// float 4 bytes of float data
// string data null terminated 1 byte string
// key data null terminated 1 byte string
// vector data 12 bytes of 3 floats
// quaternion data 16 bytes of 4 floats
// list type
// list data 4 bytes of number of entries followed by followed by pointer
// string pointer 4 bytes of address of string data on the heap (only used in list data)
// key pointer 4 bytes of address of key data on the heap (only used in list data)
// heap format
//
// 4 byte offset to next block (in bytes)
// 1 byte of type of variable or empty
// 2 bytes of reference count
// nn bytes of data
const S32 MAX_HEAP_SIZE = TOP_OF_MEMORY;
class LLScriptAllocEntry
{
public:
LLScriptAllocEntry() : mSize(0), mType(LST_NULL), mReferenceCount(0) {}
LLScriptAllocEntry(S32 offset, U8 type) : mSize(offset), mType(type), mReferenceCount(1) {}
friend std::ostream& operator<<(std::ostream& s, const LLScriptAllocEntry &a)
{
s << "Size: " << a.mSize << " Type: " << LSCRIPTTypeNames[a.mType] << " Count: " << a.mReferenceCount;
return s;
}
S32 mSize;
U8 mType;
S16 mReferenceCount;
};
// this is only OK because we only load/save via accessors below
const S32 SIZEOF_SCRIPT_ALLOC_ENTRY = 7;
inline void alloc_entry2bytestream(U8 *buffer, S32 &offset, const LLScriptAllocEntry &entry)
{
if ( (offset < 0)
||(offset > MAX_HEAP_SIZE))
{
set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
}
else
{
integer2bytestream(buffer, offset, entry.mSize);
byte2bytestream(buffer, offset, entry.mType);
s162bytestream(buffer, offset, entry.mReferenceCount);
}
}
inline void bytestream2alloc_entry(LLScriptAllocEntry &entry, U8 *buffer, S32 &offset)
{
if ( (offset < 0)
||(offset > MAX_HEAP_SIZE))
{
set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
reset_hp_to_safe_spot(buffer);
}
else
{
entry.mSize = bytestream2integer(buffer, offset);
entry.mType = bytestream2byte(buffer, offset);
entry.mReferenceCount = bytestream2s16(buffer, offset);
}
}
// create a heap from the HR to TM
BOOL lsa_create_heap(U8 *heap_start, S32 size);
void lsa_fprint_heap(U8 *buffer, LLFILE *fp);
void lsa_print_heap(U8 *buffer);
// adding to heap
// if block is empty
// if block is at least block size + 4 larger than data
// split block
// insert data into first part
// return address
// else
// insert data into block
// return address
// else
// if next block is >= SP
// set Stack-Heap collision
// return NULL
// if next block is empty
// merge next block with current block
// go to start of algorithm
// else
// move to next block
// go to start of algorithm
S32 lsa_heap_add_data(U8 *buffer, LLScriptLibData *data, S32 heapsize, BOOL b_delete);
S32 lsa_heap_top(U8 *heap_start, S32 maxsize);
// split block
// set offset to point to new block
// set offset of new block to point to original offset - block size - data size
// set new block to empty
// set new block reference count to 0
void lsa_split_block(U8 *buffer, S32 &offset, S32 size, LLScriptAllocEntry &entry);
// insert data
// if data is non-list type
// set type to basic type, set reference count to 1, copy data, return address
// else
// set type to list data type, set reference count to 1
// for each list entry
// insert data
// return address
void lsa_insert_data(U8 *buffer, S32 &offset, LLScriptLibData *data, LLScriptAllocEntry &entry, S32 heapsize);
S32 lsa_create_data_block(U8 **buffer, LLScriptLibData *data, S32 base_offset);
// increase reference count
// increase reference count by 1
void lsa_increase_ref_count(U8 *buffer, S32 offset);
// decrease reference count
// decrease reference count by 1
// if reference count == 0
// set type to empty
void lsa_decrease_ref_count(U8 *buffer, S32 offset);
inline S32 get_max_heap_size(U8 *buffer)
{
return get_register(buffer, LREG_SP) - get_register(buffer, LREG_HR);
}
LLScriptLibData *lsa_get_data(U8 *buffer, S32 &offset, BOOL b_dec_ref);
LLScriptLibData *lsa_get_list_ptr(U8 *buffer, S32 &offset, BOOL b_dec_ref);
S32 lsa_cat_strings(U8 *buffer, S32 offset1, S32 offset2, S32 heapsize);
S32 lsa_cmp_strings(U8 *buffer, S32 offset1, S32 offset2);
S32 lsa_cat_lists(U8 *buffer, S32 offset1, S32 offset2, S32 heapsize);
S32 lsa_cmp_lists(U8 *buffer, S32 offset1, S32 offset2);
S32 lsa_preadd_lists(U8 *buffer, LLScriptLibData *data, S32 offset2, S32 heapsize);
S32 lsa_postadd_lists(U8 *buffer, S32 offset1, LLScriptLibData *data, S32 heapsize);
// modifying a list
// insert new list that is modified
// store returned address in original list's variable
// decrease reference count on old list
// list l1 = [10];
// list l2 = l1;
// l1 = [11];
// we want l2 == [10];
// more complicated example:
// list l1 = [10, 11];
// list l2 = l1;
// l1[0] = 12
// I think that we want l2 = [10, 11];
// one option would be to use syntax like:
// l1 = llSetList(l1, 0, 12);
// but this would require variable argument list matching
// which maybe is ok, but would be work
// the other option would be changes to lists that have multiple references causes a copy to occur
// popl @l1, 0, integer, 12
//
// would cause l1 to be copied, 12 to replace the 0th entry, and the address of the new list to be saved in l1
//
inline LLScriptLibData *lsa_bubble_sort(LLScriptLibData *src, S32 stride, S32 ascending)
{
S32 number = src->getListLength();
if (number <= 0)
{
return NULL;
}
if (stride <= 0)
{
stride = 1;
}
S32 i = 0;
if (number % stride)
{
LLScriptLibData *retval = src->mListp;
src->mListp = NULL;
return retval;
}
LLScriptLibData **sortarray = new LLScriptLibData*[number];
LLScriptLibData *temp = src->mListp;
while (temp)
{
sortarray[i] = temp;
i++;
temp = temp->mListp;
}
S32 j, s;
for (i = 0; i < number; i += stride)
{
for (j = i; j < number; j += stride)
{
if ( ((*sortarray[i]) <= (*sortarray[j]))
!= (ascending == TRUE))
{
for (s = 0; s < stride; s++)
{
temp = sortarray[i + s];
sortarray[i + s] = sortarray[j + s];
sortarray[j + s] = temp;
}
}
}
}
i = 1;
temp = sortarray[0];
while (i < number)
{
temp->mListp = sortarray[i++];
temp = temp->mListp;
}
temp->mListp = NULL;
src->mListp = NULL;
temp = sortarray[0];
delete[] sortarray;
return temp;
}
LLScriptLibData* lsa_randomize(LLScriptLibData* src, S32 stride);
#endif

1176
indra/lscript/lscript_byteconvert.h Normal file
View File

File diff suppressed because it is too large Load Diff

562
indra/lscript/lscript_byteformat.h Normal file
View File

@@ -0,0 +1,562 @@
/**
* @file lscript_byteformat.h
* @brief Shared code between compiler and assembler and LSL
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_BYTEFORMAT_H
#define LL_LSCRIPT_BYTEFORMAT_H
// Data shared between compiler/assembler and lscript execution code
#include "stdtypes.h"
const S32 LSL2_VERSION_NUMBER = 0x0200;
const S32 LSL2_VERSION1_END_NUMBER = 0x0101;
const S32 LSL2_VERSION2_START_NUMBER = 0x0200;
const S32 LSL2_MAJOR_VERSION_ONE = 1;
const S32 LSL2_MAJOR_VERSION_TWO = 2;
const S32 LSL2_CURRENT_MAJOR_VERSION = LSL2_MAJOR_VERSION_TWO;
const S32 TOP_OF_MEMORY = 16384;
typedef enum e_lscript_registers
{
LREG_INVALID,
LREG_IP, // instruction pointer
LREG_VN, // version number
LREG_BP, // base pointer - what local variables are referenced from
LREG_SP, // stack pointer - where the top of the stack is
LREG_HR, // heap register - where in memory does the heap start
LREG_HP, // heap pointer - where is the top of the heap?
LREG_CS, // current state - what state are we currently in?
LREG_NS, // next state - what state are we currently in?
LREG_CE, // current events - what events are waiting to be handled?
LREG_IE, // in event - which event handler are we currently in?
LREG_ER, // event register - what events do we have active handlers for?
LREG_FR, // fault register - which errors are currently active?
LREG_SLR, // sleep register - are we sleeping?
LREG_GVR, // global variable register - where do global variables start
LREG_GFR, // global function register - where do global functions start
LREG_SR, // state register - where do states start
LREG_TM, // top of memory - where is the top of memory
LREG_PR, // parameter register - data passed to script from launcher
LREG_ESR, // energy supply register - how much energy do we have on board?
LREG_NCE, // 64 bit current envents - what events are waiting to be handled?
LREG_NIE, // 64 bit in event - which event handler are we currently in?
LREG_NER, // 64 bit event register - what events do we have active handlers for?
LREG_EOF
} LSCRIPTRegisters;
const S32 gLSCRIPTRegisterAddresses[LREG_EOF] = /* Flawfinder: ignore */
{
0, // LREG_INVALID
4, // LREG_IP
8, // LREG_VN
12, // LREG_BP
16, // LREG_SP
20, // LREG_HR
24, // LREG_HP
28, // LREG_CS
32, // LREG_NS
36, // LREG_CE
40, // LREG_IE
44, // LREG_ER
48, // LREG_FR
52, // LREG_SLR
56, // LREG_GVR
60, // LREG_GFR
72, // LREG_SR
0, // LREG_TM
64, // LREG_PR
68, // LREG_ESR
76, // LREG_NCE
84, // LREG_NIE
92, // LREG_NER
};
const char * const gLSCRIPTRegisterNames[LREG_EOF] =
{
"INVALID", // LREG_INVALID
"IP", // LREG_IP
"VN", // LREG_VN
"BP", // LREG_BP
"SP", // LREG_SP
"HR", // LREG_HR
"HP", // LREG_HP
"CS", // LREG_CS
"NS", // LREG_NS
"CE", // LREG_CE
"IE", // LREG_IE
"ER", // LREG_ER
"FR", // LREG_FR
"SLR", // LREG_SLR
"GVR", // LREG_GVR
"GFR", // LREG_GFR
"SR", // LREG_SR
"TM", // LREG_TM
"PR", // LREG_PR
"ESR", // LREG_ESR
"NCE", // LREG_NCE
"NIE", // LREG_NIE
"NER", // LREG_NER
};
typedef enum e_lscript_op_codes
{
LOPC_INVALID,
LOPC_NOOP,
LOPC_POP,
LOPC_POPS,
LOPC_POPL,
LOPC_POPV,
LOPC_POPQ,
LOPC_POPARG,
LOPC_POPIP,
LOPC_POPBP,
LOPC_POPSP,
LOPC_POPSLR,
LOPC_DUP,
LOPC_DUPS,
LOPC_DUPL,
LOPC_DUPV,
LOPC_DUPQ,
LOPC_STORE,
LOPC_STORES,
LOPC_STOREL,
LOPC_STOREV,
LOPC_STOREQ,
LOPC_STOREG,
LOPC_STOREGS,
LOPC_STOREGL,
LOPC_STOREGV,
LOPC_STOREGQ,
LOPC_LOADP,
LOPC_LOADSP,
LOPC_LOADLP,
LOPC_LOADVP,
LOPC_LOADQP,
LOPC_LOADGP,
LOPC_LOADGLP,
LOPC_LOADGSP,
LOPC_LOADGVP,
LOPC_LOADGQP,
LOPC_PUSH,
LOPC_PUSHS,
LOPC_PUSHL,
LOPC_PUSHV,
LOPC_PUSHQ,
LOPC_PUSHG,
LOPC_PUSHGS,
LOPC_PUSHGL,
LOPC_PUSHGV,
LOPC_PUSHGQ,
LOPC_PUSHIP,
LOPC_PUSHBP,
LOPC_PUSHSP,
LOPC_PUSHARGB,
LOPC_PUSHARGI,
LOPC_PUSHARGF,
LOPC_PUSHARGS,
LOPC_PUSHARGV,
LOPC_PUSHARGQ,
LOPC_PUSHE,
LOPC_PUSHEV,
LOPC_PUSHEQ,
LOPC_PUSHARGE,
LOPC_ADD,
LOPC_SUB,
LOPC_MUL,
LOPC_DIV,
LOPC_MOD,
LOPC_EQ,
LOPC_NEQ,
LOPC_LEQ,
LOPC_GEQ,
LOPC_LESS,
LOPC_GREATER,
LOPC_BITAND,
LOPC_BITOR,
LOPC_BITXOR,
LOPC_BOOLAND,
LOPC_BOOLOR,
LOPC_NEG,
LOPC_BITNOT,
LOPC_BOOLNOT,
LOPC_JUMP,
LOPC_JUMPIF,
LOPC_JUMPNIF,
LOPC_STATE,
LOPC_CALL,
LOPC_RETURN,
LOPC_CAST,
LOPC_STACKTOS,
LOPC_STACKTOL,
LOPC_PRINT,
LOPC_CALLLIB,
LOPC_CALLLIB_TWO_BYTE,
LOPC_SHL,
LOPC_SHR,
LOPC_EOF
} LSCRIPTOpCodesEnum;
const U8 LSCRIPTOpCodes[LOPC_EOF] =
{
0x00, // LOPC_INVALID
0x00, // LOPC_NOOP
0x01, // LOPC_POP
0x02, // LOPC_POPS
0x03, // LOPC_POPL
0x04, // LOPC_POPV
0x05, // LOPC_POPQ
0x06, // LOPC_POPARG
0x07, // LOPC_POPIP
0x08, // LOPC_POPBP
0x09, // LOPC_POPSP
0x0a, // LOPC_POPSLR
0x20, // LOPC_DUP
0x21, // LOPC_DUPS
0x22, // LOPC_DUPL
0x23, // LOPC_DUPV
0x24, // LOPC_DUPQ
0x30, // LOPC_STORE
0x31, // LOPC_STORES
0x32, // LOPC_STOREL
0x33, // LOPC_STOREV
0x34, // LOPC_STOREQ
0x35, // LOPC_STOREG
0x36, // LOPC_STOREGS
0x37, // LOPC_STOREGL
0x38, // LOPC_STOREGV
0x39, // LOPC_STOREGQ
0x3a, // LOPC_LOADP
0x3b, // LOPC_LOADSP
0x3c, // LOPC_LOADLP
0x3d, // LOPC_LOADVP
0x3e, // LOPC_LOADQP
0x3f, // LOPC_LOADGP
0x40, // LOPC_LOADGSP
0x41, // LOPC_LOADGLP
0x42, // LOPC_LOADGVP
0x43, // LOPC_LOADGQP
0x50, // LOPC_PUSH
0x51, // LOPC_PUSHS
0x52, // LOPC_PUSHL
0x53, // LOPC_PUSHV
0x54, // LOPC_PUSHQ
0x55, // LOPC_PUSHG
0x56, // LOPC_PUSHGS
0x57, // LOPC_PUSHGL
0x58, // LOPC_PUSHGV
0x59, // LOPC_PUSHGQ
0x5a, // LOPC_PUSHIP
0x5b, // LOPC_PUSHBP
0x5c, // LOPC_PUSHSP
0x5d, // LOPC_PUSHARGB
0x5e, // LOPC_PUSHARGI
0x5f, // LOPC_PUSHARGF
0x60, // LOPC_PUSHARGS
0x61, // LOPC_PUSHARGV
0x62, // LOPC_PUSHARGQ
0x63, // LOPC_PUSHE
0x64, // LOPC_PUSHEV
0x65, // LOPC_PUSHEQ
0x66, // LOPC_PUSHARGE
0x70, // LOPC_ADD
0x71, // LOPC_SUB
0x72, // LOPC_MUL
0x73, // LOPC_DIV
0x74, // LOPC_MOD
0x75, // LOPC_EQ
0x76, // LOPC_NEQ
0x77, // LOPC_LEQ
0x78, // LOPC_GEQ
0x79, // LOPC_LESS
0x7a, // LOPC_GREATER
0x7b, // LOPC_BITAND
0x7c, // LOPC_BITOR
0x7d, // LOPC_BITXOR
0x7e, // LOPC_BOOLAND
0x7f, // LOPC_BOOLOR
0x80, // LOPC_NEG
0x81, // LOPC_BITNOT
0x82, // LOPC_BOOLNOT
0x90, // LOPC_JUMP
0x91, // LOPC_JUMPIF
0x92, // LOPC_JUMPNIF
0x93, // LOPC_STATE
0x94, // LOPC_CALL
0x95, // LOPC_RETURN
0xa0, // LOPC_CAST
0xb0, // LOPC_STACKTOS
0xb1, // LOPC_STACKTOL
0xc0, // LOPC_PRINT
0xd0, // LOPC_CALLLIB
0xd1, // LOPC_CALLLIB_TWO_BYTE
0xe0, // LOPC_SHL
0xe1 // LOPC_SHR
};
typedef enum e_lscript_state_event_type
{
LSTT_NULL,
LSTT_STATE_ENTRY,
LSTT_STATE_EXIT,
LSTT_TOUCH_START,
LSTT_TOUCH,
LSTT_TOUCH_END,
LSTT_COLLISION_START,
LSTT_COLLISION,
LSTT_COLLISION_END,
LSTT_LAND_COLLISION_START,
LSTT_LAND_COLLISION,
LSTT_LAND_COLLISION_END,
LSTT_TIMER,
LSTT_CHAT,
LSTT_REZ,
LSTT_SENSOR,
LSTT_NO_SENSOR,
LSTT_CONTROL,
LSTT_MONEY,
LSTT_EMAIL,
LSTT_AT_TARGET,
LSTT_NOT_AT_TARGET,
LSTT_AT_ROT_TARGET,
LSTT_NOT_AT_ROT_TARGET,
LSTT_RTPERMISSIONS,
LSTT_INVENTORY,
LSTT_ATTACH,
LSTT_DATASERVER,
LSTT_LINK_MESSAGE,
LSTT_MOVING_START,
LSTT_MOVING_END,
LSTT_OBJECT_REZ,
LSTT_REMOTE_DATA,
LSTT_HTTP_RESPONSE,
LSTT_HTTP_REQUEST,
LSTT_EOF,
LSTT_STATE_BEGIN = LSTT_STATE_ENTRY,
LSTT_STATE_END = LSTT_EOF
} LSCRIPTStateEventType;
const U64 LSCRIPTStateBitField[LSTT_EOF] =
{
0x0000000000000000, // LSTT_NULL
0x0000000000000001, // LSTT_STATE_ENTRY
0x0000000000000002, // LSTT_STATE_EXIT
0x0000000000000004, // LSTT_TOUCH_START
0x0000000000000008, // LSTT_TOUCH
0x0000000000000010, // LSTT_TOUCH_END
0x0000000000000020, // LSTT_COLLISION_START
0x0000000000000040, // LSTT_COLLISION
0x0000000000000080, // LSTT_COLLISION_END
0x0000000000000100, // LSTT_LAND_COLLISION_START
0x0000000000000200, // LSTT_LAND_COLLISION
0x0000000000000400, // LSTT_LAND_COLLISION_END
0x0000000000000800, // LSTT_TIMER
0x0000000000001000, // LSTT_CHAT
0x0000000000002000, // LSTT_REZ
0x0000000000004000, // LSTT_SENSOR
0x0000000000008000, // LSTT_NO_SENSOR
0x0000000000010000, // LSTT_CONTROL
0x0000000000020000, // LSTT_MONEY
0x0000000000040000, // LSTT_EMAIL
0x0000000000080000, // LSTT_AT_TARGET
0x0000000000100000, // LSTT_NOT_AT_TARGET
0x0000000000200000, // LSTT_AT_ROT_TARGET
0x0000000000400000, // LSTT_NOT_AT_ROT_TARGET
0x0000000000800000, // LSTT_RTPERMISSIONS
0x0000000001000000, // LSTT_INVENTORY
0x0000000002000000, // LSTT_ATTACH
0x0000000004000000, // LSTT_DATASERVER
0x0000000008000000, // LSTT_LINK_MESSAGE
0x0000000010000000, // LSTT_MOVING_START
0x0000000020000000, // LSTT_MOVING_END
0x0000000040000000, // LSTT_OBJECT_REZ
0x0000000080000000, // LSTT_REMOTE_DATA
0x0000000100000000LL, // LSTT_HTTP_RESPOSE
0x0000000200000000LL // LSTT_HTTP_REQUEST
};
inline S32 get_event_handler_jump_position(U64 bit_field, LSCRIPTStateEventType type)
{
S32 count = 0, position = LSTT_STATE_ENTRY;
while (position < type)
{
if (bit_field & 0x1)
{
count++;
}
bit_field >>= 1;
position++;
}
return count;
}
inline S32 get_number_of_event_handlers(U64 bit_field)
{
S32 count = 0, position = 0;
while (position < LSTT_EOF)
{
if (bit_field & 0x1)
{
count++;
}
bit_field >>= 1;
position++;
}
return count;
}
typedef enum e_lscript_types
{
LST_NULL,
LST_INTEGER,
LST_FLOATINGPOINT,
LST_STRING,
LST_KEY,
LST_VECTOR,
LST_QUATERNION,
LST_LIST,
LST_UNDEFINED,
LST_EOF
} LSCRIPTType;
const U8 LSCRIPTTypeByte[LST_EOF] =
{
LST_NULL,
LST_INTEGER,
LST_FLOATINGPOINT,
LST_STRING,
LST_KEY,
LST_VECTOR,
LST_QUATERNION,
LST_LIST,
LST_NULL,
};
const U8 LSCRIPTTypeHi4Bits[LST_EOF] =
{
LST_NULL,
LST_INTEGER << 4,
LST_FLOATINGPOINT << 4,
LST_STRING << 4,
LST_KEY << 4,
LST_VECTOR << 4,
LST_QUATERNION << 4,
LST_LIST << 4,
LST_UNDEFINED << 4,
};
const char * const LSCRIPTTypeNames[LST_EOF] = /*Flawfinder: ignore*/
{
"VOID",
"integer",
"float",
"string",
"key",
"vector",
"quaternion",
"list",
"invalid"
};
const S32 LSCRIPTDataSize[LST_EOF] =
{
0, // VOID
4, // integer
4, // float
4, // string
4, // key
12, // vector
16, // quaternion
4, // list
0 // invalid
};
typedef enum e_lscript_runtime_faults
{
LSRF_INVALID,
LSRF_MATH,
LSRF_STACK_HEAP_COLLISION,
LSRF_BOUND_CHECK_ERROR,
LSRF_HEAP_ERROR,
LSRF_VERSION_MISMATCH,
LSRF_MISSING_INVENTORY,
LSRF_SANDBOX,
LSRF_CHAT_OVERRUN,
LSRF_TOO_MANY_LISTENS,
LSRF_NESTING_LISTS,
LSRF_CLI,
LSRF_EOF
} LSCRIPTRunTimeFaults;
extern const char* LSCRIPTRunTimeFaultStrings[LSRF_EOF]; /*Flawfinder: ignore*/
typedef enum e_lscript_runtime_permissions
{
SCRIPT_PERMISSION_DEBIT,
SCRIPT_PERMISSION_TAKE_CONTROLS,
SCRIPT_PERMISSION_REMAP_CONTROLS,
SCRIPT_PERMISSION_TRIGGER_ANIMATION,
SCRIPT_PERMISSION_ATTACH,
SCRIPT_PERMISSION_RELEASE_OWNERSHIP,
SCRIPT_PERMISSION_CHANGE_LINKS,
SCRIPT_PERMISSION_CHANGE_JOINTS,
SCRIPT_PERMISSION_CHANGE_PERMISSIONS,
SCRIPT_PERMISSION_TRACK_CAMERA,
SCRIPT_PERMISSION_CONTROL_CAMERA,
SCRIPT_PERMISSION_EOF
} LSCRIPTRunTimePermissions;
const U32 LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_EOF] =
{
(0x1 << 1), // SCRIPT_PERMISSION_DEBIT,
(0x1 << 2), // SCRIPT_PERMISSION_TAKE_CONTROLS,
(0x1 << 3), // SCRIPT_PERMISSION_REMAP_CONTROLS,
(0x1 << 4), // SCRIPT_PERMISSION_TRIGGER_ANIMATION,
(0x1 << 5), // SCRIPT_PERMISSION_ATTACH,
(0x1 << 6), // SCRIPT_PERMISSION_RELEASE_OWNERSHIP,
(0x1 << 7), // SCRIPT_PERMISSION_CHANGE_LINKS,
(0x1 << 8), // SCRIPT_PERMISSION_CHANGE_JOINTS,
(0x1 << 9), // SCRIPT_PERMISSION_CHANGE_PERMISSIONS
(0x1 << 10),// SCRIPT_PERMISSION_TRACK_CAMERA
(0x1 << 11),// SCRIPT_PERMISSION_CONTROL_CAMERA
};
// http_request string constants
extern const char* URL_REQUEST_GRANTED;
extern const char* URL_REQUEST_DENIED;
extern const U64 LSL_HTTP_REQUEST_TIMEOUT;
#endif

174
indra/lscript/lscript_compile/CMakeLists.txt Normal file
View File

@@ -0,0 +1,174 @@
# -*- cmake -*-
include(00-Common)
include(LLCommon)
include(LLMath)
include(LLMessage)
include(LLInventory)
include(LScript)
include(FindCygwin)
find_program(FLEX flex
"C:/Program Files/GnuWin32/bin"
${CYGWIN_INSTALL_PATH}/bin
/bin
/usr/bin
/usr/local/bin
)
mark_as_advanced(FLEX)
find_program(BISON bison
"C:/Program Files/GnuWin32/bin"
${CYGWIN_INSTALL_PATH}/bin
/bin
/usr/bin
/usr/local/bin
)
mark_as_advanced(BISON)
find_program(M4 m4
"C:/Program Files/GnuWin32/bin"
${CYGWIN_INSTALL_PATH}/bin
/bin
/usr/bin
/usr/local/bin
)
mark_as_advanced(M4)
include_directories(
${LLCOMMON_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LLMESSAGE_INCLUDE_DIRS}
${LLINVENTORY_INCLUDE_DIRS}
${LSCRIPT_INCLUDE_DIRS}
)
set(lscript_generated_SOURCE_FILES
indra.l.cpp
indra.y.cpp
)
set(lscript_compile_SOURCE_FILES
lscript_alloc.cpp
lscript_bytecode.cpp
lscript_error.cpp
lscript_heap.cpp
lscript_resource.cpp
lscript_scope.cpp
lscript_tree.cpp
lscript_typecheck.cpp
)
set(lscript_compile_HEADER_FILES
CMakeLists.txt
indra.l
indra.y
../lscript_alloc.h
../lscript_byteformat.h
../lscript_byteconvert.h
../lscript_http.h
lscript_error.h
lscript_bytecode.h
lscript_heap.h
lscript_resource.h
lscript_scope.h
lscript_tree.h
lscript_typecheck.h
)
set_source_files_properties(${lscript_compile_HEADER_FILES}
PROPERTIES HEADER_FILE_ONLY TRUE)
set_source_files_properties(${lscript_generated_SOURCE_FILES}
PROPERTIES HEADER_FILE_ONLY FALSE GENERATED TRUE)
list(APPEND lscript_compile_SOURCE_FILES ${lscript_generated_SOURCE_FILES} ${lscript_compile_HEADER_FILES})
if(FLEX)
add_custom_command(
OUTPUT
${CMAKE_CURRENT_BINARY_DIR}/indra.l.cpp
COMMAND ${FLEX}
ARGS
-o${CMAKE_CURRENT_BINARY_DIR}/indra.l.cpp
${CMAKE_CURRENT_SOURCE_DIR}/indra.l
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/indra.l
)
else(FLEX)
message(STATUS "FLEX not found, using pre-generated lexer")
add_custom_command(
COMMENT "Copying pre-generated indra.l.cpp"
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/indra.l.cpp
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/indra_generated.l.cpp
${CMAKE_CURRENT_BINARY_DIR}/indra.l.cpp
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/indra_generated.l.cpp
)
endif(FLEX)
if (WINDOWS)
set_source_files_properties(indra.l.cpp
PROPERTIES COMPILE_FLAGS /DYY_NO_UNISTD_H)
endif (WINDOWS)
if(BISON)
if (WINDOWS)
get_filename_component(M4_PATH ${M4} PATH)
add_custom_command(
OUTPUT
${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/bison.bat
${BISON} ${M4_PATH}
${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
${CMAKE_CURRENT_SOURCE_DIR}/indra.y
DEPENDS
${CMAKE_CURRENT_SOURCE_DIR}/bison.bat
${CMAKE_CURRENT_SOURCE_DIR}/indra.y
)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/windows)
else (WINDOWS)
add_custom_command(
OUTPUT
${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
COMMAND
${BISON}
ARGS
-d -o ${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
${CMAKE_CURRENT_SOURCE_DIR}/indra.y
DEPENDS
${CMAKE_CURRENT_SOURCE_DIR}/indra.y
)
endif (WINDOWS)
if (DARWIN)
# Mac OS X 10.4 compatibility
add_custom_command(
OUTPUT
${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
COMMAND
mv
${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp.h
${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
)
endif (DARWIN)
else(BISON)
message(STATUS "BISON not found, using pre-generated parser")
add_custom_command(
COMMENT "Copying pre-generated indra.y.cpp, indra.y.hpp"
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/indra_generated.y.cpp
${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/indra_generated.y.hpp
${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/indra_generated.l.cpp
)
endif(BISON)
add_library (lscript_compile ${lscript_compile_SOURCE_FILES})
add_dependencies(lscript_compile prepare)

11
indra/lscript/lscript_compile/bison.bat Normal file
View File

@@ -0,0 +1,11 @@
@REM Run bison under Windows. This script is needed so that bison can
@REM find m4, even if neither program is present in PATH.
@set bison=%1
set M4PATH=%2
set M4=
@set output=%3
@set input=%4
set PATH=%M4PATH%;%PATH%
%bison% -d -o %output% %input%

904
indra/lscript/lscript_compile/indra.l Normal file
View File

@@ -0,0 +1,904 @@
N [0-9]
L [a-zA-Z_]
H [a-fA-F0-9]
E [Ee][+-]?{N}+
FS (f|F)
%e 10000
%n 4000
%p 5000
%{
// We maintain a pre-generated lexer source file to simplify user builds.
// Before committing changes to this file, manually run
//
// flex -o indra_generated.l.cpp indra.l
//
// to update the pre-generated lexer. Then commit all files simultaneously.
#include "linden_common.h"
// Deal with the fact that lex/yacc generates unreachable code
#ifdef LL_WINDOWS
#pragma warning (disable : 4018) // warning C4018: signed/unsigned mismatch
#pragma warning (disable : 4702) // warning C4702: unreachable code
#endif // LL_WINDOWS
#include "llmath.h"
#include "lscript_tree.h"
#include "lscript_typecheck.h"
#include "lscript_resource.h"
#include "indra.y.hpp"
#include "lltimer.h"
#include "indra_constants.h"
#include "llagentconstants.h"
#include "lllslconstants.h"
#include "lluuid.h"
#include "llassetstorage.h"
#include "llpartdata.h"
#include "llvehicleparams.h"
#include "llpermissionsflags.h"
#include "llfollowcamparams.h"
#include "llparcelflags.h"
#include "llregionflags.h"
#include "lscript_http.h"
#include "llclickaction.h"
void count();
void line_comment();
void block_comment();
void parse_string();
#define YYLMAX 16384
#define YY_NEVER_INTERACTIVE 1 /* stops flex from calling isatty() */
#ifdef LL_WINDOWS
#define isatty(x) 0 /* hack for bug in cygwin flex 2.5.35 */
#endif
#ifdef ECHO
#undef ECHO
#endif
#define ECHO do { } while (0)
#if defined(__cplusplus)
extern "C" { int yylex( void ); }
extern "C" { int yyparse( void ); }
extern "C" { int yyerror(const char *fmt, ...); }
#endif
%}
%%
"//" { gInternalLine++; gInternalColumn = 0; line_comment(); }
"/*" { block_comment(); }
"integer" { count(); return(INTEGER); }
"float" { count(); return(FLOAT_TYPE); }
"string" { count(); return(STRING); }
"key" { count(); return(LLKEY); }
"vector" { count(); return(VECTOR); }
"quaternion" { count(); return(QUATERNION); }
"rotation" { count(); return(QUATERNION); }
"list" { count(); return(LIST); }
"default" { count(); yylval.sval = new char[strlen(yytext) + 1]; strcpy(yylval.sval, yytext); return(STATE_DEFAULT); }
"state" { count(); return(STATE); }
"event" { count(); return(EVENT); }
"jump" { count(); return(JUMP); }
"return" { count(); return(RETURN); }
"if" { count(); return(IF); }
"else" { count(); return(ELSE); }
"for" { count(); return(FOR); }
"do" { count(); return(DO); }
"while" { count(); return(WHILE); }
"state_entry" { count(); return(STATE_ENTRY); }
"state_exit" { count(); return(STATE_EXIT); }
"touch_start" { count(); return(TOUCH_START); }
"touch" { count(); return(TOUCH); }
"touch_end" { count(); return(TOUCH_END); }
"collision_start" { count(); return(COLLISION_START); }
"collision" { count(); return(COLLISION); }
"collision_end" { count(); return(COLLISION_END); }
"land_collision_start" { count(); return(LAND_COLLISION_START); }
"land_collision" { count(); return(LAND_COLLISION); }
"land_collision_end" { count(); return(LAND_COLLISION_END); }
"timer" { count(); return(TIMER); }
"listen" { count(); return(CHAT); }
"sensor" { count(); return(SENSOR); }
"no_sensor" { count(); return(NO_SENSOR); }
"control" { count(); return(CONTROL); }
"print" { count(); return(PRINT); }
"at_target" { count(); return(AT_TARGET); }
"not_at_target" { count(); return(NOT_AT_TARGET); }
"at_rot_target" { count(); return(AT_ROT_TARGET); }
"not_at_rot_target" { count(); return(NOT_AT_ROT_TARGET); }
"money" { count(); return(MONEY); }
"email" { count(); return(EMAIL); }
"run_time_permissions" { count(); return(RUN_TIME_PERMISSIONS); }
"changed" { count(); return(INVENTORY); }
"attach" { count(); return(ATTACH); }
"dataserver" { count(); return(DATASERVER); }
"moving_start" { count(); return(MOVING_START); }
"moving_end" { count(); return(MOVING_END); }
"link_message" { count(); return(LINK_MESSAGE); }
"on_rez" { count(); return(REZ); }
"object_rez" { count(); return(OBJECT_REZ); }
"remote_data" { count(); return(REMOTE_DATA); }
"http_response" { count(); return(HTTP_RESPONSE); }
"http_request" { count(); return(HTTP_REQUEST); }
"." { count(); return(PERIOD); }
0[xX]{H}+ { count(); yylval.ival = strtoul(yytext, NULL, 0); return(INTEGER_CONSTANT); }
{N}+ { count(); yylval.ival = strtoul(yytext, NULL, 10); return(INTEGER_CONSTANT); }
"TRUE" { count(); yylval.ival = 1; return(INTEGER_TRUE); }
"FALSE" { count(); yylval.ival = 0; return(INTEGER_FALSE); }
"STATUS_PHYSICS" { count(); yylval.ival = 0x1; return(INTEGER_CONSTANT); }
"STATUS_ROTATE_X" { count(); yylval.ival = 0x2; return(INTEGER_CONSTANT); }
"STATUS_ROTATE_Y" { count(); yylval.ival = 0x4; return(INTEGER_CONSTANT); }
"STATUS_ROTATE_Z" { count(); yylval.ival = 0x8; return(INTEGER_CONSTANT); }
"STATUS_PHANTOM" { count(); yylval.ival = 0x10; return(INTEGER_CONSTANT); }
"STATUS_SANDBOX" { count(); yylval.ival = 0x20; return(INTEGER_CONSTANT); }
"STATUS_BLOCK_GRAB" { count(); yylval.ival = 0x40; return(INTEGER_CONSTANT); }
"STATUS_DIE_AT_EDGE" { count(); yylval.ival = 0x80; return(INTEGER_CONSTANT); }
"STATUS_RETURN_AT_EDGE" { count(); yylval.ival = 0x100; return(INTEGER_CONSTANT); }
"STATUS_CAST_SHADOWS" { count(); yylval.ival = 0x200; return(INTEGER_CONSTANT); }
"AGENT_FLYING" { count(); yylval.ival = AGENT_FLYING; return(INTEGER_CONSTANT); }
"AGENT_ATTACHMENTS" { count(); yylval.ival = AGENT_ATTACHMENTS; return(INTEGER_CONSTANT); }
"AGENT_SCRIPTED" { count(); yylval.ival = AGENT_SCRIPTED; return(INTEGER_CONSTANT); }
"AGENT_MOUSELOOK" { count(); yylval.ival = AGENT_MOUSELOOK; return(INTEGER_CONSTANT); }
"AGENT_SITTING" { count(); yylval.ival = AGENT_SITTING; return(INTEGER_CONSTANT); }
"AGENT_ON_OBJECT" { count(); yylval.ival = AGENT_ON_OBJECT; return(INTEGER_CONSTANT); }
"AGENT_AWAY" { count(); yylval.ival = AGENT_AWAY; return(INTEGER_CONSTANT); }
"AGENT_WALKING" { count(); yylval.ival = AGENT_WALKING; return(INTEGER_CONSTANT); }
"AGENT_IN_AIR" { count(); yylval.ival = AGENT_IN_AIR; return(INTEGER_CONSTANT); }
"AGENT_TYPING" { count(); yylval.ival = AGENT_TYPING; return(INTEGER_CONSTANT); }
"AGENT_CROUCHING" { count(); yylval.ival = AGENT_CROUCHING; return(INTEGER_CONSTANT); }
"AGENT_BUSY" { count(); yylval.ival = AGENT_BUSY; return(INTEGER_CONSTANT); }
"AGENT_ALWAYS_RUN" { count(); yylval.ival = AGENT_ALWAYS_RUN; return(INTEGER_CONSTANT); }
"CAMERA_PITCH" { count(); yylval.ival = FOLLOWCAM_PITCH; return(INTEGER_CONSTANT); }
"CAMERA_FOCUS_OFFSET" { count(); yylval.ival = FOLLOWCAM_FOCUS_OFFSET; return (INTEGER_CONSTANT); }
"CAMERA_POSITION_LAG" { count(); yylval.ival = FOLLOWCAM_POSITION_LAG; return (INTEGER_CONSTANT); }
"CAMERA_FOCUS_LAG" { count(); yylval.ival = FOLLOWCAM_FOCUS_LAG; return (INTEGER_CONSTANT); }
"CAMERA_DISTANCE" { count(); yylval.ival = FOLLOWCAM_DISTANCE; return (INTEGER_CONSTANT); }
"CAMERA_BEHINDNESS_ANGLE" { count(); yylval.ival = FOLLOWCAM_BEHINDNESS_ANGLE; return (INTEGER_CONSTANT); }
"CAMERA_BEHINDNESS_LAG" { count(); yylval.ival = FOLLOWCAM_BEHINDNESS_LAG; return (INTEGER_CONSTANT); }
"CAMERA_POSITION_THRESHOLD" { count(); yylval.ival = FOLLOWCAM_POSITION_THRESHOLD; return (INTEGER_CONSTANT); }
"CAMERA_FOCUS_THRESHOLD" { count(); yylval.ival = FOLLOWCAM_FOCUS_THRESHOLD; return (INTEGER_CONSTANT); }
"CAMERA_ACTIVE" { count(); yylval.ival = FOLLOWCAM_ACTIVE; return (INTEGER_CONSTANT); }
"CAMERA_POSITION" { count(); yylval.ival = FOLLOWCAM_POSITION; return (INTEGER_CONSTANT); }
"CAMERA_FOCUS" { count(); yylval.ival = FOLLOWCAM_FOCUS; return (INTEGER_CONSTANT); }
"CAMERA_POSITION_LOCKED" { count(); yylval.ival = FOLLOWCAM_POSITION_LOCKED; return (INTEGER_CONSTANT); }
"CAMERA_FOCUS_LOCKED" { count(); yylval.ival = FOLLOWCAM_FOCUS_LOCKED; return (INTEGER_CONSTANT); }
"ANIM_ON" { count(); yylval.ival = 0x1; return(INTEGER_CONSTANT); }
"LOOP" { count(); yylval.ival = 0x2; return(INTEGER_CONSTANT); }
"REVERSE" { count(); yylval.ival = 0x4; return(INTEGER_CONSTANT); }
"PING_PONG" { count(); yylval.ival = 0x8; return(INTEGER_CONSTANT); }
"SMOOTH" { count(); yylval.ival = 0x10; return(INTEGER_CONSTANT); }
"ROTATE" { count(); yylval.ival = 0x20; return(INTEGER_CONSTANT); }
"SCALE" { count(); yylval.ival = 0x40; return(INTEGER_CONSTANT); }
"ALL_SIDES" { count(); yylval.ival = LSL_ALL_SIDES; return(INTEGER_CONSTANT); }
"LINK_ROOT" { count(); yylval.ival = LSL_LINK_ROOT; return(INTEGER_CONSTANT); }
"LINK_SET" { count(); yylval.ival = LSL_LINK_SET; return(INTEGER_CONSTANT); }
"LINK_ALL_OTHERS" { count(); yylval.ival = LSL_LINK_ALL_OTHERS; return(INTEGER_CONSTANT); }
"LINK_ALL_CHILDREN" { count(); yylval.ival = LSL_LINK_ALL_CHILDREN; return(INTEGER_CONSTANT); }
"LINK_THIS" { count(); yylval.ival = LSL_LINK_THIS; return(INTEGER_CONSTANT); }
"AGENT" { count(); yylval.ival = 0x1; return(INTEGER_CONSTANT); }
"ACTIVE" { count(); yylval.ival = 0x2; return(INTEGER_CONSTANT); }
"PASSIVE" { count(); yylval.ival = 0x4; return(INTEGER_CONSTANT); }
"SCRIPTED" { count(); yylval.ival = 0x8; return(INTEGER_CONSTANT); }
"CONTROL_FWD" { count(); yylval.ival = AGENT_CONTROL_AT_POS; return(INTEGER_CONSTANT); }
"CONTROL_BACK" { count(); yylval.ival = AGENT_CONTROL_AT_NEG; return(INTEGER_CONSTANT); }
"CONTROL_LEFT" { count(); yylval.ival = AGENT_CONTROL_LEFT_POS; return(INTEGER_CONSTANT); }
"CONTROL_RIGHT" { count(); yylval.ival = AGENT_CONTROL_LEFT_NEG; return(INTEGER_CONSTANT); }
"CONTROL_ROT_LEFT" { count(); yylval.ival = AGENT_CONTROL_YAW_POS; return(INTEGER_CONSTANT); }
"CONTROL_ROT_RIGHT" { count(); yylval.ival = AGENT_CONTROL_YAW_NEG; return(INTEGER_CONSTANT); }
"CONTROL_UP" { count(); yylval.ival = AGENT_CONTROL_UP_POS; return(INTEGER_CONSTANT); }
"CONTROL_DOWN" { count(); yylval.ival = AGENT_CONTROL_UP_NEG; return(INTEGER_CONSTANT); }
"CONTROL_LBUTTON" { count(); yylval.ival = AGENT_CONTROL_LBUTTON_DOWN; return(INTEGER_CONSTANT); }
"CONTROL_ML_LBUTTON" { count(); yylval.ival = AGENT_CONTROL_ML_LBUTTON_DOWN; return(INTEGER_CONSTANT); }
"PERMISSION_DEBIT" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_DEBIT]; return(INTEGER_CONSTANT); }
"PERMISSION_TAKE_CONTROLS" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_TAKE_CONTROLS]; return(INTEGER_CONSTANT); }
"PERMISSION_REMAP_CONTROLS" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_REMAP_CONTROLS]; return(INTEGER_CONSTANT); }
"PERMISSION_TRIGGER_ANIMATION" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_TRIGGER_ANIMATION]; return(INTEGER_CONSTANT); }
"PERMISSION_ATTACH" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_ATTACH]; return(INTEGER_CONSTANT); }
"PERMISSION_RELEASE_OWNERSHIP" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_RELEASE_OWNERSHIP]; return(INTEGER_CONSTANT); }
"PERMISSION_CHANGE_LINKS" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CHANGE_LINKS]; return(INTEGER_CONSTANT); }
"PERMISSION_CHANGE_JOINTS" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CHANGE_JOINTS]; return(INTEGER_CONSTANT); }
"PERMISSION_CHANGE_PERMISSIONS" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CHANGE_PERMISSIONS]; return(INTEGER_CONSTANT); }
"PERMISSION_TRACK_CAMERA" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_TRACK_CAMERA]; return(INTEGER_CONSTANT); }
"PERMISSION_CONTROL_CAMERA" { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CONTROL_CAMERA]; return(INTEGER_CONSTANT); }
"INVENTORY_TEXTURE" { count(); yylval.ival = LLAssetType::AT_TEXTURE; return(INTEGER_CONSTANT); }
"INVENTORY_SOUND" { count(); yylval.ival = LLAssetType::AT_SOUND; return(INTEGER_CONSTANT); }
"INVENTORY_OBJECT" { count(); yylval.ival = LLAssetType::AT_OBJECT; return(INTEGER_CONSTANT); }
"INVENTORY_SCRIPT" { count(); yylval.ival = LLAssetType::AT_LSL_TEXT; return(INTEGER_CONSTANT); }
"INVENTORY_LANDMARK" { count(); yylval.ival = LLAssetType::AT_LANDMARK; return(INTEGER_CONSTANT); }
"INVENTORY_CLOTHING" { count(); yylval.ival = LLAssetType::AT_CLOTHING; return(INTEGER_CONSTANT); }
"INVENTORY_NOTECARD" { count(); yylval.ival = LLAssetType::AT_NOTECARD; return(INTEGER_CONSTANT); }
"INVENTORY_BODYPART" { count(); yylval.ival = LLAssetType::AT_BODYPART; return(INTEGER_CONSTANT); }
"INVENTORY_ANIMATION" { count(); yylval.ival = LLAssetType::AT_ANIMATION; return(INTEGER_CONSTANT); }
"INVENTORY_GESTURE" { count(); yylval.ival = LLAssetType::AT_GESTURE; return(INTEGER_CONSTANT); }
"INVENTORY_ALL" { count(); yylval.ival = LLAssetType::AT_NONE; return(INTEGER_CONSTANT); }
"INVENTORY_NONE" { count(); yylval.ival = LLAssetType::AT_NONE; return(INTEGER_CONSTANT); }
"CHANGED_INVENTORY" { count(); yylval.ival = CHANGED_INVENTORY; return(INTEGER_CONSTANT); }
"CHANGED_COLOR" { count(); yylval.ival = CHANGED_COLOR; return(INTEGER_CONSTANT); }
"CHANGED_SHAPE" { count(); yylval.ival = CHANGED_SHAPE; return(INTEGER_CONSTANT); }
"CHANGED_SCALE" { count(); yylval.ival = CHANGED_SCALE; return(INTEGER_CONSTANT); }
"CHANGED_TEXTURE" { count(); yylval.ival = CHANGED_TEXTURE; return(INTEGER_CONSTANT); }
"CHANGED_LINK" { count(); yylval.ival = CHANGED_LINK; return(INTEGER_CONSTANT); }
"CHANGED_ALLOWED_DROP" { count(); yylval.ival = CHANGED_ALLOWED_DROP; return(INTEGER_CONSTANT); }
"CHANGED_OWNER" { count(); yylval.ival = CHANGED_OWNER; return(INTEGER_CONSTANT); }
"CHANGED_REGION" { count(); yylval.ival = CHANGED_REGION; return(INTEGER_CONSTANT); }
"CHANGED_TELEPORT" { count(); yylval.ival = CHANGED_TELEPORT; return(INTEGER_CONSTANT); }
"CHANGED_REGION_START" { count(); yylval.ival = CHANGED_REGION_START; return(INTEGER_CONSTANT); }
"OBJECT_UNKNOWN_DETAIL" { count(); yylval.ival = OBJECT_UNKNOWN_DETAIL; return(INTEGER_CONSTANT); }
"OBJECT_NAME" { count(); yylval.ival = OBJECT_NAME; return(INTEGER_CONSTANT); }
"OBJECT_DESC" { count(); yylval.ival = OBJECT_DESC; return(INTEGER_CONSTANT); }
"OBJECT_POS" { count(); yylval.ival = OBJECT_POS; return(INTEGER_CONSTANT); }
"OBJECT_ROT" { count(); yylval.ival = OBJECT_ROT; return(INTEGER_CONSTANT); }
"OBJECT_VELOCITY" { count(); yylval.ival = OBJECT_VELOCITY; return(INTEGER_CONSTANT); }
"OBJECT_OWNER" { count(); yylval.ival = OBJECT_OWNER; return(INTEGER_CONSTANT); }
"OBJECT_GROUP" { count(); yylval.ival = OBJECT_GROUP; return(INTEGER_CONSTANT); }
"OBJECT_CREATOR" { count(); yylval.ival = OBJECT_CREATOR; return(INTEGER_CONSTANT); }
"TYPE_INTEGER" { count(); yylval.ival = LST_INTEGER; return(INTEGER_CONSTANT); }
"TYPE_FLOAT" { count(); yylval.ival = LST_FLOATINGPOINT; return(INTEGER_CONSTANT); }
"TYPE_STRING" { count(); yylval.ival = LST_STRING; return(INTEGER_CONSTANT); }
"TYPE_KEY" { count(); yylval.ival = LST_KEY; return(INTEGER_CONSTANT); }
"TYPE_VECTOR" { count(); yylval.ival = LST_VECTOR; return(INTEGER_CONSTANT); }
"TYPE_ROTATION" { count(); yylval.ival = LST_QUATERNION; return(INTEGER_CONSTANT); }
"TYPE_INVALID" { count(); yylval.ival = LST_NULL; return(INTEGER_CONSTANT); }
"NULL_KEY" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "00000000-0000-0000-0000-000000000000"); return(STRING_CONSTANT); }
"EOF" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "\n\n\n"); return(STRING_CONSTANT); }
"URL_REQUEST_GRANTED" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, URL_REQUEST_GRANTED); return(STRING_CONSTANT); }
"URL_REQUEST_DENIED" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, URL_REQUEST_DENIED); return(STRING_CONSTANT); }
"PI" { count(); yylval.fval = F_PI; return(FP_CONSTANT); }
"TWO_PI" { count(); yylval.fval = F_TWO_PI; return(FP_CONSTANT); }
"PI_BY_TWO" { count(); yylval.fval = F_PI_BY_TWO; return(FP_CONSTANT); }
"DEG_TO_RAD" { count(); yylval.fval = DEG_TO_RAD; return(FP_CONSTANT); }
"RAD_TO_DEG" { count(); yylval.fval = RAD_TO_DEG; return(FP_CONSTANT); }
"SQRT2" { count(); yylval.fval = F_SQRT2; return(FP_CONSTANT); }
"DEBUG_CHANNEL" { count(); yylval.ival = CHAT_CHANNEL_DEBUG; return(INTEGER_CONSTANT); }
"PUBLIC_CHANNEL" { count(); yylval.ival = 0; return(INTEGER_CONSTANT); }
"ZERO_VECTOR" { count(); return(ZERO_VECTOR); }
"ZERO_ROTATION" { count(); return(ZERO_ROTATION); }
"ATTACH_CHEST" { count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
"ATTACH_HEAD" { count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
"ATTACH_LSHOULDER" { count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
"ATTACH_RSHOULDER" { count(); yylval.ival = 4; return(INTEGER_CONSTANT); }
"ATTACH_LHAND" { count(); yylval.ival = 5; return(INTEGER_CONSTANT); }
"ATTACH_RHAND" { count(); yylval.ival = 6; return(INTEGER_CONSTANT); }
"ATTACH_LFOOT" { count(); yylval.ival = 7; return(INTEGER_CONSTANT); }
"ATTACH_RFOOT" { count(); yylval.ival = 8; return(INTEGER_CONSTANT); }
"ATTACH_BACK" { count(); yylval.ival = 9; return(INTEGER_CONSTANT); }
"ATTACH_PELVIS" { count(); yylval.ival = 10; return(INTEGER_CONSTANT); }
"ATTACH_MOUTH" { count(); yylval.ival = 11; return(INTEGER_CONSTANT); }
"ATTACH_CHIN" { count(); yylval.ival = 12; return(INTEGER_CONSTANT); }
"ATTACH_LEAR" { count(); yylval.ival = 13; return(INTEGER_CONSTANT); }
"ATTACH_REAR" { count(); yylval.ival = 14; return(INTEGER_CONSTANT); }
"ATTACH_LEYE" { count(); yylval.ival = 15; return(INTEGER_CONSTANT); }
"ATTACH_REYE" { count(); yylval.ival = 16; return(INTEGER_CONSTANT); }
"ATTACH_NOSE" { count(); yylval.ival = 17; return(INTEGER_CONSTANT); }
"ATTACH_RUARM" { count(); yylval.ival = 18; return(INTEGER_CONSTANT); }
"ATTACH_RLARM" { count(); yylval.ival = 19; return(INTEGER_CONSTANT); }
"ATTACH_LUARM" { count(); yylval.ival = 20; return(INTEGER_CONSTANT); }
"ATTACH_LLARM" { count(); yylval.ival = 21; return(INTEGER_CONSTANT); }
"ATTACH_RHIP" { count(); yylval.ival = 22; return(INTEGER_CONSTANT); }
"ATTACH_RULEG" { count(); yylval.ival = 23; return(INTEGER_CONSTANT); }
"ATTACH_RLLEG" { count(); yylval.ival = 24; return(INTEGER_CONSTANT); }
"ATTACH_LHIP" { count(); yylval.ival = 25; return(INTEGER_CONSTANT); }
"ATTACH_LULEG" { count(); yylval.ival = 26; return(INTEGER_CONSTANT); }
"ATTACH_LLLEG" { count(); yylval.ival = 27; return(INTEGER_CONSTANT); }
"ATTACH_BELLY" { count(); yylval.ival = 28; return(INTEGER_CONSTANT); }
"ATTACH_RPEC" { count(); yylval.ival = 29; return(INTEGER_CONSTANT); }
"ATTACH_LPEC" { count(); yylval.ival = 30; return(INTEGER_CONSTANT); }
"ATTACH_HUD_CENTER_2" { count(); yylval.ival = 31; return(INTEGER_CONSTANT); }
"ATTACH_HUD_TOP_RIGHT" { count(); yylval.ival = 32; return(INTEGER_CONSTANT); }
"ATTACH_HUD_TOP_CENTER" { count(); yylval.ival = 33; return(INTEGER_CONSTANT); }
"ATTACH_HUD_TOP_LEFT" { count(); yylval.ival = 34; return(INTEGER_CONSTANT); }
"ATTACH_HUD_CENTER_1" { count(); yylval.ival = 35; return(INTEGER_CONSTANT); }
"ATTACH_HUD_BOTTOM_LEFT" { count(); yylval.ival = 36; return(INTEGER_CONSTANT); }
"ATTACH_HUD_BOTTOM" { count(); yylval.ival = 37; return(INTEGER_CONSTANT); }
"ATTACH_HUD_BOTTOM_RIGHT" { count(); yylval.ival = 38; return(INTEGER_CONSTANT); }
"LAND_LEVEL" { count(); yylval.ival = E_LANDBRUSH_LEVEL; return(INTEGER_CONSTANT); }
"LAND_RAISE" { count(); yylval.ival = E_LANDBRUSH_RAISE; return(INTEGER_CONSTANT); }
"LAND_LOWER" { count(); yylval.ival = E_LANDBRUSH_LOWER; return(INTEGER_CONSTANT); }
"LAND_SMOOTH" { count(); yylval.ival = E_LANDBRUSH_SMOOTH; return(INTEGER_CONSTANT); }
"LAND_NOISE" { count(); yylval.ival = E_LANDBRUSH_NOISE; return(INTEGER_CONSTANT); }
"LAND_REVERT" { count(); yylval.ival = E_LANDBRUSH_REVERT; return(INTEGER_CONSTANT); }
"LAND_SMALL_BRUSH" { count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
"LAND_MEDIUM_BRUSH" { count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
"LAND_LARGE_BRUSH" { count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
"DATA_ONLINE" { count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
"DATA_NAME" { count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
"DATA_BORN" { count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
"DATA_RATING" { count(); yylval.ival = 4; return(INTEGER_CONSTANT); }
"DATA_SIM_POS" { count(); yylval.ival = 5; return(INTEGER_CONSTANT); }
"DATA_SIM_STATUS" { count(); yylval.ival = 6; return(INTEGER_CONSTANT); }
"DATA_SIM_RATING" { count(); yylval.ival = 7; return(INTEGER_CONSTANT); }
"DATA_PAYINFO" { count(); yylval.ival = 8; return(INTEGER_CONSTANT); }
"PAYMENT_INFO_ON_FILE" { count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
"PAYMENT_INFO_USED" { count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
"REMOTE_DATA_CHANNEL" { count(); yylval.ival = LSL_REMOTE_DATA_CHANNEL; return(INTEGER_CONSTANT); }
"REMOTE_DATA_REQUEST" { count(); yylval.ival = LSL_REMOTE_DATA_REQUEST; return(INTEGER_CONSTANT); }
"REMOTE_DATA_REPLY" { count(); yylval.ival = LSL_REMOTE_DATA_REPLY; return(INTEGER_CONSTANT); }
"PSYS_PART_FLAGS" { count(); yylval.ival = LLPS_PART_FLAGS; return(INTEGER_CONSTANT); }
"PSYS_PART_START_COLOR" { count(); yylval.ival = LLPS_PART_START_COLOR; return (INTEGER_CONSTANT); }
"PSYS_PART_START_ALPHA" { count(); yylval.ival = LLPS_PART_START_ALPHA; return (INTEGER_CONSTANT); }
"PSYS_PART_START_SCALE" { count(); yylval.ival = LLPS_PART_START_SCALE; return (INTEGER_CONSTANT); }
"PSYS_PART_END_COLOR" { count(); yylval.ival = LLPS_PART_END_COLOR; return (INTEGER_CONSTANT); }
"PSYS_PART_END_ALPHA" { count(); yylval.ival = LLPS_PART_END_ALPHA; return (INTEGER_CONSTANT); }
"PSYS_PART_END_SCALE" { count(); yylval.ival = LLPS_PART_END_SCALE; return (INTEGER_CONSTANT); }
"PSYS_PART_MAX_AGE" { count(); yylval.ival = LLPS_PART_MAX_AGE; return (INTEGER_CONSTANT); }
"PSYS_PART_WIND_MASK" { count(); yylval.ival = LLPartData::LL_PART_WIND_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_INTERP_COLOR_MASK" { count(); yylval.ival = LLPartData::LL_PART_INTERP_COLOR_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_INTERP_SCALE_MASK" { count(); yylval.ival = LLPartData::LL_PART_INTERP_SCALE_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_BOUNCE_MASK" { count(); yylval.ival = LLPartData::LL_PART_BOUNCE_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_FOLLOW_SRC_MASK" { count(); yylval.ival = LLPartData::LL_PART_FOLLOW_SRC_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_FOLLOW_VELOCITY_MASK" { count(); yylval.ival = LLPartData::LL_PART_FOLLOW_VELOCITY_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_TARGET_POS_MASK" { count(); yylval.ival = LLPartData::LL_PART_TARGET_POS_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_EMISSIVE_MASK" { count(); yylval.ival = LLPartData::LL_PART_EMISSIVE_MASK; return(INTEGER_CONSTANT); }
"PSYS_PART_TARGET_LINEAR_MASK" { count(); yylval.ival = LLPartData::LL_PART_TARGET_LINEAR_MASK; return(INTEGER_CONSTANT); }
"PSYS_SRC_MAX_AGE" { count(); yylval.ival = LLPS_SRC_MAX_AGE; return(INTEGER_CONSTANT); }
"PSYS_SRC_PATTERN" { count(); yylval.ival = LLPS_SRC_PATTERN; return(INTEGER_CONSTANT); }
"PSYS_SRC_INNERANGLE" { count(); yylval.ival = LLPS_SRC_INNERANGLE; return(INTEGER_CONSTANT); }
"PSYS_SRC_OUTERANGLE" { count(); yylval.ival = LLPS_SRC_OUTERANGLE; return(INTEGER_CONSTANT); }
"PSYS_SRC_ANGLE_BEGIN" { count(); yylval.ival = LLPS_SRC_ANGLE_BEGIN; return(INTEGER_CONSTANT); }
"PSYS_SRC_ANGLE_END" { count(); yylval.ival = LLPS_SRC_ANGLE_END; return(INTEGER_CONSTANT); }
"PSYS_SRC_BURST_RATE" { count(); yylval.ival = LLPS_SRC_BURST_RATE; return(INTEGER_CONSTANT); }
"PSYS_SRC_BURST_PART_COUNT" { count(); yylval.ival = LLPS_SRC_BURST_PART_COUNT; return(INTEGER_CONSTANT); }
"PSYS_SRC_BURST_RADIUS" { count(); yylval.ival = LLPS_SRC_BURST_RADIUS; return(INTEGER_CONSTANT); }
"PSYS_SRC_BURST_SPEED_MIN" { count(); yylval.ival = LLPS_SRC_BURST_SPEED_MIN; return(INTEGER_CONSTANT); }
"PSYS_SRC_BURST_SPEED_MAX" { count(); yylval.ival = LLPS_SRC_BURST_SPEED_MAX; return(INTEGER_CONSTANT); }
"PSYS_SRC_ACCEL" { count(); yylval.ival = LLPS_SRC_ACCEL; return(INTEGER_CONSTANT); }
"PSYS_SRC_TEXTURE" { count(); yylval.ival = LLPS_SRC_TEXTURE; return(INTEGER_CONSTANT); }
"PSYS_SRC_TARGET_KEY" { count(); yylval.ival = LLPS_SRC_TARGET_UUID; return(INTEGER_CONSTANT); }
"PSYS_SRC_OMEGA" { count(); yylval.ival = LLPS_SRC_OMEGA; return(INTEGER_CONSTANT); }
"PSYS_SRC_OBJ_REL_MASK" { count(); yylval.ival = LLPartSysData::LL_PART_SRC_OBJ_REL_MASK; return(INTEGER_CONSTANT); }
"PSYS_SRC_PATTERN_DROP" { count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_DROP; return(INTEGER_CONSTANT); }
"PSYS_SRC_PATTERN_EXPLODE" { count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_EXPLODE; return(INTEGER_CONSTANT); }
"PSYS_SRC_PATTERN_ANGLE" { count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE; return(INTEGER_CONSTANT); }
"PSYS_SRC_PATTERN_ANGLE_CONE" { count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE; return(INTEGER_CONSTANT); }
"PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY" { count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY; return(INTEGER_CONSTANT); }
"VEHICLE_TYPE_NONE" { count(); yylval.ival = VEHICLE_TYPE_NONE; return(INTEGER_CONSTANT); }
"VEHICLE_TYPE_SLED" { count(); yylval.ival = VEHICLE_TYPE_SLED; return(INTEGER_CONSTANT); }
"VEHICLE_TYPE_CAR" { count(); yylval.ival = VEHICLE_TYPE_CAR; return(INTEGER_CONSTANT); }
"VEHICLE_TYPE_BOAT" { count(); yylval.ival = VEHICLE_TYPE_BOAT; return(INTEGER_CONSTANT); }
"VEHICLE_TYPE_AIRPLANE" { count(); yylval.ival = VEHICLE_TYPE_AIRPLANE; return(INTEGER_CONSTANT); }
"VEHICLE_TYPE_BALLOON" { count(); yylval.ival = VEHICLE_TYPE_BALLOON; return(INTEGER_CONSTANT); }
"VEHICLE_REFERENCE_FRAME" { count(); yylval.ival = VEHICLE_REFERENCE_FRAME; return(INTEGER_CONSTANT); }
"VEHICLE_LINEAR_FRICTION_TIMESCALE" { count(); yylval.ival = VEHICLE_LINEAR_FRICTION_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_ANGULAR_FRICTION_TIMESCALE" { count(); yylval.ival = VEHICLE_ANGULAR_FRICTION_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_LINEAR_MOTOR_DIRECTION" { count(); yylval.ival = VEHICLE_LINEAR_MOTOR_DIRECTION; return(INTEGER_CONSTANT); }
"VEHICLE_ANGULAR_MOTOR_DIRECTION" { count(); yylval.ival = VEHICLE_ANGULAR_MOTOR_DIRECTION; return(INTEGER_CONSTANT); }
"VEHICLE_LINEAR_MOTOR_OFFSET" { count(); yylval.ival = VEHICLE_LINEAR_MOTOR_OFFSET; return(INTEGER_CONSTANT); }
"VEHICLE_HOVER_HEIGHT" { count(); yylval.ival = VEHICLE_HOVER_HEIGHT; return(INTEGER_CONSTANT); }
"VEHICLE_HOVER_EFFICIENCY" { count(); yylval.ival = VEHICLE_HOVER_EFFICIENCY; return(INTEGER_CONSTANT); }
"VEHICLE_HOVER_TIMESCALE" { count(); yylval.ival = VEHICLE_HOVER_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_BUOYANCY" { count(); yylval.ival = VEHICLE_BUOYANCY; return(INTEGER_CONSTANT); }
"VEHICLE_LINEAR_DEFLECTION_EFFICIENCY" { count(); yylval.ival = VEHICLE_LINEAR_DEFLECTION_EFFICIENCY; return(INTEGER_CONSTANT); }
"VEHICLE_LINEAR_DEFLECTION_TIMESCALE" { count(); yylval.ival = VEHICLE_LINEAR_DEFLECTION_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_LINEAR_MOTOR_TIMESCALE" { count(); yylval.ival = VEHICLE_LINEAR_MOTOR_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE" { count(); yylval.ival = VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY" { count(); yylval.ival = VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY; return(INTEGER_CONSTANT); }
"VEHICLE_ANGULAR_DEFLECTION_TIMESCALE" { count(); yylval.ival = VEHICLE_ANGULAR_DEFLECTION_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_ANGULAR_MOTOR_TIMESCALE" { count(); yylval.ival = VEHICLE_ANGULAR_MOTOR_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE" { count(); yylval.ival = VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY" { count(); yylval.ival = VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY; return(INTEGER_CONSTANT); }
"VEHICLE_VERTICAL_ATTRACTION_TIMESCALE" { count(); yylval.ival = VEHICLE_VERTICAL_ATTRACTION_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_BANKING_EFFICIENCY" { count(); yylval.ival = VEHICLE_BANKING_EFFICIENCY; return(INTEGER_CONSTANT); }
"VEHICLE_BANKING_MIX" { count(); yylval.ival = VEHICLE_BANKING_MIX; return(INTEGER_CONSTANT); }
"VEHICLE_BANKING_TIMESCALE" { count(); yylval.ival = VEHICLE_BANKING_TIMESCALE; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_NO_FLY_UP" { count(); yylval.ival = VEHICLE_FLAG_NO_DEFLECTION_UP; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_NO_DEFLECTION_UP" { count(); yylval.ival = VEHICLE_FLAG_NO_DEFLECTION_UP; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_LIMIT_ROLL_ONLY" { count(); yylval.ival = VEHICLE_FLAG_LIMIT_ROLL_ONLY; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_HOVER_WATER_ONLY" { count(); yylval.ival = VEHICLE_FLAG_HOVER_WATER_ONLY; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_HOVER_TERRAIN_ONLY" { count(); yylval.ival = VEHICLE_FLAG_HOVER_TERRAIN_ONLY; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT" { count(); yylval.ival = VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_HOVER_UP_ONLY" { count(); yylval.ival = VEHICLE_FLAG_HOVER_UP_ONLY; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_LIMIT_MOTOR_UP" { count(); yylval.ival = VEHICLE_FLAG_LIMIT_MOTOR_UP; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_MOUSELOOK_STEER" { count(); yylval.ival = VEHICLE_FLAG_MOUSELOOK_STEER; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_MOUSELOOK_BANK" { count(); yylval.ival = VEHICLE_FLAG_MOUSELOOK_BANK; return(INTEGER_CONSTANT); }
"VEHICLE_FLAG_CAMERA_DECOUPLED" { count(); yylval.ival = VEHICLE_FLAG_CAMERA_DECOUPLED; return(INTEGER_CONSTANT); }
"PRIM_TYPE" { count(); yylval.ival = LSL_PRIM_TYPE; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL" { count(); yylval.ival = LSL_PRIM_MATERIAL; return(INTEGER_CONSTANT); }
"PRIM_PHYSICS" { count(); yylval.ival = LSL_PRIM_PHYSICS; return(INTEGER_CONSTANT); }
"PRIM_FLEXIBLE" { count(); yylval.ival = LSL_PRIM_FLEXIBLE; return(INTEGER_CONSTANT); }
"PRIM_POINT_LIGHT" { count(); yylval.ival = LSL_PRIM_POINT_LIGHT; return(INTEGER_CONSTANT); }
"PRIM_TEMP_ON_REZ" { count(); yylval.ival = LSL_PRIM_TEMP_ON_REZ; return(INTEGER_CONSTANT); }
"PRIM_PHANTOM" { count(); yylval.ival = LSL_PRIM_PHANTOM; return(INTEGER_CONSTANT); }
"PRIM_CAST_SHADOWS" { count(); yylval.ival = LSL_PRIM_CAST_SHADOWS; return(INTEGER_CONSTANT); }
"PRIM_POSITION" { count(); yylval.ival = LSL_PRIM_POSITION; return(INTEGER_CONSTANT); }
"PRIM_SIZE" { count(); yylval.ival = LSL_PRIM_SIZE; return(INTEGER_CONSTANT); }
"PRIM_ROTATION" { count(); yylval.ival = LSL_PRIM_ROTATION; return(INTEGER_CONSTANT); }
"PRIM_TEXTURE" { count(); yylval.ival = LSL_PRIM_TEXTURE; return(INTEGER_CONSTANT); }
"PRIM_COLOR" { count(); yylval.ival = LSL_PRIM_COLOR; return(INTEGER_CONSTANT); }
"PRIM_BUMP_SHINY" { count(); yylval.ival = LSL_PRIM_BUMP_SHINY; return(INTEGER_CONSTANT); }
"PRIM_FULLBRIGHT" { count(); yylval.ival = LSL_PRIM_FULLBRIGHT; return(INTEGER_CONSTANT); }
"PRIM_TEXGEN" { count(); yylval.ival = LSL_PRIM_TEXGEN; return(INTEGER_CONSTANT); }
"PRIM_GLOW" { count(); yylval.ival = LSL_PRIM_GLOW; return(INTEGER_CONSTANT); }
"PRIM_TYPE_BOX" { count(); yylval.ival = LSL_PRIM_TYPE_BOX; return(INTEGER_CONSTANT); }
"PRIM_TYPE_CYLINDER" { count(); yylval.ival = LSL_PRIM_TYPE_CYLINDER; return(INTEGER_CONSTANT); }
"PRIM_TYPE_PRISM" { count(); yylval.ival = LSL_PRIM_TYPE_PRISM; return(INTEGER_CONSTANT); }
"PRIM_TYPE_SPHERE" { count(); yylval.ival = LSL_PRIM_TYPE_SPHERE; return(INTEGER_CONSTANT); }
"PRIM_TYPE_TORUS" { count(); yylval.ival = LSL_PRIM_TYPE_TORUS; return(INTEGER_CONSTANT); }
"PRIM_TYPE_TUBE" { count(); yylval.ival = LSL_PRIM_TYPE_TUBE; return(INTEGER_CONSTANT); }
"PRIM_TYPE_RING" { count(); yylval.ival = LSL_PRIM_TYPE_RING; return(INTEGER_CONSTANT); }
"PRIM_TYPE_SCULPT" { count(); yylval.ival = LSL_PRIM_TYPE_SCULPT; return(INTEGER_CONSTANT); }
"PRIM_HOLE_DEFAULT" { count(); yylval.ival = LSL_PRIM_HOLE_DEFAULT; return(INTEGER_CONSTANT); }
"PRIM_HOLE_CIRCLE" { count(); yylval.ival = LSL_PRIM_HOLE_CIRCLE; return(INTEGER_CONSTANT); }
"PRIM_HOLE_SQUARE" { count(); yylval.ival = LSL_PRIM_HOLE_SQUARE; return(INTEGER_CONSTANT); }
"PRIM_HOLE_TRIANGLE" { count(); yylval.ival = LSL_PRIM_HOLE_TRIANGLE; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_STONE" { count(); yylval.ival = LSL_PRIM_MATERIAL_STONE; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_METAL" { count(); yylval.ival = LSL_PRIM_MATERIAL_METAL; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_GLASS" { count(); yylval.ival = LSL_PRIM_MATERIAL_GLASS; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_WOOD" { count(); yylval.ival = LSL_PRIM_MATERIAL_WOOD; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_FLESH" { count(); yylval.ival = LSL_PRIM_MATERIAL_FLESH; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_PLASTIC" { count(); yylval.ival = LSL_PRIM_MATERIAL_PLASTIC; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_RUBBER" { count(); yylval.ival = LSL_PRIM_MATERIAL_RUBBER; return(INTEGER_CONSTANT); }
"PRIM_MATERIAL_LIGHT" { count(); yylval.ival = LSL_PRIM_MATERIAL_LIGHT; return(INTEGER_CONSTANT); }
"PRIM_SHINY_NONE" { count(); yylval.ival = LSL_PRIM_SHINY_NONE; return(INTEGER_CONSTANT); }
"PRIM_SHINY_LOW" { count(); yylval.ival = LSL_PRIM_SHINY_LOW; return(INTEGER_CONSTANT); }
"PRIM_SHINY_MEDIUM" { count(); yylval.ival = LSL_PRIM_SHINY_MEDIUM; return(INTEGER_CONSTANT); }
"PRIM_SHINY_HIGH" { count(); yylval.ival = LSL_PRIM_SHINY_HIGH; return(INTEGER_CONSTANT); }
"PRIM_BUMP_NONE" { count(); yylval.ival = LSL_PRIM_BUMP_NONE; return(INTEGER_CONSTANT); }
"PRIM_BUMP_BRIGHT" { count(); yylval.ival = LSL_PRIM_BUMP_BRIGHT; return(INTEGER_CONSTANT); }
"PRIM_BUMP_DARK" { count(); yylval.ival = LSL_PRIM_BUMP_DARK; return(INTEGER_CONSTANT); }
"PRIM_BUMP_WOOD" { count(); yylval.ival = LSL_PRIM_BUMP_WOOD; return(INTEGER_CONSTANT); }
"PRIM_BUMP_BARK" { count(); yylval.ival = LSL_PRIM_BUMP_BARK; return(INTEGER_CONSTANT); }
"PRIM_BUMP_BRICKS" { count(); yylval.ival = LSL_PRIM_BUMP_BRICKS; return(INTEGER_CONSTANT); }
"PRIM_BUMP_CHECKER" { count(); yylval.ival = LSL_PRIM_BUMP_CHECKER; return(INTEGER_CONSTANT); }
"PRIM_BUMP_CONCRETE" { count(); yylval.ival = LSL_PRIM_BUMP_CONCRETE; return(INTEGER_CONSTANT); }
"PRIM_BUMP_TILE" { count(); yylval.ival = LSL_PRIM_BUMP_TILE; return(INTEGER_CONSTANT); }
"PRIM_BUMP_STONE" { count(); yylval.ival = LSL_PRIM_BUMP_STONE; return(INTEGER_CONSTANT); }
"PRIM_BUMP_DISKS" { count(); yylval.ival = LSL_PRIM_BUMP_DISKS; return(INTEGER_CONSTANT); }
"PRIM_BUMP_GRAVEL" { count(); yylval.ival = LSL_PRIM_BUMP_GRAVEL; return(INTEGER_CONSTANT); }
"PRIM_BUMP_BLOBS" { count(); yylval.ival = LSL_PRIM_BUMP_BLOBS; return(INTEGER_CONSTANT); }
"PRIM_BUMP_SIDING" { count(); yylval.ival = LSL_PRIM_BUMP_SIDING; return(INTEGER_CONSTANT); }
"PRIM_BUMP_LARGETILE" { count(); yylval.ival = LSL_PRIM_BUMP_LARGETILE; return(INTEGER_CONSTANT); }
"PRIM_BUMP_STUCCO" { count(); yylval.ival = LSL_PRIM_BUMP_STUCCO; return(INTEGER_CONSTANT); }
"PRIM_BUMP_SUCTION" { count(); yylval.ival = LSL_PRIM_BUMP_SUCTION; return(INTEGER_CONSTANT); }
"PRIM_BUMP_WEAVE" { count(); yylval.ival = LSL_PRIM_BUMP_WEAVE; return(INTEGER_CONSTANT); }
"PRIM_TEXGEN_DEFAULT" { count(); yylval.ival = LSL_PRIM_TEXGEN_DEFAULT; return(INTEGER_CONSTANT); }
"PRIM_TEXGEN_PLANAR" { count(); yylval.ival = LSL_PRIM_TEXGEN_PLANAR; return(INTEGER_CONSTANT); }
"PRIM_SCULPT_TYPE_SPHERE" { count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_SPHERE; return(INTEGER_CONSTANT); }
"PRIM_SCULPT_TYPE_TORUS" { count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_TORUS; return(INTEGER_CONSTANT); }
"PRIM_SCULPT_TYPE_PLANE" { count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_PLANE; return(INTEGER_CONSTANT); }
"PRIM_SCULPT_TYPE_CYLINDER" { count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_CYLINDER; return(INTEGER_CONSTANT); }
"PRIM_SCULPT_TYPE_MASK" { count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_MASK; return(INTEGER_CONSTANT); }
"PRIM_SCULPT_FLAG_MIRROR" { count(); yylval.ival = LSL_PRIM_SCULPT_FLAG_MIRROR; return(INTEGER_CONSTANT); }
"PRIM_SCULPT_FLAG_INVERT" { count(); yylval.ival = LSL_PRIM_SCULPT_FLAG_INVERT; return(INTEGER_CONSTANT); }
"MASK_BASE" { count(); yylval.ival = 0; return(INTEGER_CONSTANT); }
"MASK_OWNER" { count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
"MASK_GROUP" { count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
"MASK_EVERYONE" { count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
"MASK_NEXT" { count(); yylval.ival = 4; return(INTEGER_CONSTANT); }
"PERM_TRANSFER" { count(); yylval.ival = PERM_TRANSFER; return(INTEGER_CONSTANT); }
"PERM_MODIFY" { count(); yylval.ival = PERM_MODIFY; return(INTEGER_CONSTANT); }
"PERM_COPY" { count(); yylval.ival = PERM_COPY; return(INTEGER_CONSTANT); }
"PERM_MOVE" { count(); yylval.ival = PERM_MOVE; return(INTEGER_CONSTANT); }
"PERM_ALL" { count(); yylval.ival = PERM_ALL; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_STOP" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_STOP; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_PAUSE" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_PAUSE; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_PLAY" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_PLAY; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_LOOP" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_LOOP; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_TEXTURE" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_TEXTURE; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_URL" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_URL; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_TIME" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_TIME; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_AGENT" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_AGENT; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_UNLOAD" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_UNLOAD; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_AUTO_ALIGN" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_AUTO_ALIGN; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_TYPE" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_TYPE; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_SIZE" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_SIZE; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_DESC" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_DESC; return(INTEGER_CONSTANT); }
"PARCEL_MEDIA_COMMAND_LOOP_SET" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_LOOP_SET; return(INTEGER_CONSTANT); }
"LIST_STAT_MAX" { count(); yylval.ival = LIST_STAT_MAX; return(INTEGER_CONSTANT); }
"LIST_STAT_MIN" { count(); yylval.ival = LIST_STAT_MIN; return(INTEGER_CONSTANT); }
"LIST_STAT_MEAN" { count(); yylval.ival = LIST_STAT_MEAN; return(INTEGER_CONSTANT); }
"LIST_STAT_MEDIAN" { count(); yylval.ival = LIST_STAT_MEDIAN; return(INTEGER_CONSTANT); }
"LIST_STAT_STD_DEV" { count(); yylval.ival = LIST_STAT_STD_DEV; return(INTEGER_CONSTANT); }
"LIST_STAT_SUM" { count(); yylval.ival = LIST_STAT_SUM; return(INTEGER_CONSTANT); }
"LIST_STAT_SUM_SQUARES" { count(); yylval.ival = LIST_STAT_SUM_SQUARES; return(INTEGER_CONSTANT); }
"LIST_STAT_NUM_COUNT" { count(); yylval.ival = LIST_STAT_NUM_COUNT; return(INTEGER_CONSTANT); }
"LIST_STAT_GEOMETRIC_MEAN" { count(); yylval.ival = LIST_STAT_GEO_MEAN; return(INTEGER_CONSTANT); }
"LIST_STAT_RANGE" { count(); yylval.ival = LIST_STAT_RANGE; return(INTEGER_CONSTANT); }
"PAY_HIDE" { count(); yylval.ival = PAY_PRICE_HIDE; return(INTEGER_CONSTANT); }
"PAY_DEFAULT" { count(); yylval.ival = PAY_PRICE_DEFAULT; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_FLY" { count(); yylval.ival = PF_ALLOW_FLY; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_GROUP_SCRIPTS" { count(); yylval.ival = PF_ALLOW_GROUP_SCRIPTS; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_SCRIPTS" { count(); yylval.ival = PF_ALLOW_OTHER_SCRIPTS; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_LANDMARK" { count(); yylval.ival = PF_ALLOW_LANDMARK; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_TERRAFORM" { count(); yylval.ival = PF_ALLOW_TERRAFORM; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_DAMAGE" { count(); yylval.ival = PF_ALLOW_DAMAGE; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_CREATE_OBJECTS" { count(); yylval.ival = PF_CREATE_OBJECTS; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_CREATE_GROUP_OBJECTS" { count(); yylval.ival = PF_CREATE_GROUP_OBJECTS; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_USE_ACCESS_GROUP" { count(); yylval.ival = PF_USE_ACCESS_GROUP; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_USE_ACCESS_LIST" { count(); yylval.ival = PF_USE_ACCESS_LIST; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_USE_BAN_LIST" { count(); yylval.ival = PF_USE_BAN_LIST; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_USE_LAND_PASS_LIST" { count(); yylval.ival = PF_USE_PASS_LIST; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_LOCAL_SOUND_ONLY" { count(); yylval.ival = PF_SOUND_LOCAL; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_RESTRICT_PUSHOBJECT" { count(); yylval.ival = PF_RESTRICT_PUSHOBJECT; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_GROUP_OBJECT_ENTRY" { count(); yylval.ival = PF_ALLOW_GROUP_OBJECT_ENTRY; return(INTEGER_CONSTANT); }
"PARCEL_FLAG_ALLOW_ALL_OBJECT_ENTRY" { count(); yylval.ival = PF_ALLOW_ALL_OBJECT_ENTRY; return(INTEGER_CONSTANT); }
"REGION_FLAG_ALLOW_DAMAGE" { count(); yylval.ival = REGION_FLAGS_ALLOW_DAMAGE; return(INTEGER_CONSTANT); }
"REGION_FLAG_FIXED_SUN" { count(); yylval.ival = REGION_FLAGS_SUN_FIXED; return(INTEGER_CONSTANT); }
"REGION_FLAG_BLOCK_TERRAFORM" { count(); yylval.ival = REGION_FLAGS_BLOCK_TERRAFORM; return(INTEGER_CONSTANT); }
"REGION_FLAG_SANDBOX" { count(); yylval.ival = REGION_FLAGS_SANDBOX; return(INTEGER_CONSTANT); }
"REGION_FLAG_DISABLE_COLLISIONS" { count(); yylval.ival = REGION_FLAGS_SKIP_COLLISIONS; return(INTEGER_CONSTANT); }
"REGION_FLAG_DISABLE_PHYSICS" { count(); yylval.ival = REGION_FLAGS_SKIP_PHYSICS; return(INTEGER_CONSTANT); }
"REGION_FLAG_BLOCK_FLY" { count(); yylval.ival = REGION_FLAGS_BLOCK_FLY; return(INTEGER_CONSTANT); }
"REGION_FLAG_ALLOW_DIRECT_TELEPORT" { count(); yylval.ival = REGION_FLAGS_ALLOW_DIRECT_TELEPORT; return(INTEGER_CONSTANT); }
"REGION_FLAG_RESTRICT_PUSHOBJECT" { count(); yylval.ival = REGION_FLAGS_RESTRICT_PUSHOBJECT; return(INTEGER_CONSTANT); }
"HTTP_METHOD" { count(); yylval.ival = HTTP_METHOD; return(INTEGER_CONSTANT); }
"HTTP_MIMETYPE" { count(); yylval.ival = HTTP_MIMETYPE; return(INTEGER_CONSTANT); }
"HTTP_BODY_MAXLENGTH" { count(); yylval.ival = HTTP_BODY_MAXLENGTH; return(INTEGER_CONSTANT); }
"HTTP_BODY_TRUNCATED" { count(); yylval.ival = HTTP_BODY_TRUNCATED; return(INTEGER_CONSTANT); }
"HTTP_VERIFY_CERT" { count(); yylval.ival = HTTP_VERIFY_CERT; return(INTEGER_CONSTANT); }
"PARCEL_COUNT_TOTAL" { count(); yylval.ival = OC_TOTAL; return(INTEGER_CONSTANT); }
"PARCEL_COUNT_OWNER" { count(); yylval.ival = OC_OWNER; return(INTEGER_CONSTANT); }
"PARCEL_COUNT_GROUP" { count(); yylval.ival = OC_GROUP; return(INTEGER_CONSTANT); }
"PARCEL_COUNT_OTHER" { count(); yylval.ival = OC_OTHER; return(INTEGER_CONSTANT); }
"PARCEL_COUNT_SELECTED" { count(); yylval.ival = OC_SELECTED; return(INTEGER_CONSTANT); }
"PARCEL_COUNT_TEMP" { count(); yylval.ival = OC_TEMP; return(INTEGER_CONSTANT); }
"PARCEL_DETAILS_NAME" { count(); yylval.ival = PARCEL_DETAILS_NAME; return(INTEGER_CONSTANT); }
"PARCEL_DETAILS_DESC" { count(); yylval.ival = PARCEL_DETAILS_DESC; return(INTEGER_CONSTANT); }
"PARCEL_DETAILS_OWNER" { count(); yylval.ival = PARCEL_DETAILS_OWNER; return(INTEGER_CONSTANT); }
"PARCEL_DETAILS_GROUP" { count(); yylval.ival = PARCEL_DETAILS_GROUP; return(INTEGER_CONSTANT); }
"PARCEL_DETAILS_AREA" { count(); yylval.ival = PARCEL_DETAILS_AREA; return(INTEGER_CONSTANT); }
"STRING_TRIM_HEAD" { count(); yylval.ival = STRING_TRIM_HEAD; return(INTEGER_CONSTANT); }
"STRING_TRIM_TAIL" { count(); yylval.ival = STRING_TRIM_TAIL; return(INTEGER_CONSTANT); }
"STRING_TRIM" { count(); yylval.ival = STRING_TRIM; return(INTEGER_CONSTANT); }
"CLICK_ACTION_NONE" { count(); yylval.ival = CLICK_ACTION_NONE; return(INTEGER_CONSTANT); }
"CLICK_ACTION_TOUCH" { count(); yylval.ival = CLICK_ACTION_TOUCH; return(INTEGER_CONSTANT); }
"CLICK_ACTION_SIT" { count(); yylval.ival = CLICK_ACTION_SIT; return(INTEGER_CONSTANT); }
"CLICK_ACTION_BUY" { count(); yylval.ival = CLICK_ACTION_BUY; return(INTEGER_CONSTANT); }
"CLICK_ACTION_PAY" { count(); yylval.ival = CLICK_ACTION_PAY; return(INTEGER_CONSTANT); }
"CLICK_ACTION_OPEN" { count(); yylval.ival = CLICK_ACTION_OPEN; return(INTEGER_CONSTANT); }
"CLICK_ACTION_PLAY" { count(); yylval.ival = CLICK_ACTION_PLAY; return(INTEGER_CONSTANT); }
"CLICK_ACTION_OPEN_MEDIA" { count(); yylval.ival = CLICK_ACTION_OPEN_MEDIA; return(INTEGER_CONSTANT); }
"TEXTURE_BLANK" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "5748decc-f629-461c-9a36-a35a221fe21f"); return(STRING_CONSTANT); }
"TEXTURE_DEFAULT" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "89556747-24cb-43ed-920b-47caed15465f"); return(STRING_CONSTANT); }
"TEXTURE_MEDIA" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "8b5fec65-8d8d-9dc5-cda8-8fdf2716e361"); return(STRING_CONSTANT); }
"TEXTURE_PLYWOOD" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "89556747-24cb-43ed-920b-47caed15465f"); return(STRING_CONSTANT); }
"TEXTURE_TRANSPARENT" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "8dcd4a48-2d37-4909-9f78-f7a9eb4ef903"); return(STRING_CONSTANT); }
"TOUCH_INVALID_FACE" { count(); yylval.ival = -1; return(INTEGER_CONSTANT); }
"TOUCH_INVALID_VECTOR" { count(); return(TOUCH_INVALID_VECTOR); }
"TOUCH_INVALID_TEXCOORD" { count(); return(TOUCH_INVALID_TEXCOORD); }
{L}({L}|{N})* { count(); yylval.sval = new char[strlen(yytext) + 1]; strcpy(yylval.sval, yytext); return(IDENTIFIER); }
{N}+{E} { count(); yylval.fval = (F32)atof(yytext); return(FP_CONSTANT); }
{N}*"."{N}+({E})?{FS}? { count(); yylval.fval = (F32)atof(yytext); return(FP_CONSTANT); }
{N}+"."{N}*({E})?{FS}? { count(); yylval.fval = (F32)atof(yytext); return(FP_CONSTANT); }
L?\"(\\.|[^\\"])*\" { parse_string(); count(); return(STRING_CONSTANT); }
"++" { count(); return(INC_OP); }
"--" { count(); return(DEC_OP); }
"+=" { count(); return(ADD_ASSIGN); }
"-=" { count(); return(SUB_ASSIGN); }
"*=" { count(); return(MUL_ASSIGN); }
"/=" { count(); return(DIV_ASSIGN); }
"%=" { count(); return(MOD_ASSIGN); }
";" { count(); return(';'); }
"{" { count(); return('{'); }
"}" { count(); return('}'); }
"," { count(); return(','); }
"=" { count(); return('='); }
"(" { count(); return('('); }
")" { count(); return(')'); }
"-" { count(); return('-'); }
"+" { count(); return('+'); }
"*" { count(); return('*'); }
"/" { count(); return('/'); }
"%" { count(); return('%'); }
"@" { count(); return('@'); }
":" { count(); return(':'); }
">" { count(); return('>'); }
"<" { count(); return('<'); }
"]" { count(); return(']'); }
"[" { count(); return('['); }
"==" { count(); return(EQ); }
"!=" { count(); return(NEQ); }
">=" { count(); return(GEQ); }
"<=" { count(); return(LEQ); }
"&" { count(); return('&'); }
"|" { count(); return('|'); }
"^" { count(); return('^'); }
"~" { count(); return('~'); }
"!" { count(); return('!'); }
"&&" { count(); return(BOOLEAN_AND); }
"||" { count(); return(BOOLEAN_OR); }
"<<" { count(); return(SHIFT_LEFT); }
">>" { count(); return(SHIFT_RIGHT); }
[ \t\v\n\f] { count(); }
. { /* ignore bad characters */ }
%%
LLScriptAllocationManager *gAllocationManager;
LLScriptScript *gScriptp;
// Prototype for the yacc parser entry point
int yyparse(void);
int yyerror(const char *fmt, ...)
{
gErrorToText.writeError(yyout, gLine, gColumn, LSERROR_SYNTAX_ERROR);
return 0;
}
//#define EMERGENCY_DEBUG_PRINTOUTS
//#define EMIT_CIL_ASSEMBLER
BOOL lscript_compile(const char* src_filename, const char* dst_filename,
const char* err_filename, BOOL compile_to_mono, const char* class_name, BOOL is_god_like)
{
BOOL b_parse_ok = FALSE;
BOOL b_dummy = FALSE;
U64 b_dummy_count = FALSE;
LSCRIPTType type = LST_NULL;
gInternalColumn = 0;
gInternalLine = 0;
gScriptp = NULL;
gErrorToText.init();
init_supported_expressions();
init_temp_jumps();
gAllocationManager = new LLScriptAllocationManager();
yyin = LLFile::fopen(std::string(src_filename), "r");
if (yyin)
{
yyout = LLFile::fopen(std::string(err_filename), "w");
// Reset the lexer's internal buffering.
yyrestart(yyin);
b_parse_ok = !yyparse();
if (b_parse_ok)
{
#ifdef EMERGENCY_DEBUG_PRINTOUTS
char compiled[256];
sprintf(compiled, "%s.o", src_filename);
LLFILE* compfile;
compfile = LLFile::fopen(compiled, "w");
#endif
if(dst_filename)
{
gScriptp->setBytecodeDest(dst_filename);
}
gScriptp->mGodLike = is_god_like;
gScriptp->setClassName(class_name);
gScopeStringTable = new LLStringTable(16384);
#ifdef EMERGENCY_DEBUG_PRINTOUTS
gScriptp->recurse(compfile, 0, 4, LSCP_PRETTY_PRINT, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
#endif
gScriptp->recurse(yyout, 0, 0, LSCP_PRUNE, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
gScriptp->recurse(yyout, 0, 0, LSCP_SCOPE_PASS1, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
gScriptp->recurse(yyout, 0, 0, LSCP_SCOPE_PASS2, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
gScriptp->recurse(yyout, 0, 0, LSCP_TYPE, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
if (!gErrorToText.getErrors())
{
gScriptp->recurse(yyout, 0, 0, LSCP_RESOURCE, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
#ifdef EMERGENCY_DEBUG_PRINTOUTS
gScriptp->recurse(yyout, 0, 0, LSCP_EMIT_ASSEMBLY, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
#endif
if(TRUE == compile_to_mono)
{
gScriptp->recurse(yyout, 0, 0, LSCP_EMIT_CIL_ASSEMBLY, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
}
else
{
gScriptp->recurse(yyout, 0, 0, LSCP_EMIT_BYTE_CODE, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
}
}
delete gScopeStringTable;
gScopeStringTable = NULL;
#ifdef EMERGENCY_DEBUG_PRINTOUTS
fclose(compfile);
#endif
}
fclose(yyout);
fclose(yyin);
}
delete gAllocationManager;
delete gScopeStringTable;
return b_parse_ok && !gErrorToText.getErrors();
}
BOOL lscript_compile(char *filename, BOOL compile_to_mono, BOOL is_god_like = FALSE)
{
char src_filename[MAX_STRING];
sprintf(src_filename, "%s.lsl", filename);
char err_filename[MAX_STRING];
sprintf(err_filename, "%s.out", filename);
char class_name[MAX_STRING];
sprintf(class_name, "%s", filename);
return lscript_compile(src_filename, NULL, err_filename, compile_to_mono, class_name, is_god_like);
}
S32 yywrap()
{
#if defined(FLEX_SCANNER) && !defined(LL_WINDOWS)
// get gcc to stop complaining about lack of use of yyunput
(void) yyunput;
#endif
return(1);
}
void line_comment()
{
char c;
while ((c = yyinput()) != '\n' && c != 0 && c != EOF)
;
}
void block_comment()
{
char c1 = 0;
char c2 = yyinput();
while (c2 != 0 && c2 != EOF && !(c1 == '*' && c2 == '/')) {
if (c2 == '\n')
{
gInternalLine++;
gInternalColumn = 0;
}
else if (c2 == '\t')
gInternalColumn += 4 - (gInternalColumn % 8);
else
gInternalColumn++;
c1 = c2;
c2 = yyinput();
}
}
void count()
{
S32 i;
gColumn = gInternalColumn;
gLine = gInternalLine;
for (i = 0; yytext[i] != '\0'; i++)
if (yytext[i] == '\n')
{
gInternalLine++;
gInternalColumn = 0;
}
else if (yytext[i] == '\t')
gInternalColumn += 4 - (gInternalColumn % 8);
else
gInternalColumn++;
}
void parse_string()
{
S32 length = (S32)strlen(yytext);
length = length - 2;
char *temp = yytext + 1;
S32 i;
S32 escapes = 0;
S32 tabs = 0;
for (i = 0; i < length; i++)
{
if (temp[i] == '\\')
{
escapes++;
i++;
if (temp[i] == 't')
tabs++;
}
}
S32 newlength = length - escapes + tabs*3;
yylval.sval = new char[newlength + 1];
char *dest = yylval.sval;
for (i = 0; i < length; i++)
{
if (temp[i] == '\\')
{
i++;
// linefeed
if (temp[i] == 'n')
{
*dest++ = 10;
}
else if (temp[i] == 't')
{
*dest++ = ' ';
*dest++ = ' ';
*dest++ = ' ';
*dest++ = ' ';
}
else
{
*dest++ = temp[i];
}
}
else
{
*dest++ = temp[i];
}
}
yylval.sval[newlength] = 0;
}

1807
indra/lscript/lscript_compile/indra.y Normal file
View File

File diff suppressed because it is too large Load Diff

6774
indra/lscript/lscript_compile/indra_generated.l.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

4682
indra/lscript/lscript_compile/indra_generated.y.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

164
indra/lscript/lscript_compile/indra_generated.y.hpp Normal file
View File

@@ -0,0 +1,164 @@
/* A Bison parser, made by GNU Bison 2.4.1. */
/* Skeleton interface for Bison's Yacc-like parsers in C
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
INTEGER = 258,
FLOAT_TYPE = 259,
STRING = 260,
LLKEY = 261,
VECTOR = 262,
QUATERNION = 263,
LIST = 264,
STATE = 265,
EVENT = 266,
JUMP = 267,
RETURN = 268,
STATE_ENTRY = 269,
STATE_EXIT = 270,
TOUCH_START = 271,
TOUCH = 272,
TOUCH_END = 273,
COLLISION_START = 274,
COLLISION = 275,
COLLISION_END = 276,
LAND_COLLISION_START = 277,
LAND_COLLISION = 278,
LAND_COLLISION_END = 279,
TIMER = 280,
CHAT = 281,
SENSOR = 282,
NO_SENSOR = 283,
CONTROL = 284,
AT_TARGET = 285,
NOT_AT_TARGET = 286,
AT_ROT_TARGET = 287,
NOT_AT_ROT_TARGET = 288,
MONEY = 289,
EMAIL = 290,
RUN_TIME_PERMISSIONS = 291,
INVENTORY = 292,
ATTACH = 293,
DATASERVER = 294,
MOVING_START = 295,
MOVING_END = 296,
REZ = 297,
OBJECT_REZ = 298,
LINK_MESSAGE = 299,
REMOTE_DATA = 300,
HTTP_RESPONSE = 301,
HTTP_REQUEST = 302,
IDENTIFIER = 303,
STATE_DEFAULT = 304,
INTEGER_CONSTANT = 305,
INTEGER_TRUE = 306,
INTEGER_FALSE = 307,
FP_CONSTANT = 308,
STRING_CONSTANT = 309,
INC_OP = 310,
DEC_OP = 311,
ADD_ASSIGN = 312,
SUB_ASSIGN = 313,
MUL_ASSIGN = 314,
DIV_ASSIGN = 315,
MOD_ASSIGN = 316,
EQ = 317,
NEQ = 318,
GEQ = 319,
LEQ = 320,
BOOLEAN_AND = 321,
BOOLEAN_OR = 322,
SHIFT_LEFT = 323,
SHIFT_RIGHT = 324,
IF = 325,
ELSE = 326,
FOR = 327,
DO = 328,
WHILE = 329,
PRINT = 330,
PERIOD = 331,
ZERO_VECTOR = 332,
ZERO_ROTATION = 333,
TOUCH_INVALID_VECTOR = 334,
TOUCH_INVALID_TEXCOORD = 335,
LOWER_THAN_ELSE = 336,
INITIALIZER = 337
};
#endif
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
{
/* Line 1676 of yacc.c */
#line 38 "indra.y"
S32 ival;
F32 fval;
char *sval;
class LLScriptType *type;
class LLScriptConstant *constant;
class LLScriptIdentifier *identifier;
class LLScriptSimpleAssignable *assignable;
class LLScriptGlobalVariable *global;
class LLScriptEvent *event;
class LLScriptEventHandler *handler;
class LLScriptExpression *expression;
class LLScriptStatement *statement;
class LLScriptGlobalFunctions *global_funcs;
class LLScriptFunctionDec *global_decl;
class LLScriptState *state;
class LLScritpGlobalStorage *global_store;
class LLScriptScript *script;
/* Line 1676 of yacc.c */
#line 156 "indra_generated.y.hpp"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
#endif
extern YYSTYPE yylval;

32
indra/lscript/lscript_compile/lscript_alloc.cpp Normal file
View File

@@ -0,0 +1,32 @@
/**
* @file lscript_alloc.cpp
* @brief Allocation tracking
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/

326
indra/lscript/lscript_compile/lscript_bytecode.cpp Normal file
View File

@@ -0,0 +1,326 @@
/**
* @file lscript_bytecode.cpp
* @brief classes to build actual bytecode
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "lscript_bytecode.h"
#include "lscript_error.h"
#if defined(_MSC_VER)
# pragma warning(disable: 4102) // 'yy_more' : unreferenced label
# pragma warning(disable: 4702) // unreachable code
#endif
LLScriptJumpTable::LLScriptJumpTable()
{
}
LLScriptJumpTable::~LLScriptJumpTable()
{
mLabelMap.deleteAllData();
mJumpMap.deleteAllData();
}
void LLScriptJumpTable::addLabel(char *name, S32 offset)
{
char *temp = gScopeStringTable->addString(name);
mLabelMap[temp] = new S32(offset);
}
void LLScriptJumpTable::addJump(char *name, S32 offset)
{
char *temp = gScopeStringTable->addString(name);
mJumpMap[temp] = new S32(offset);
}
LLScriptByteCodeChunk::LLScriptByteCodeChunk(BOOL b_need_jumps)
: mCodeChunk(NULL), mCurrentOffset(0), mJumpTable(NULL)
{
if (b_need_jumps)
{
mJumpTable = new LLScriptJumpTable();
}
}
LLScriptByteCodeChunk::~LLScriptByteCodeChunk()
{
delete [] mCodeChunk;
delete mJumpTable;
}
void LLScriptByteCodeChunk::addByte(U8 byte)
{
if (mCodeChunk)
{
U8 *temp = new U8[mCurrentOffset + 1];
memcpy(temp, mCodeChunk, mCurrentOffset); /* Flawfinder: ignore */
delete [] mCodeChunk;
mCodeChunk = temp;
}
else
{
mCodeChunk = new U8[1];
}
*(mCodeChunk + mCurrentOffset++) = byte;
}
void LLScriptByteCodeChunk::addU16(U16 data)
{
U8 temp[2];
S32 offset = 0;
u162bytestream(temp, offset, data);
addBytes(temp, 2);
}
void LLScriptByteCodeChunk::addBytes(const U8 *bytes, S32 size)
{
if (mCodeChunk)
{
U8 *temp = new U8[mCurrentOffset + size];
memcpy(temp, mCodeChunk, mCurrentOffset); /* Flawfinder: ignore */
delete [] mCodeChunk;
mCodeChunk = temp;
}
else
{
mCodeChunk = new U8[size];
}
memcpy(mCodeChunk + mCurrentOffset, bytes, size);/* Flawfinder: ignore */
mCurrentOffset += size;
}
void LLScriptByteCodeChunk::addBytes(const char *bytes, S32 size)
{
if (mCodeChunk)
{
U8 *temp = new U8[mCurrentOffset + size];
memcpy(temp, mCodeChunk, mCurrentOffset); /*Flawfinder: ignore*/
delete [] mCodeChunk;
mCodeChunk = temp;
}
else
{
mCodeChunk = new U8[size];
}
memcpy(mCodeChunk + mCurrentOffset, bytes, size); /*Flawfinder: ignore*/
mCurrentOffset += size;
}
void LLScriptByteCodeChunk::addBytes(S32 size)
{
if (mCodeChunk)
{
U8 *temp = new U8[mCurrentOffset + size];
memcpy(temp, mCodeChunk, mCurrentOffset); /*Flawfinder: ignore*/
delete [] mCodeChunk;
mCodeChunk = temp;
}
else
{
mCodeChunk = new U8[size];
}
memset(mCodeChunk + mCurrentOffset, 0, size);
mCurrentOffset += size;
}
void LLScriptByteCodeChunk::addBytesDontInc(S32 size)
{
if (mCodeChunk)
{
U8 *temp = new U8[mCurrentOffset + size];
memcpy(temp, mCodeChunk, mCurrentOffset); /*Flawfinder: ignore*/
delete [] mCodeChunk;
mCodeChunk = temp;
}
else
{
mCodeChunk = new U8[size];
}
memset(mCodeChunk + mCurrentOffset, 0, size);
}
void LLScriptByteCodeChunk::addInteger(S32 value)
{
U8 temp[4];
S32 offset = 0;
integer2bytestream(temp, offset, value);
addBytes(temp, 4);
}
void LLScriptByteCodeChunk::addFloat(F32 value)
{
U8 temp[4];
S32 offset = 0;
float2bytestream(temp, offset, value);
addBytes(temp, 4);
}
void LLScriptByteCodeChunk::addLabel(char *name)
{
if (mJumpTable)
{
mJumpTable->addLabel(name, mCurrentOffset);
}
}
void LLScriptByteCodeChunk::addJump(char *name)
{
if (mJumpTable)
{
mJumpTable->addJump(name, mCurrentOffset);
}
}
// format is Byte 0: jump op code Byte 1 - 4: offset
// the jump position points to Byte 5, so we need to add the data at
// offset - 4, offset - 3, offset - 2, and offset - 1
// offset is label - jump
void LLScriptByteCodeChunk::connectJumps()
{
char *jump;
S32 offset, jumppos;
if (mJumpTable)
{
for (jump = mJumpTable->mJumpMap.getFirstKey();
jump;
jump = mJumpTable->mJumpMap.getNextKey())
{
jumppos = *mJumpTable->mJumpMap[jump];
offset = *mJumpTable->mLabelMap[jump] - jumppos;
jumppos = jumppos - 4;
integer2bytestream(mCodeChunk, jumppos, offset);
}
}
}
LLScriptScriptCodeChunk::LLScriptScriptCodeChunk(S32 total_size)
: mTotalSize(total_size), mCompleteCode(NULL)
{
mRegisters = new LLScriptByteCodeChunk(FALSE);
mGlobalVariables = new LLScriptByteCodeChunk(FALSE);
mGlobalFunctions = new LLScriptByteCodeChunk(FALSE);
mStates = new LLScriptByteCodeChunk(FALSE);
mHeap = new LLScriptByteCodeChunk(FALSE);
}
LLScriptScriptCodeChunk::~LLScriptScriptCodeChunk()
{
delete mRegisters;
delete mGlobalVariables;
delete mGlobalFunctions;
delete mStates;
delete mHeap;
delete [] mCompleteCode;
}
void LLScriptScriptCodeChunk::build(LLFILE *efp, LLFILE *bcfp)
{
S32 code_data_size = mRegisters->mCurrentOffset +
mGlobalVariables->mCurrentOffset +
mGlobalFunctions->mCurrentOffset +
mStates->mCurrentOffset +
mHeap->mCurrentOffset;
S32 offset = 0;
if (code_data_size < mTotalSize)
{
mCompleteCode = new U8[mTotalSize];
memset(mCompleteCode, 0, mTotalSize);
memcpy(mCompleteCode, mRegisters->mCodeChunk, mRegisters->mCurrentOffset);
offset += mRegisters->mCurrentOffset;
set_register(mCompleteCode, LREG_IP, 0);
set_register(mCompleteCode, LREG_VN, LSL2_VERSION_NUMBER);
set_event_register(mCompleteCode, LREG_IE, 0, LSL2_CURRENT_MAJOR_VERSION);
set_register(mCompleteCode, LREG_BP, mTotalSize - 1);
set_register(mCompleteCode, LREG_SP, mTotalSize - 1);
set_register(mCompleteCode, LREG_GVR, offset);
memcpy(mCompleteCode + offset, mGlobalVariables->mCodeChunk, mGlobalVariables->mCurrentOffset); /*Flawfinder: ignore*/
offset += mGlobalVariables->mCurrentOffset;
set_register(mCompleteCode, LREG_GFR, offset);
memcpy(mCompleteCode + offset, mGlobalFunctions->mCodeChunk, mGlobalFunctions->mCurrentOffset); /*Flawfinder: ignore*/
offset += mGlobalFunctions->mCurrentOffset;
set_register(mCompleteCode, LREG_SR, offset);
// zero is, by definition the default state
set_register(mCompleteCode, LREG_CS, 0);
set_register(mCompleteCode, LREG_NS, 0);
set_event_register(mCompleteCode, LREG_CE, LSCRIPTStateBitField[LSTT_STATE_ENTRY], LSL2_CURRENT_MAJOR_VERSION);
S32 default_state_offset = 0;
if (LSL2_CURRENT_MAJOR_VERSION == LSL2_MAJOR_VERSION_TWO)
{
default_state_offset = 8;
}
else
{
default_state_offset = 4;
}
set_event_register(mCompleteCode, LREG_ER, bytestream2u64(mStates->mCodeChunk, default_state_offset), LSL2_CURRENT_MAJOR_VERSION);
memcpy(mCompleteCode + offset, mStates->mCodeChunk, mStates->mCurrentOffset); /*Flawfinder: ignore*/
offset += mStates->mCurrentOffset;
set_register(mCompleteCode, LREG_HR, offset);
memcpy(mCompleteCode + offset, mHeap->mCodeChunk, mHeap->mCurrentOffset); /*Flawfinder: ignore*/
offset += mHeap->mCurrentOffset;
set_register(mCompleteCode, LREG_HP, offset);
set_register(mCompleteCode, LREG_FR, 0);
set_register(mCompleteCode, LREG_SLR, 0);
set_register(mCompleteCode, LREG_ESR, 0);
set_register(mCompleteCode, LREG_PR, 0);
set_register(mCompleteCode, LREG_TM, mTotalSize);
if (fwrite(mCompleteCode, 1, mTotalSize, bcfp) != mTotalSize)
{
llwarns << "Short write" << llendl;
}
}
else
{
gErrorToText.writeError(efp, 0, 0, LSERROR_ASSEMBLE_OUT_OF_MEMORY);
}
}
LLScriptScriptCodeChunk *gScriptCodeChunk;

95
indra/lscript/lscript_compile/lscript_bytecode.h Normal file
View File

@@ -0,0 +1,95 @@
/**
* @file lscript_bytecode.h
* @brief classes to build actual bytecode
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_BYTECODE_H
#define LL_LSCRIPT_BYTECODE_H
#include "lscript_byteconvert.h"
#include "lscript_scope.h"
class LLScriptJumpTable
{
public:
LLScriptJumpTable();
~LLScriptJumpTable();
void addLabel(char *name, S32 offset);
void addJump(char *name, S32 offset);
LLMap<char *, S32 *> mLabelMap;
LLMap<char *, S32 *> mJumpMap;
};
class LLScriptByteCodeChunk
{
public:
LLScriptByteCodeChunk(BOOL b_need_jumps);
~LLScriptByteCodeChunk();
void addByte(U8 byte);
void addU16(U16 data);
void addBytes(const U8 *bytes, S32 size);
void addBytes(const char *bytes, S32 size);
void addBytes(S32 size);
void addBytesDontInc(S32 size);
void addInteger(S32 value);
void addFloat(F32 value);
void addLabel(char *name);
void addJump(char *name);
void connectJumps();
U8 *mCodeChunk;
S32 mCurrentOffset;
LLScriptJumpTable *mJumpTable;
};
class LLScriptScriptCodeChunk
{
public:
LLScriptScriptCodeChunk(S32 total_size);
~LLScriptScriptCodeChunk();
void build(LLFILE *efp, LLFILE *bcfp);
LLScriptByteCodeChunk *mRegisters;
LLScriptByteCodeChunk *mGlobalVariables;
LLScriptByteCodeChunk *mGlobalFunctions;
LLScriptByteCodeChunk *mStates;
LLScriptByteCodeChunk *mHeap;
S32 mTotalSize;
U8 *mCompleteCode;
};
extern LLScriptScriptCodeChunk *gScriptCodeChunk;
#endif

109
indra/lscript/lscript_compile/lscript_error.cpp Normal file
View File

@@ -0,0 +1,109 @@
/**
* @file lscript_error.cpp
* @brief error reporting class and strings
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "lscript_error.h"
S32 gColumn = 0;
S32 gLine = 0;
S32 gInternalColumn = 0;
S32 gInternalLine = 0;
LLScriptGenerateErrorText gErrorToText;
void LLScriptFilePosition::fdotabs(LLFILE *fp, S32 tabs, S32 tabsize)
{
S32 i;
for (i = 0; i < tabs * tabsize; i++)
{
fprintf(fp, " ");
}
}
const char* gWarningText[LSWARN_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"Dead code found beyond return statement"
};
const char* gErrorText[LSERROR_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"Syntax error",
"Not all code paths return a value",
"Function returns a value but return statement doesn't",
"Return statement type doesn't match function return type",
"Global functions can't change state",
"Name previously declared within scope",
"Name not defined within scope",
"Type mismatch",
"Expression must act on LValue",
"Byte code assembly failed -- out of memory",
"Function call mismatches type or number of arguments",
"Use of vector or quaternion method on incorrect type",
"Lists can't be included in lists",
"Unitialized variables can't be included in lists",
"Declaration requires a new scope -- use { and }",
"CIL assembler failed",
"Bytecode transformer failed",
"Bytecode verification failed"
};
void LLScriptGenerateErrorText::writeWarning(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTWarnings warning)
{
fprintf(fp, "(%d, %d) : WARNING : %s\n", pos->mLineNumber, pos->mColumnNumber, gWarningText[warning]);
mTotalWarnings++;
}
void LLScriptGenerateErrorText::writeWarning(LLFILE *fp, S32 line, S32 col, LSCRIPTWarnings warning)
{
fprintf(fp, "(%d, %d) : WARNING : %s\n", line, col, gWarningText[warning]);
mTotalWarnings++;
}
void LLScriptGenerateErrorText::writeError(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTErrors error)
{
fprintf(fp, "(%d, %d) : ERROR : %s\n", pos->mLineNumber, pos->mColumnNumber, gErrorText[error]);
mTotalErrors++;
}
void LLScriptGenerateErrorText::writeError(LLFILE *fp, S32 line, S32 col, LSCRIPTErrors error)
{
fprintf(fp, "(%d, %d) : ERROR : %s\n", line, col, gErrorText[error]);
mTotalErrors++;
}
std::string getLScriptErrorString(LSCRIPTErrors error)
{
return gErrorText[error];
}

158
indra/lscript/lscript_compile/lscript_error.h Normal file
View File

@@ -0,0 +1,158 @@
/**
* @file lscript_error.h
* @brief error reporting class and strings
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_ERROR_H
#define LL_LSCRIPT_ERROR_H
#include "lscript_scope.h"
typedef enum e_lscript_compile_pass
{
LSCP_INVALID,
LSCP_PRETTY_PRINT,
LSCP_PRUNE,
LSCP_SCOPE_PASS1,
LSCP_SCOPE_PASS2,
LSCP_TYPE,
LSCP_RESOURCE,
LSCP_EMIT_ASSEMBLY,
LSCP_EMIT_BYTE_CODE,
LSCP_DETERMINE_HANDLERS,
LSCP_LIST_BUILD_SIMPLE,
LSCP_TO_STACK,
LSCP_BUILD_FUNCTION_ARGS,
LSCP_EMIT_CIL_ASSEMBLY,
LSCP_EOF
} LSCRIPTCompilePass;
typedef enum e_lscript_prune_type
{
LSPRUNE_INVALID,
LSPRUNE_GLOBAL_VOIDS,
LSPRUNE_GLOBAL_NON_VOIDS,
LSPRUNE_EVENTS,
LSPRUNE_DEAD_CODE,
LSPRUNE_EOF
} LSCRIPTPruneType;
extern S32 gColumn;
extern S32 gLine;
extern S32 gInternalColumn;
extern S32 gInternalLine;
// used to describe where in the file this piece is
class LLScriptByteCodeChunk;
class LLScriptLibData;
class LLScriptFilePosition
{
public:
LLScriptFilePosition(S32 line, S32 col)
: mLineNumber(line), mColumnNumber(col), mByteOffset(0), mByteSize(0)
{
}
virtual ~LLScriptFilePosition() {}
virtual void recurse(LLFILE *fp, S32 tabs, S32 tabsize,
LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg,
LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count,
LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata) = 0;
virtual S32 getSize() = 0;
void fdotabs(LLFILE *fp, S32 tabs, S32 tabsize);
S32 mLineNumber;
S32 mColumnNumber;
S32 mByteOffset;
S32 mByteSize;
};
typedef enum e_lscript_warnings
{
LSWARN_INVALID,
LSWARN_DEAD_CODE,
LSWARN_EOF
} LSCRIPTWarnings;
typedef enum e_lscript_errors
{
LSERROR_INVALID,
LSERROR_SYNTAX_ERROR,
LSERROR_NO_RETURN,
LSERROR_INVALID_VOID_RETURN,
LSERROR_INVALID_RETURN,
LSERROR_STATE_CHANGE_IN_GLOBAL,
LSERROR_DUPLICATE_NAME,
LSERROR_UNDEFINED_NAME,
LSERROR_TYPE_MISMATCH,
LSERROR_EXPRESSION_ON_LVALUE,
LSERROR_ASSEMBLE_OUT_OF_MEMORY,
LSERROR_FUNCTION_TYPE_ERROR,
LSERROR_VECTOR_METHOD_ERROR,
LSERROR_NO_LISTS_IN_LISTS,
LSERROR_NO_UNITIALIZED_VARIABLES_IN_LISTS,
LSERROR_NEED_NEW_SCOPE,
LSERROR_CIL_ASSEMBLER_FAILED = 16, // Mono build error.
LSERROR_BYTECODE_TRANSFORM_FAILED = 17, // Mono build error.
LSERROR_BYTECODE_VERIFICATION_FAILED, // Mono build error.
LSERROR_EOF
} LSCRIPTErrors;
class LLScriptGenerateErrorText
{
public:
LLScriptGenerateErrorText() { init(); }
~LLScriptGenerateErrorText() {}
void init() { mTotalErrors = 0; mTotalWarnings = 0; }
void writeWarning(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTWarnings warning);
void writeWarning(LLFILE *fp, S32 line, S32 col, LSCRIPTWarnings warning);
void writeError(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTErrors error);
void writeError(LLFILE *fp, S32 line, S32 col, LSCRIPTErrors error);
BOOL getErrors() { return mTotalErrors; }
BOOL getWarnings() { return mTotalWarnings; }
S32 mTotalErrors;
S32 mTotalWarnings;
};
std::string getLScriptErrorString(LSCRIPTErrors error);
extern LLScriptGenerateErrorText gErrorToText;
#endif

73
indra/lscript/lscript_compile/lscript_heap.cpp Normal file
View File

@@ -0,0 +1,73 @@
/**
* @file lscript_heap.cpp
* @brief classes to manage script heap
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#if 0
#include "linden_common.h"
#include "lscript_heap.h"
LLScriptHeapEntry::LLScriptHeapEntry(U8 *entry)
: mEntry(entry)
{
S32 offset = 0;
mNext = bytestream2integer(entry, offset);
mRefCount = bytestream2integer(entry, offset);
mType = *(entry + offset);
mData = entry + offset;
mListOffset = offset;
}
LLScriptHeapEntry::LLScriptHeapEntry(U8 *heap, S32 offset)
: mNext(0x9), mType(0), mRefCount(0), mEntry(heap + offset), mData(heap + offset + 0x9), mListOffset(0x9)
{
}
LLScriptHeapEntry::~LLScriptHeapEntry()
{
}
void LLScriptHeapEntry::addString(char *string)
{
S32 size = strlen(string) + 1; /*Flawfinder: ignore*/
S32 offset = 0;
memcpy(mData, string, size); /*Flawfinder: ignore*/
mNext += size;
integer2bytestream(mEntry, offset, mNext);
mRefCount++;
integer2bytestream(mEntry, offset, mRefCount);
*(mEntry + offset) = LSCRIPTTypeByte[LST_STRING];
}
#endif

64
indra/lscript/lscript_compile/lscript_heap.h Normal file
View File

@@ -0,0 +1,64 @@
/**
* @file lscript_heap.h
* @brief classes to manage script heap
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#if 0
#ifndef LL_LSCRIPT_HEAP_H
#define LL_LSCRIPT_HEAP_H
#include "lscript_byteconvert.h"
//#include "vmath.h"
#include "v3math.h"
#include "llquaternion.h"
class LLScriptHeapEntry
{
public:
LLScriptHeapEntry(U8 *entry);
LLScriptHeapEntry(U8 *heap, S32 offset);
~LLScriptHeapEntry();
void addString(char *string);
S32 mNext;
U8 mType;
S32 mRefCount;
S32 mListOffset;
U8 *mEntry;
U8 *mData;
U8 *mListEntry;
};
#endif
#endif

42
indra/lscript/lscript_compile/lscript_resource.cpp Normal file
View File

@@ -0,0 +1,42 @@
/**
* @file lscript_resource.cpp
* @brief resource determination prior to assembly
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "lscript_resource.h"
void init_temp_jumps()
{
gTempJumpCount = 0;
}
S32 gTempJumpCount = 0;

43
indra/lscript/lscript_compile/lscript_resource.h Normal file
View File

@@ -0,0 +1,43 @@
/**
* @file lscript_resource.h
* @brief resource determination prior to assembly
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_RESOURCE_H
#define LL_LSCRIPT_RESOURCE_H
#include "lscript_scope.h"
void init_temp_jumps();
extern S32 gTempJumpCount;
#endif

37
indra/lscript/lscript_compile/lscript_scope.cpp Normal file
View File

@@ -0,0 +1,37 @@
/**
* @file lscript_scope.cpp
* @brief builds nametable and checks scope
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "lscript_tree.h"
LLStringTable *gScopeStringTable;

412
indra/lscript/lscript_compile/lscript_scope.h Normal file
View File

@@ -0,0 +1,412 @@
/**
* @file lscript_scope.h
* @brief builds nametable and checks scope
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_SCOPE_H
#define LL_LSCRIPT_SCOPE_H
#include "string_table.h"
#include "llmap.h"
#include "lscript_byteformat.h"
typedef enum e_lscript_identifier_type
{
LIT_INVALID,
LIT_GLOBAL,
LIT_VARIABLE,
LIT_FUNCTION,
LIT_LABEL,
LIT_STATE,
LIT_HANDLER,
LIT_LIBRARY_FUNCTION,
LIT_EOF
} LSCRIPTIdentifierType;
const char LSCRIPTFunctionTypeStrings[LST_EOF] = /*Flawfinder: ignore*/
{
'0',
'i',
'f',
's',
'k',
'v',
'q',
'l',
'0'
};
const char * const LSCRIPTListDescription[LST_EOF] = /*Flawfinder: ignore*/
{
"PUSHARGB 0",
"PUSHARGB 1",
"PUSHARGB 2",
"PUSHARGB 3",
"PUSHARGB 4",
"PUSHARGB 5",
"PUSHARGB 6",
"PUSHARGB 7",
"PUSHARGB 0"
};
const char * const LSCRIPTTypePush[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"PUSHE",
"PUSHE",
"PUSHE",
"PUSHE",
"PUSHEV",
"PUSHEQ",
"PUSHE",
"undefined"
};
const char * const LSCRIPTTypeReturn[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"LOADP -12",
"LOADP -12",
"STORES -12\nPOP",
"STORES -12\nPOP",
"LOADVP -20",
"LOADQP -24",
"LOADLP -12",
"undefined"
};
const char * const LSCRIPTTypePop[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"POP",
"POP",
"POPS",
"POPS",
"POPV",
"POPQ",
"POPL",
"undefined"
};
const char * const LSCRIPTTypeDuplicate[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"DUP",
"DUP",
"DUPS",
"DUPS",
"DUPV",
"DUPQ",
"DUPL",
"undefined"
};
const char * const LSCRIPTTypeLocalStore[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"STORE ",
"STORE ",
"STORES ",
"STORES ",
"STOREV ",
"STOREQ ",
"STOREL ",
"undefined"
};
const char * const LSCRIPTTypeLocalDeclaration[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"STOREP ",
"STOREP ",
"STORESP ",
"STORESP ",
"STOREVP ",
"STOREQP ",
"STORELP ",
"undefined"
};
const char * const LSCRIPTTypeGlobalStore[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"STOREG ",
"STOREG ",
"STORESG ",
"STORESG ",
"STOREGV ",
"STOREGQ ",
"STORELG ",
"undefined"
};
const char * const LSCRIPTTypeLocalPush[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"PUSH ",
"PUSH ",
"PUSHS ",
"PUSHS ",
"PUSHV ",
"PUSHQ ",
"PUSHL ",
"undefined"
};
const char * const LSCRIPTTypeLocalPush1[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"PUSHARGI 1",
"PUSHARGF 1",
"undefined",
"undefined",
"undefined",
"undefined",
"undefined",
"undefined"
};
const char * const LSCRIPTTypeGlobalPush[LST_EOF] = /*Flawfinder: ignore*/
{
"INVALID",
"PUSHG ",
"PUSHG ",
"PUSHGS ",
"PUSHGS ",
"PUSHGV ",
"PUSHGQ ",
"PUSHGL ",
"undefined"
};
class LLScriptSimpleAssignable;
class LLScriptArgString
{
public:
LLScriptArgString() : mString(NULL) {}
~LLScriptArgString() { delete [] mString; }
LSCRIPTType getType(S32 count)
{
if (!mString)
return LST_NULL;
S32 length = (S32)strlen(mString); /*Flawfinder: ignore*/
if (count >= length)
{
return LST_NULL;
}
switch(mString[count])
{
case 'i':
return LST_INTEGER;
case 'f':
return LST_FLOATINGPOINT;
case 's':
return LST_STRING;
case 'k':
return LST_KEY;
case 'v':
return LST_VECTOR;
case 'q':
return LST_QUATERNION;
case 'l':
return LST_LIST;
default:
return LST_NULL;
}
}
void addType(LSCRIPTType type)
{
S32 count = 0;
if (mString)
{
count = (S32)strlen(mString); /*Flawfinder: ignore*/
char *temp = new char[count + 2];
memcpy(temp, mString, count); /*Flawfinder: ignore*/
delete [] mString;
mString = temp;
mString[count + 1] = 0;
}
else
{
mString = new char[count + 2];
mString[count + 1] = 0;
}
mString[count++] = LSCRIPTFunctionTypeStrings[type];
}
S32 getNumber()
{
if (mString)
return (S32)strlen(mString); /*Flawfinder: ignore*/
else
return 0;
}
char *mString;
};
class LLScriptScopeEntry
{
public:
LLScriptScopeEntry(const char *identifier, LSCRIPTIdentifierType idtype, LSCRIPTType type, S32 count = 0)
: mIdentifier(identifier), mIDType(idtype), mType(type), mOffset(0), mSize(0), mAssignable(NULL), mCount(count), mLibraryNumber(0)
{
}
~LLScriptScopeEntry() {}
const char *mIdentifier;
LSCRIPTIdentifierType mIDType;
LSCRIPTType mType;
S32 mOffset;
S32 mSize;
LLScriptSimpleAssignable *mAssignable;
S32 mCount; // NOTE: Index for locals in CIL.
U16 mLibraryNumber;
LLScriptArgString mFunctionArgs;
LLScriptArgString mLocals;
};
class LLScriptScope
{
public:
LLScriptScope(LLStringTable *stable)
: mParentScope(NULL), mSTable(stable), mFunctionCount(0), mStateCount(0)
{
}
~LLScriptScope()
{
mEntryMap.deleteAllData();
}
LLScriptScopeEntry *addEntry(const char *identifier, LSCRIPTIdentifierType idtype, LSCRIPTType type)
{
const char *name = mSTable->addString(identifier);
if (!mEntryMap.checkData(name))
{
if (idtype == LIT_FUNCTION)
mEntryMap[name] = new LLScriptScopeEntry(name, idtype, type, mFunctionCount++);
else if (idtype == LIT_STATE)
mEntryMap[name] = new LLScriptScopeEntry(name, idtype, type, mStateCount++);
else
mEntryMap[name] = new LLScriptScopeEntry(name, idtype, type);
return mEntryMap[name];
}
else
{
// identifier already exists at this scope
return NULL;
}
}
BOOL checkEntry(const char *identifier)
{
const char *name = mSTable->addString(identifier);
if (mEntryMap.checkData(name))
{
return TRUE;
}
else
{
// identifier already exists at this scope
return FALSE;
}
}
LLScriptScopeEntry *findEntry(const char *identifier)
{
const char *name = mSTable->addString(identifier);
LLScriptScope *scope = this;
while (scope)
{
if (scope->mEntryMap.checkData(name))
{
// cool, we found it at this scope
return scope->mEntryMap[name];
}
scope = scope->mParentScope;
}
return NULL;
}
LLScriptScopeEntry *findEntryTyped(const char *identifier, LSCRIPTIdentifierType idtype)
{
const char *name = mSTable->addString(identifier);
LLScriptScope *scope = this;
while (scope)
{
if (scope->mEntryMap.checkData(name))
{
// need to check type, and if type is function we need to check both types
if (idtype == LIT_FUNCTION)
{
if (scope->mEntryMap[name]->mIDType == LIT_FUNCTION)
{
return scope->mEntryMap[name];
}
else if (scope->mEntryMap[name]->mIDType == LIT_LIBRARY_FUNCTION)
{
return scope->mEntryMap[name];
}
}
else if (scope->mEntryMap[name]->mIDType == idtype)
{
// cool, we found it at this scope
return scope->mEntryMap[name];
}
}
scope = scope->mParentScope;
}
return NULL;
}
void addParentScope(LLScriptScope *scope)
{
mParentScope = scope;
}
LLMap<const char *, LLScriptScopeEntry *> mEntryMap;
LLScriptScope *mParentScope;
LLStringTable *mSTable;
S32 mFunctionCount;
S32 mStateCount;
};
extern LLStringTable *gScopeStringTable;
#endif

10892
indra/lscript/lscript_compile/lscript_tree.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

2331
indra/lscript/lscript_compile/lscript_tree.h Normal file
View File

File diff suppressed because it is too large Load Diff

592
indra/lscript/lscript_compile/lscript_typecheck.cpp Normal file
View File

@@ -0,0 +1,592 @@
/**
* @file lscript_typecheck.cpp
* @brief typechecks script
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "lscript_tree.h"
/*
LScript automatic type casting
LST_INTEGER -> LST_INTEGER
LST_FLOATINGPOINT -> LST_FLOATINGPOINT
LST_INTEGER -> LST_FLOATINGPOINT
LST_FLOATINGPOINT -> LST_STRING
LST_INTEGER -> LST_STRING
LST_STRING -> LST_STRING
LST_VECTOR -> LST_STRING
LST_QUATERNION -> LST_STRING
LST_LIST -> LST_STRING
LST_VECTOR -> LST_VECTOR
LST_QUATERNION -> LST_QUATERNION
LST_FLOATINGPOINT -> LST_LIST
LST_INTEGER -> LST_LIST
LST_STRING -> LST_LIST
LST_VECTOR -> LST_LIST
LST_QUATERNION -> LST_LIST
LST_LIST -> LST_LIST
*/
LSCRIPTType implicit_casts(LSCRIPTType left_side, LSCRIPTType right_side)
{
switch(left_side)
{
// shouldn't be doing an operation on void types
case LST_NULL:
switch(right_side)
{
case LST_NULL:
return LST_NULL;
default:
return LST_UNDEFINED;
}
// shouldn't be doing an operation on undefined types
case LST_UNDEFINED:
return LST_UNDEFINED;
// only integers can become integers
case LST_INTEGER:
switch(right_side)
{
case LST_INTEGER:
return LST_INTEGER;
default:
return LST_UNDEFINED;
}
// only integers and floats can become floats
case LST_FLOATINGPOINT:
switch(right_side)
{
case LST_INTEGER:
case LST_FLOATINGPOINT:
return LST_FLOATINGPOINT;
default:
return LST_UNDEFINED;
}
// only strings and keys can become strings
case LST_STRING:
switch(right_side)
{
case LST_STRING:
case LST_KEY:
return LST_STRING;
default:
return LST_UNDEFINED;
}
// only strings and keys can become keys
case LST_KEY:
switch(right_side)
{
case LST_STRING:
case LST_KEY:
return LST_KEY;
default:
return LST_UNDEFINED;
}
// only vectors can become vectors
case LST_VECTOR:
switch(right_side)
{
case LST_VECTOR:
return LST_VECTOR;
default:
return LST_UNDEFINED;
}
// only quaternions can become quaternions
case LST_QUATERNION:
switch(right_side)
{
case LST_QUATERNION:
return LST_QUATERNION;
default:
return LST_UNDEFINED;
}
// only lists can become lists
case LST_LIST:
switch(right_side)
{
case LST_LIST:
return LST_LIST;
default:
return LST_UNDEFINED;
}
default:
return LST_UNDEFINED;
}
}
LSCRIPTType promote(LSCRIPTType left_side, LSCRIPTType right_side)
{
LSCRIPTType type;
type = implicit_casts(left_side, right_side);
if (type != LST_UNDEFINED)
{
return type;
}
type = implicit_casts(right_side, left_side);
if (type != LST_UNDEFINED)
{
return type;
}
return LST_UNDEFINED;
}
BOOL legal_assignment(LSCRIPTType left_side, LSCRIPTType right_side)
{
// this is to prevent cascading errors
if ( (left_side == LST_UNDEFINED)
||(right_side == LST_UNDEFINED))
{
return TRUE;
}
if (implicit_casts(left_side, right_side) != LST_UNDEFINED)
{
return TRUE;
}
else
{
return FALSE;
}
}
BOOL legal_casts(LSCRIPTType cast, LSCRIPTType base)
{
switch(base)
{
// shouldn't be doing an operation on void types
case LST_NULL:
return FALSE;
// shouldn't be doing an operation on undefined types
case LST_UNDEFINED:
return FALSE;
case LST_INTEGER:
switch(cast)
{
case LST_INTEGER:
case LST_FLOATINGPOINT:
case LST_STRING:
case LST_LIST:
return TRUE;
break;
default:
return FALSE;
break;
}
break;
case LST_FLOATINGPOINT:
switch(cast)
{
case LST_INTEGER:
case LST_FLOATINGPOINT:
case LST_STRING:
case LST_LIST:
return TRUE;
break;
default:
return FALSE;
break;
}
break;
case LST_STRING:
switch(cast)
{
case LST_INTEGER:
case LST_FLOATINGPOINT:
case LST_STRING:
case LST_KEY:
case LST_VECTOR:
case LST_QUATERNION:
case LST_LIST:
return TRUE;
break;
default:
return FALSE;
break;
}
break;
case LST_KEY:
switch(cast)
{
case LST_STRING:
case LST_KEY:
case LST_LIST:
return TRUE;
break;
default:
return FALSE;
break;
}
break;
case LST_VECTOR:
switch(cast)
{
case LST_VECTOR:
case LST_STRING:
case LST_LIST:
return TRUE;
break;
default:
return FALSE;
break;
}
break;
case LST_QUATERNION:
switch(cast)
{
case LST_QUATERNION:
case LST_STRING:
case LST_LIST:
return TRUE;
break;
default:
return FALSE;
break;
}
break;
// lists can only be cast to lists and strings
case LST_LIST:
switch(cast)
{
case LST_LIST:
case LST_STRING:
return TRUE;
break;
default:
return FALSE;
break;
}
break;
default:
return FALSE;
break;
}
}
LSCRIPTType gSupportedExpressionArray[LET_EOF][LST_EOF][LST_EOF];
void init_supported_expressions(void)
{
S32 i, j, k;
// zero out, then set the ones that matter
for (i = 0; i < LET_EOF; i++)
{
for (j = 0; j < LST_EOF; j++)
{
for (k = 0; k < LST_EOF; k++)
{
gSupportedExpressionArray[i][j][k] = LST_NULL;
}
}
}
// LET_ASSIGNMENT
gSupportedExpressionArray[LET_ASSIGNMENT][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_STRING][LST_STRING] = LST_STRING;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_KEY][LST_KEY] = LST_KEY;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_INTEGER] = LST_LIST;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_FLOATINGPOINT] = LST_LIST;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_STRING] = LST_LIST;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_KEY] = LST_LIST;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_VECTOR] = LST_LIST;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_QUATERNION] = LST_LIST;
gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_LIST] = LST_LIST;
// LET_ADD_ASSIGN
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_STRING][LST_STRING] = LST_STRING;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_INTEGER] = LST_LIST;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_FLOATINGPOINT] = LST_LIST;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_STRING] = LST_LIST;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_KEY] = LST_LIST;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_VECTOR] = LST_LIST;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_QUATERNION] = LST_LIST;
gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_LIST] = LST_LIST;
// LET_SUB_ASSIGN
gSupportedExpressionArray[LET_SUB_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_SUB_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_SUB_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_SUB_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_SUB_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
// LET_MUL_ASSIGN
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
//gSupportedExpressionArray[LET_MUL_ASSIGN][LST_INTEGER][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
//gSupportedExpressionArray[LET_MUL_ASSIGN][LST_FLOATINGPOINT][LST_VECTOR] = LST_VECTOR;
//gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
gSupportedExpressionArray[LET_MUL_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
// LET_DIV_ASSIGN
gSupportedExpressionArray[LET_DIV_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_DIV_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_DIV_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_DIV_ASSIGN][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
gSupportedExpressionArray[LET_DIV_ASSIGN][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
gSupportedExpressionArray[LET_DIV_ASSIGN][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
gSupportedExpressionArray[LET_DIV_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
// LET_MOD_ASSIGN
gSupportedExpressionArray[LET_MOD_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_MOD_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
// LET_EQUALITY
gSupportedExpressionArray[LET_EQUALITY][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_STRING][LST_STRING] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_STRING][LST_KEY] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_KEY][LST_STRING] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_KEY][LST_KEY] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_VECTOR][LST_VECTOR] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_QUATERNION][LST_QUATERNION] = LST_INTEGER;
gSupportedExpressionArray[LET_EQUALITY][LST_LIST][LST_LIST] = LST_INTEGER;
// LET_NOT_EQUALS
gSupportedExpressionArray[LET_NOT_EQUALS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_STRING][LST_STRING] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_STRING][LST_KEY] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_KEY][LST_STRING] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_KEY][LST_KEY] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_VECTOR][LST_VECTOR] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_QUATERNION][LST_QUATERNION] = LST_INTEGER;
gSupportedExpressionArray[LET_NOT_EQUALS][LST_LIST][LST_LIST] = LST_INTEGER;
// LET_LESS_EQUALS
gSupportedExpressionArray[LET_LESS_EQUALS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_LESS_EQUALS][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_LESS_EQUALS][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_LESS_EQUALS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
// LET_GREATER_EQUALS
gSupportedExpressionArray[LET_GREATER_EQUALS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_GREATER_EQUALS][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_GREATER_EQUALS][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_GREATER_EQUALS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
// LET_LESS_THAN
gSupportedExpressionArray[LET_LESS_THAN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_LESS_THAN][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_LESS_THAN][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_LESS_THAN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
// LET_GREATER_THAN
gSupportedExpressionArray[LET_GREATER_THAN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_GREATER_THAN][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
gSupportedExpressionArray[LET_GREATER_THAN][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_GREATER_THAN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
// LET_PLUS
gSupportedExpressionArray[LET_PLUS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_PLUS][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_PLUS][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_PLUS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_PLUS][LST_STRING][LST_STRING] = LST_STRING;
gSupportedExpressionArray[LET_PLUS][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_PLUS][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_INTEGER] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_FLOATINGPOINT] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_STRING] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_KEY] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_VECTOR] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_QUATERNION] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_INTEGER][LST_LIST] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_FLOATINGPOINT][LST_LIST] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_STRING][LST_LIST] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_KEY][LST_LIST] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_VECTOR][LST_LIST] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_QUATERNION][LST_LIST] = LST_LIST;
gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_LIST] = LST_LIST;
// LET_MINUS
gSupportedExpressionArray[LET_MINUS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_MINUS][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_MINUS][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_MINUS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_MINUS][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_MINUS][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
// LET_TIMES
gSupportedExpressionArray[LET_TIMES][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_TIMES][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_TIMES][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_TIMES][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
gSupportedExpressionArray[LET_TIMES][LST_INTEGER][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
gSupportedExpressionArray[LET_TIMES][LST_FLOATINGPOINT][LST_VECTOR] = LST_VECTOR;
gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_VECTOR] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
gSupportedExpressionArray[LET_TIMES][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
// LET_DIVIDE
gSupportedExpressionArray[LET_DIVIDE][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_DIVIDE][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_DIVIDE][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_DIVIDE][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_DIVIDE][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
gSupportedExpressionArray[LET_DIVIDE][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
gSupportedExpressionArray[LET_DIVIDE][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
gSupportedExpressionArray[LET_DIVIDE][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
// LET_MOD
gSupportedExpressionArray[LET_MOD][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
gSupportedExpressionArray[LET_MOD][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
// LET_BIT_AND
gSupportedExpressionArray[LET_BIT_AND][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
// LET_BIT_OR
gSupportedExpressionArray[LET_BIT_OR][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
// LET_BIT_XOR
gSupportedExpressionArray[LET_BIT_XOR][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
// LET_BOOLEAN_AND
gSupportedExpressionArray[LET_BOOLEAN_AND][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
// LET_BOOLEAN_OR
gSupportedExpressionArray[LET_BOOLEAN_OR][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
// LET_SHIFT_LEFT
gSupportedExpressionArray[LET_SHIFT_LEFT][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
// LET_SHIFT_RIGHT
gSupportedExpressionArray[LET_SHIFT_RIGHT][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
// LET_PARENTHESIS
gSupportedExpressionArray[LET_PARENTHESIS][LST_INTEGER][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_PARENTHESIS][LST_FLOATINGPOINT][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_PARENTHESIS][LST_STRING][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_PARENTHESIS][LST_LIST][LST_NULL] = LST_INTEGER;
// LET_UNARY_MINUS
gSupportedExpressionArray[LET_UNARY_MINUS][LST_INTEGER][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_UNARY_MINUS][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
gSupportedExpressionArray[LET_UNARY_MINUS][LST_VECTOR][LST_NULL] = LST_VECTOR;
gSupportedExpressionArray[LET_UNARY_MINUS][LST_QUATERNION][LST_NULL] = LST_QUATERNION;
// LET_BOOLEAN_NOT
gSupportedExpressionArray[LET_BOOLEAN_NOT][LST_INTEGER][LST_NULL] = LST_INTEGER;
// LET_BIT_NOT
gSupportedExpressionArray[LET_BIT_NOT][LST_INTEGER][LST_NULL] = LST_INTEGER;
// LET_PRE_INCREMENT
gSupportedExpressionArray[LET_PRE_INCREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_PRE_INCREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
// LET_PRE_DECREMENT
gSupportedExpressionArray[LET_PRE_DECREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_PRE_DECREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
// LET_POST_INCREMENT
gSupportedExpressionArray[LET_POST_INCREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_POST_INCREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
// LET_POST_DECREMENT
gSupportedExpressionArray[LET_POST_DECREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
gSupportedExpressionArray[LET_POST_DECREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
}
BOOL legal_binary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTType right_side, LSCRIPTExpressionType expression)
{
if ( (left_side == LST_UNDEFINED)
||(right_side == LST_UNDEFINED))
{
result = LST_UNDEFINED;
return TRUE;
}
if ( (left_side == LST_NULL)
||(right_side == LST_NULL))
{
result = LST_UNDEFINED;
return FALSE;
}
result = gSupportedExpressionArray[expression][left_side][right_side];
if (result)
return TRUE;
else
{
result = LST_UNDEFINED;
return FALSE;
}
}
BOOL legal_unary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTExpressionType expression)
{
if (left_side == LST_UNDEFINED)
{
result = LST_UNDEFINED;
return TRUE;
}
if (left_side == LST_NULL)
{
result = LST_UNDEFINED;
return FALSE;
}
result = gSupportedExpressionArray[expression][left_side][LST_NULL];
if (result)
return TRUE;
else
{
result = LST_UNDEFINED;
return FALSE;
}
}

124
indra/lscript/lscript_compile/lscript_typecheck.h Normal file
View File

@@ -0,0 +1,124 @@
/**
* @file lscript_typecheck.h
* @brief typechecks script
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_TYPECHECK_H
#define LL_LSCRIPT_TYPECHECK_H
#include "lscript_error.h"
LSCRIPTType implicit_casts(LSCRIPTType left_side, LSCRIPTType right_side);
BOOL legal_casts(LSCRIPTType cast, LSCRIPTType base);
LSCRIPTType promote(LSCRIPTType left_side, LSCRIPTType right_side);
BOOL legal_assignment(LSCRIPTType left_side, LSCRIPTType right_side);
typedef enum e_lscript_expression_types
{
LET_NULL,
LET_ASSIGNMENT,
LET_ADD_ASSIGN,
LET_SUB_ASSIGN,
LET_MUL_ASSIGN,
LET_DIV_ASSIGN,
LET_MOD_ASSIGN,
LET_EQUALITY,
LET_NOT_EQUALS,
LET_LESS_EQUALS,
LET_GREATER_EQUALS,
LET_LESS_THAN,
LET_GREATER_THAN,
LET_PLUS,
LET_MINUS,
LET_TIMES,
LET_DIVIDE,
LET_MOD,
LET_BIT_AND,
LET_BIT_OR,
LET_BIT_XOR,
LET_BOOLEAN_AND,
LET_BOOLEAN_OR,
LET_PARENTHESIS,
LET_UNARY_MINUS,
LET_BOOLEAN_NOT,
LET_BIT_NOT,
LET_PRE_INCREMENT,
LET_PRE_DECREMENT,
LET_CAST,
LET_VECTOR_INITIALIZER,
LET_QUATERNION_INITIALIZER,
LET_LIST_INITIALIZER,
LET_LVALUE,
LET_POST_INCREMENT,
LET_POST_DECREMENT,
LET_FUNCTION_CALL,
LET_CONSTANT,
LET_FOR_EXPRESSION_LIST,
LET_FUNC_EXPRESSION_LIST,
LET_LIST_EXPRESSION_LIST,
LET_PRINT,
LET_SHIFT_LEFT,
LET_SHIFT_RIGHT,
LET_EOF
} LSCRIPTExpressionType;
BOOL legal_binary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTType right_side, LSCRIPTExpressionType expression);
BOOL legal_unary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTExpressionType expression);
void init_supported_expressions(void);
/*
LScript automatic type casting
LST_INTEGER -> LST_INTEGER
LST_FLOATINGPOINT -> LST_FLOATINGPOINT
LST_INTEGER -> LST_FLOATINGPOINT
LST_FLOATINGPOINT -> LST_STRING
LST_INTEGER -> LST_STRING
LST_STRING -> LST_STRING
LST_VECTOR -> LST_STRING
LST_QUATERNION -> LST_STRING
LST_LIST -> LST_STRING
LST_VECTOR -> LST_VECTOR
LST_QUATERNION -> LST_QUATERNION
LST_FLOATINGPOINT -> LST_LIST
LST_INTEGER -> LST_LIST
LST_STRING -> LST_LIST
LST_VECTOR -> LST_LIST
LST_QUATERNION -> LST_LIST
LST_LIST -> LST_LIST
*/
#endif

558
indra/lscript/lscript_execute.h Normal file
View File

@@ -0,0 +1,558 @@
/**
* @file lscript_execute.h
* @brief Classes to execute bytecode
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_EXECUTE_H
#define LL_LSCRIPT_EXECUTE_H
#include "lscript_byteconvert.h"
#include "linked_lists.h"
#include "lscript_library.h"
// Return values for run() methods
const U32 NO_DELETE_FLAG = 0x0000;
const U32 DELETE_FLAG = 0x0001;
const U32 CREDIT_MONEY_FLAG = 0x0002;
// list of op code execute functions
BOOL run_noop(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pop(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pops(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_popl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_popv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_popq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_poparg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_popip(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_popbp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_popsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_popslr(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_dup(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_dups(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_dupl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_dupv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_dupq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_store(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_stores(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storel(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storev(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storeq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storeg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storegs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storegl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storegv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_storegq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadlp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadvp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadqp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadgp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadgsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadglp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadgvp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_loadgqp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_push(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushgs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushgl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushgv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushgq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_puship(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushbp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushargb(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushargi(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushargf(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushargs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushargv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushargq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushe(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pushev(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pusheq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_pusharge(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_add(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_sub(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_mul(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_div(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_mod(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_eq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_neq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_leq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_geq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_less(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_greater(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_bitand(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_bitor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_bitxor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_booland(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_boolor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_shl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_shr(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_neg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_bitnot(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_boolnot(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_jump(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_jumpif(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_jumpnif(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_state(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_call(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_return(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_cast(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_stacktos(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_stacktol(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_print(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_calllib(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
BOOL run_calllib_two_byte(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
void unknown_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void integer_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void integer_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void integer_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void float_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void float_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void float_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void string_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void string_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void key_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void key_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void vector_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void vector_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void vector_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void vector_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void quaternion_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void integer_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void float_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void string_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void key_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void vector_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void quaternion_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void list_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void list_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void list_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void list_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void list_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void list_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void list_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode);
class LLScriptDataCollection
{
public:
LLScriptDataCollection(LSCRIPTStateEventType type, LLScriptLibData *data)
: mType(type), mData(data)
{
}
LLScriptDataCollection(U8 *src, S32 &offset)
{
S32 i, number;
mType = (LSCRIPTStateEventType)bytestream2integer(src, offset);
number = bytestream2integer(src, offset);
mData = new LLScriptLibData[number];
for (i = 0; i < number; i++)
{
mData[i].set(src, offset);
}
}
~LLScriptDataCollection()
{
delete [] mData;
mData = NULL;
}
S32 getSavedSize()
{
S32 size = 0;
// mTyoe
size += 4;
// number of entries
size += 4;
S32 i = 0;
do
{
size += mData[i].getSavedSize();;
}
while (mData[i++].mType != LST_NULL);
return size;
}
S32 write2bytestream(U8 *dest)
{
S32 offset = 0;
// mTyoe
integer2bytestream(dest, offset, mType);
// count number of entries
S32 number = 0;
while (mData[number++].mType != LST_NULL)
;
integer2bytestream(dest, offset, number);
// now the entries themselves
number = 0;
do
{
offset += mData[number].write2bytestream(dest + offset);
}
while (mData[number++].mType != LST_NULL);
return offset;
}
LSCRIPTStateEventType mType;
LLScriptLibData *mData;
};
const S32 MAX_EVENTS_IN_QUEUE = 64;
class LLScriptEventData
{
public:
LLScriptEventData() {}
LLScriptEventData(U8 *src, S32 &offset)
{
S32 i, number = bytestream2integer(src, offset);
for (i = 0; i < number; i++)
{
mEventDataList.addData(new LLScriptDataCollection(src, offset));
}
}
void set(U8 *src, S32 &offset)
{
S32 i, number = bytestream2integer(src, offset);
for (i = 0; i < number; i++)
{
mEventDataList.addData(new LLScriptDataCollection(src, offset));
}
}
~LLScriptEventData()
{
mEventDataList.deleteAllData();
}
void addEventData(LLScriptDataCollection *data)
{
if (mEventDataList.getLength() < MAX_EVENTS_IN_QUEUE)
mEventDataList.addDataAtEnd(data);
else
delete data;
}
LLScriptDataCollection *getNextEvent(LSCRIPTStateEventType type)
{
LLScriptDataCollection *temp;
for (temp = mEventDataList.getFirstData();
temp;
temp = mEventDataList.getNextData())
{
if (temp->mType == type)
{
mEventDataList.removeCurrentData();
return temp;
}
}
return NULL;
}
LLScriptDataCollection *getNextEvent()
{
LLScriptDataCollection *temp;
temp = mEventDataList.getFirstData();
if (temp)
{
mEventDataList.removeCurrentData();
return temp;
}
return NULL;
}
void removeEventType(LSCRIPTStateEventType type)
{
LLScriptDataCollection *temp;
for (temp = mEventDataList.getFirstData();
temp;
temp = mEventDataList.getNextData())
{
if (temp->mType == type)
{
mEventDataList.deleteCurrentData();
}
}
}
S32 getSavedSize()
{
S32 size = 0;
// number in linked list
size += 4;
LLScriptDataCollection *temp;
for (temp = mEventDataList.getFirstData();
temp;
temp = mEventDataList.getNextData())
{
size += temp->getSavedSize();
}
return size;
}
S32 write2bytestream(U8 *dest)
{
S32 offset = 0;
// number in linked list
S32 number = mEventDataList.getLength();
integer2bytestream(dest, offset, number);
LLScriptDataCollection *temp;
for (temp = mEventDataList.getFirstData();
temp;
temp = mEventDataList.getNextData())
{
offset += temp->write2bytestream(dest + offset);
}
return offset;
}
LLLinkedList<LLScriptDataCollection> mEventDataList;
};
class LLScriptExecute
{
public:
LLScriptExecute();
virtual ~LLScriptExecute() {;}
virtual S32 getVersion() const = 0;
virtual void deleteAllEvents() = 0;
virtual void addEvent(LLScriptDataCollection* event) = 0;
virtual U32 getEventCount() = 0;
virtual void removeEventType(LSCRIPTStateEventType event_type) = 0;
virtual S32 getFaults() = 0;
virtual void setFault(LSCRIPTRunTimeFaults fault) = 0;
virtual U32 getFreeMemory() = 0;
virtual S32 getParameter() = 0;
virtual void setParameter(S32 value) = 0;
virtual F32 getSleep() const = 0;
virtual void setSleep(F32 value) = 0;
virtual F32 getEnergy() const = 0;
virtual void setEnergy(F32 value) = 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.
virtual U32 getEventsSavedSize() = 0; // Returns 0 if events are written with state.
virtual S32 writeEvents(U8 *dest) = 0; // Must write and return exactly the number of bytes returned by getEventsSavedSize.
virtual void readEvents(U8* src, S32& offset) = 0;
virtual S32 readState(U8 *src) = 0; // Returns number of bytes read.
virtual void reset();
virtual const U8* getBytecode() const = 0;
virtual U32 getBytecodeSize() const = 0;
virtual bool isMono() const = 0;
virtual void error() {;} // Processing that must be performed when error flag is set and so run is not called.
virtual U32 getUsedMemory() = 0;
// Run current event handler for a maximum of time_slice seconds.
// Updates current handler and current events registers.
virtual void resumeEventHandler(BOOL b_print, 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.
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, 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, const LLUUID &id, F32 time_slice) = 0;
// Switch to next state.
// Returns new set of handled events.
virtual U64 nextState() = 0;
// Returns time taken.
virtual F32 runQuanta(BOOL b_print, const LLUUID &id,
const char **errorstr,
F32 quanta,
U32& events_processed, LLTimer& timer);
// NOTE: babbage: this must be used on occasions where another script may already be executing. Only 2 levels of nesting are allowed.
// Provided to support bizarre detach behaviour only. Do not use.
virtual F32 runNested(BOOL b_print, const LLUUID &id,
const char **errorstr,
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,
U32& events_processed,
F32 quanta);
bool isYieldDue() const;
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;
// A timer is regularly checked to see if script takes too long, but we
// don't do it every opcode due to performance hits.
static void setTimerCheckSkip( S32 value ) { sTimerCheckSkip = value; }
static S32 getTimerCheckSkip() { return sTimerCheckSkip; }
private:
BOOL mReset;
static S32 sTimerCheckSkip; // Number of times to skip the timer check for performance reasons
};
class LLScriptExecuteLSL2 : public LLScriptExecute
{
public:
LLScriptExecuteLSL2(LLFILE *fp);
LLScriptExecuteLSL2(const U8* bytecode, U32 bytecode_size);
virtual ~LLScriptExecuteLSL2();
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();}
virtual void removeEventType(LSCRIPTStateEventType event_type);
virtual S32 getFaults() {return get_register(mBuffer, LREG_FR);}
virtual void setFault(LSCRIPTRunTimeFaults fault) {set_fault(mBuffer, fault);}
virtual U32 getFreeMemory();
virtual S32 getParameter();
virtual void setParameter(S32 value);
virtual F32 getSleep() const;
virtual void setSleep(F32 value);
virtual F32 getEnergy() const;
virtual void setEnergy(F32 value);
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.
virtual U32 getEventsSavedSize() {return mEventData.getSavedSize();}
virtual S32 writeEvents(U8 *dest) {return mEventData.write2bytestream(dest);}
virtual void readEvents(U8* src, S32& offset) {mEventData.set(src, offset);}
virtual S32 writeBytecode(U8 **dest);
virtual S32 readState(U8 *src);
virtual void reset();
virtual const U8* getBytecode() const {return mBytecode;}
virtual U32 getBytecodeSize() const {return mBytecodeSize;}
virtual bool isMono() const {return false;}
virtual U32 getUsedMemory();
// Run current event handler for a maximum of time_slice seconds.
// Updates current handler and current events registers.
virtual void resumeEventHandler(BOOL b_print, const LLUUID &id, F32 time_slice);
// Run handler for event for a maximum of time_slice seconds.
// Updates current handler and current events registers.
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, 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, const LLUUID &id, F32 time_slice);
// Switch to next state.
// Returns new set of handled events.
virtual U64 nextState();
void init();
BOOL (*mExecuteFuncs[0x100])(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id);
U32 mInstructionCount;
U8 *mBuffer;
LLScriptEventData mEventData;
U8* mBytecode; // Initial state and bytecode.
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

41
indra/lscript/lscript_execute/CMakeLists.txt Normal file
View File

@@ -0,0 +1,41 @@
# -*- cmake -*-
include(00-Common)
include(LLCommon)
include(LLMath)
include(LScript)
include_directories(
${LLCOMMON_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LSCRIPT_INCLUDE_DIRS}
)
set(lscript_execute_SOURCE_FILES
llscriptresource.cpp
llscriptresourceconsumer.cpp
llscriptresourcepool.cpp
lscript_execute.cpp
lscript_heapruntime.cpp
lscript_readlso.cpp
)
set(lscript_execute_HEADER_FILES
CMakeLists.txt
../llscriptresource.h
../llscriptresourceconsumer.h
../llscriptresourcepool.h
../lscript_execute.h
../lscript_rt_interface.h
lscript_heapruntime.h
lscript_readlso.h
)
set_source_files_properties(${lscript_execute_HEADER_FILES}
PROPERTIES HEADER_FILE_ONLY TRUE)
list(APPEND lscript_execute_SOURCE_FILES ${lscript_execute_HEADER_FILES})
add_library (lscript_execute ${lscript_execute_SOURCE_FILES})
add_dependencies(lscript_execute prepare)

97
indra/lscript/lscript_execute/llscriptresource.cpp Normal file
View File

@@ -0,0 +1,97 @@
/**
* @file llscriptresource.cpp
* @brief LLScriptResource class implementation for managing limited resources
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llscriptresource.h"
#include "llerror.h"
LLScriptResource::LLScriptResource()
: mTotal(0),
mUsed(0)
{
}
bool LLScriptResource::request(S32 amount /* = 1 */)
{
if (mUsed + amount <= mTotal)
{
mUsed += amount;
return true;
}
return false;
}
bool LLScriptResource::release(S32 amount /* = 1 */)
{
if (mUsed >= amount)
{
mUsed -= amount;
return true;
}
return false;
}
S32 LLScriptResource::getAvailable() const
{
if (mUsed > mTotal)
{
// It is possible after a parcel ownership change for more than total to be used
// In this case the user of this class just wants to know
// whether or not they can use a resource
return 0;
}
return (mTotal - mUsed);
}
void LLScriptResource::setTotal(S32 amount)
{
// This may cause this resource to be over spent
// such that more are in use than total allowed
// Until those resources are released getAvailable will return 0.
mTotal = amount;
}
S32 LLScriptResource::getTotal() const
{
return mTotal;
}
S32 LLScriptResource::getUsed() const
{
return mUsed;
}
bool LLScriptResource::isOverLimit() const
{
return (mUsed > mTotal);
}

112
indra/lscript/lscript_execute/llscriptresourceconsumer.cpp Normal file
View File

@@ -0,0 +1,112 @@
/**
* @file llscriptresourceconsumer.cpp
* @brief An interface for a script resource consumer.
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llscriptresourceconsumer.h"
#include "llscriptresourcepool.h"
LLScriptResourceConsumer::LLScriptResourceConsumer()
: mScriptResourcePool(&LLScriptResourcePool::null)
{ }
// Get the resource pool this consumer is currently using.
// virtual
LLScriptResourcePool& LLScriptResourceConsumer::getScriptResourcePool()
{
return *mScriptResourcePool;
}
// Get the resource pool this consumer is currently using.
// virtual
const LLScriptResourcePool& LLScriptResourceConsumer::getScriptResourcePool() const
{
return *mScriptResourcePool;
}
// virtual
void LLScriptResourceConsumer::setScriptResourcePool(LLScriptResourcePool& new_pool)
{
mScriptResourcePool = &new_pool;
}
bool LLScriptResourceConsumer::switchScriptResourcePools(LLScriptResourcePool& new_pool)
{
if (&new_pool == &LLScriptResourcePool::null)
{
llwarns << "New pool is null" << llendl;
}
if (isInPool(new_pool))
{
return true;
}
if (!canUseScriptResourcePool(new_pool))
{
return false;
}
S32 used_urls = getUsedPublicURLs();
getScriptResourcePool().getPublicURLResource().release( used_urls );
setScriptResourcePool(new_pool);
getScriptResourcePool().getPublicURLResource().request( used_urls );
return true;
}
bool LLScriptResourceConsumer::canUseScriptResourcePool(const LLScriptResourcePool& resource_pool)
{
if (isInPool(resource_pool))
{
return true;
}
if (resource_pool.getPublicURLResource().getAvailable() < getUsedPublicURLs())
{
return false;
}
return true;
}
bool LLScriptResourceConsumer::isInPool(const LLScriptResourcePool& resource_pool)
{
const LLScriptResourcePool& current_pool = getScriptResourcePool();
if ( &resource_pool == &current_pool )
{
// This consumer is already in this pool
return true;
}
return false;
}

50
indra/lscript/lscript_execute/llscriptresourcepool.cpp Normal file
View File

@@ -0,0 +1,50 @@
/**
* @file llscriptresourcepool.cpp
* @brief Collection of limited script resources
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llscriptresourcepool.h"
LLScriptResourcePool LLScriptResourcePool::null;
LLScriptResourcePool::LLScriptResourcePool()
{
}
LLScriptResource& LLScriptResourcePool::getPublicURLResource()
{
return mLSLPublicURLs;
}
const LLScriptResource& LLScriptResourcePool::getPublicURLResource() const
{
return mLSLPublicURLs;
}

4376
indra/lscript/lscript_execute/lscript_execute.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

525
indra/lscript/lscript_execute/lscript_heapruntime.cpp Normal file
View File

@@ -0,0 +1,525 @@
/**
* @file lscript_heapruntime.cpp
* @brief classes to manage script heap at runtime
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#if 0
#include "linden_common.h"
#include "lscript_heapruntime.h"
#include "lscript_execute.h"
/*
String Heap Format
Byte Description
0x0 - 0xnn Single byte string including null terminator
List Heap Format
Byte Description
0x0 Next Entry Type
0: End of list
1: Integer
2: Floating point
3: String
4: Vector
5: Quaternion
6: List
0x1 - 0x4 Integer, Floating Point, String Address, List Address
or
0x1 - 0xd Vector
or
0x1 - 0x11 Quaternion
. . .
Heap Block Format
Byte Description
0x0 - 0x3 Offset to Next Block
0x4 - 0x7 Object Reference Count
0x8 Block Type
0: Empty
3: String
6: List
0x9 - 0xM Object Data
Heap Management
Adding Data
1) Set last empty spot to zero.
2) Go to start of the heap (HR).
3) Get next 4 bytes of offset.
4) If zero, we've reached the end of used memory. If empty spot is zero go to step 9. Otherwise set base offset to 0 and go to step 9.
5) Skip 4 bytes.
6) Get next 1 byte of entry type.
7) If zero, this spot is empty. If empty spot is zero, set empty spot to this address and go to step 9. Otherwise, coalesce with last empty spot and then go to step 9.
8) Skip forward by offset and go to step 3.
9) If the spot is empty, check to see if the size needed == offset - 9.
10) If it does, let's drop our data into this spot. Set reference count to 1. Set entry type appropriately and copy the data in.
11) If size needed < offset - 9 then we can stick in data and add in an empty block.
12) Otherwise, we need to keep looking. Go to step 3.
Increasing reference counts
Decreasing reference counts
1) Set entry type to 0.
2) If offset is non-zero and the next entry is empty, coalesce. Go to step 2.
What increases reference count:
Initial creation sets reference count to 1.
Storing the reference increases reference count by 1.
Pushing the reference increases reference count by 1.
Duplicating the reference increases reference count by 1.
What decreases the reference count:
Popping the reference decreases reference count by 1.
*/
LLScriptHeapRunTime::LLScriptHeapRunTime()
: mLastEmpty(0), mBuffer(NULL), mCurrentPosition(0), mStackPointer(0), mHeapRegister(0), mbPrint(FALSE)
{
}
LLScriptHeapRunTime::~LLScriptHeapRunTime()
{
}
S32 LLScriptHeapRunTime::addData(char *string)
{
if (!mBuffer)
return 0;
S32 size = strlen(string) + 1;
S32 block_offset = findOpenBlock(size + HEAP_BLOCK_HEADER_SIZE);
if (mCurrentPosition)
{
S32 offset = mCurrentPosition;
if (offset + block_offset + HEAP_BLOCK_HEADER_SIZE + LSCRIPTDataSize[LST_INTEGER] >= mStackPointer)
{
set_fault(mBuffer, LSRF_STACK_HEAP_COLLISION);
return 0;
}
// cool, we've found a spot!
// set offset
integer2bytestream(mBuffer, offset, block_offset);
// set reference count
integer2bytestream(mBuffer, offset, 1);
// set type
*(mBuffer + offset++) = LSCRIPTTypeByte[LST_STRING];
// plug in data
char2bytestream(mBuffer, offset, string);
if (mbPrint)
printf("0x%X created ref count %d\n", mCurrentPosition - mHeapRegister, 1);
// now, zero out next offset to prevent "trouble"
// offset = mCurrentPosition + size + HEAP_BLOCK_HEADER_SIZE;
// integer2bytestream(mBuffer, offset, 0);
}
return mCurrentPosition;
}
S32 LLScriptHeapRunTime::addData(U8 *list)
{
if (!mBuffer)
return 0;
return 0;
}
S32 LLScriptHeapRunTime::catStrings(S32 address1, S32 address2)
{
if (!mBuffer)
return 0;
S32 dataaddress1 = address1 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;
S32 dataaddress2 = address2 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;
S32 toffset1 = dataaddress1;
safe_heap_bytestream_count_char(mBuffer, toffset1);
S32 toffset2 = dataaddress2;
safe_heap_bytestream_count_char(mBuffer, toffset2);
// calculate new string size
S32 size1 = toffset1 - dataaddress1;
S32 size2 = toffset2 - dataaddress2;
S32 newbuffer = size1 + size2 - 1;
char *temp = new char[newbuffer];
// get the strings
bytestream2char(temp, mBuffer, dataaddress1);
bytestream2char(temp + size1 - 1, mBuffer, dataaddress2);
decreaseRefCount(address1);
decreaseRefCount(address2);
S32 retaddress = addData(temp);
return retaddress;
}
S32 LLScriptHeapRunTime::cmpStrings(S32 address1, S32 address2)
{
if (!mBuffer)
return 0;
S32 dataaddress1 = address1 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;
S32 dataaddress2 = address2 + 2*LSCRIPTDataSize[LST_INTEGER] + 1;
S32 toffset1 = dataaddress1;
safe_heap_bytestream_count_char(mBuffer, toffset1);
S32 toffset2 = dataaddress2;
safe_heap_bytestream_count_char(mBuffer, toffset2);
// calculate new string size
S32 size1 = toffset1 - dataaddress1;
S32 size2 = toffset2 - dataaddress2;
if (size1 != size2)
{
return llmin(size1, size2);
}
else
{
return strncmp((char *)(mBuffer + dataaddress1), (char *)(mBuffer + dataaddress2), size1);
}
}
void LLScriptHeapRunTime::removeData(S32 address)
{
if (!mBuffer)
return;
S32 toffset = address;
// read past offset (relying on function side effect
bytestream2integer(mBuffer, toffset);
// make sure that reference count is 0
integer2bytestream(mBuffer, toffset, 0);
// show the block as empty
*(mBuffer + toffset) = 0;
// now, clean up the heap
S32 clean = mHeapRegister;
S32 tclean;
S32 clean_offset;
S32 nclean;
S32 tnclean;
S32 next_offset;
U8 type;
U8 ntype;
for(;;)
{
tclean = clean;
clean_offset = bytestream2integer(mBuffer, tclean);
// is this block, empty?
tclean += LSCRIPTDataSize[LST_INTEGER];
type = *(mBuffer + tclean);
if (!clean_offset)
{
if (!type)
{
// we're done! if our block is empty, we can pull in the HP and zero out our offset
set_register(mBuffer, LREG_HP, clean);
}
return;
}
if (!type)
{
// if we're empty, try to coalesce with the next one
nclean = clean + clean_offset;
tnclean = nclean;
next_offset = bytestream2integer(mBuffer, tnclean);
tnclean += LSCRIPTDataSize[LST_INTEGER];
ntype = *(mBuffer + tnclean);
if (!next_offset)
{
// we're done! if our block is empty, we can pull in the HP and zero out our offset
tclean = clean;
integer2bytestream(mBuffer, tclean, 0);
set_register(mBuffer, LREG_HP, clean);
return;
}
if (!ntype)
{
// hooray! we can coalesce
tclean = clean;
integer2bytestream(mBuffer, tclean, clean_offset + next_offset);
// don't skip forward so that we can keep coalescing on next pass through the loop
}
else
{
clean += clean_offset;
}
}
else
{
// if not, move on to the next block
clean += clean_offset;
}
}
}
void LLScriptHeapRunTime::coalesce(S32 address1, S32 address2)
{
// we need to bump the base offset by the second block's
S32 toffset = address1;
S32 offset1 = bytestream2integer(mBuffer, toffset);
offset1 += bytestream2integer(mBuffer, address2);
integer2bytestream(mBuffer, address1, offset1);
}
void LLScriptHeapRunTime::split(S32 address1, S32 size)
{
S32 toffset = address1;
S32 oldoffset = bytestream2integer(mBuffer, toffset);
// add new offset and zero out reference count and block used
S32 newoffset = oldoffset - size;
S32 newblockpos = address1 + size;
// set new offset
integer2bytestream(mBuffer, newblockpos, newoffset);
// zero out reference count
integer2bytestream(mBuffer, newblockpos, 0);
// mark as empty
*(mBuffer + newblockpos) = 0;
// now, change the offset of the original block
integer2bytestream(mBuffer, address1, size + HEAP_BLOCK_HEADER_SIZE);
}
/*
For reference count changes, strings are easy. For lists, we'll need to go through the lists reducing
the reference counts for any included strings and lists
*/
void LLScriptHeapRunTime::increaseRefCount(S32 address)
{
if (!mBuffer)
return;
if (!address)
{
// unused temp string entry
return;
}
// get current reference count
S32 toffset = address + 4;
S32 count = bytestream2integer(mBuffer, toffset);
count++;
if (mbPrint)
printf("0x%X inc ref count %d\n", address - mHeapRegister, count);
// see which type it is
U8 type = *(mBuffer + toffset);
if (type == LSCRIPTTypeByte[LST_STRING])
{
toffset = address + 4;
integer2bytestream(mBuffer, toffset, count);
}
// TO DO: put list stuff here!
else
{
set_fault(mBuffer, LSRF_HEAP_ERROR);
}
}
void LLScriptHeapRunTime::decreaseRefCount(S32 address)
{
if (!mBuffer)
return;
if (!address)
{
// unused temp string entry
return;
}
// get offset
S32 toffset = address;
// read past offset (rely on function side effect)
bytestream2integer(mBuffer, toffset);
// get current reference count
S32 count = bytestream2integer(mBuffer, toffset);
// see which type it is
U8 type = *(mBuffer + toffset);
if (type == LSCRIPTTypeByte[LST_STRING])
{
count--;
if (mbPrint)
printf("0x%X dec ref count %d\n", address - mHeapRegister, count);
toffset = address + 4;
integer2bytestream(mBuffer, toffset, count);
if (!count)
{
// we can blow this one away
removeData(address);
}
}
// TO DO: put list stuff here!
else
{
set_fault(mBuffer, LSRF_HEAP_ERROR);
}
}
// if we're going to assign a variable, we need to decrement the reference count of what we were pointing at (if anything)
void LLScriptHeapRunTime::releaseLocal(S32 address)
{
S32 hr = get_register(mBuffer, LREG_HR);
address = lscript_local_get(mBuffer, address);
if ( (address >= hr)
&&(address < hr + get_register(mBuffer, LREG_HP)))
{
decreaseRefCount(address);
}
}
void LLScriptHeapRunTime::releaseGlobal(S32 address)
{
// NOTA BENE: Global strings are referenced relative to the HR while local strings aren't
S32 hr = get_register(mBuffer, LREG_HR);
address = lscript_global_get(mBuffer, address) + hr;
if ( (address >= hr)
&&(address < hr + get_register(mBuffer, LREG_HP)))
{
decreaseRefCount(address);
}
}
// we know the following function has "unreachable code"
// don't remind us every friggin' time we compile. . .
#if defined(_MSC_VER)
# pragma warning(disable: 4702) // unreachable code
#endif
S32 LLScriptHeapRunTime::findOpenBlock(S32 size)
{
S32 offset;
S32 toffset;
U8 blocktype;
while(1)
{
if (mCurrentPosition + size >= mStackPointer)
{
set_fault(mBuffer, LSRF_STACK_HEAP_COLLISION);
mCurrentPosition = 0;
}
toffset = mCurrentPosition;
offset = bytestream2integer(mBuffer, toffset);
if (!offset)
{
// we've reached the end of Heap, return this location if we'll fit
// do we need to coalesce with last empty space?
if (mLastEmpty)
{
// ok, that everything from mLastEmpty to us is empty, so we don't need a block
// zero out the last empty's offset and return it
mCurrentPosition = mLastEmpty;
integer2bytestream(mBuffer, mLastEmpty, 0);
mLastEmpty = 0;
}
// now, zero out next offset to prevent "trouble"
offset = mCurrentPosition + size;
integer2bytestream(mBuffer, offset, 0);
// set HP to appropriate value
set_register(mBuffer, LREG_HP, mCurrentPosition + size);
return size;
}
// ok, is this slot empty?
toffset += LSCRIPTDataSize[LST_INTEGER];
blocktype = *(mBuffer + toffset++);
if (!blocktype)
{
// Empty block, do we need to coalesce?
if (mLastEmpty)
{
coalesce(mLastEmpty, mCurrentPosition);
mCurrentPosition = mLastEmpty;
toffset = mCurrentPosition;
offset = bytestream2integer(mBuffer, toffset);
}
// do we fit in this block?
if (offset >= size)
{
// do we need to split the block? (only split if splitting will leave > HEAP_BLOCK_SPLIT_THRESHOLD bytes of free space)
if (offset - HEAP_BLOCK_SPLIT_THRESHOLD >= size)
{
split(mCurrentPosition, size);
return size;
}
else
return offset;
}
}
// nothing found, keep looking
mCurrentPosition += offset;
}
// fake return to prevent warnings
mCurrentPosition = 0;
return 0;
}
LLScriptHeapRunTime gRunTime;
#endif

46
indra/lscript/lscript_execute/lscript_heapruntime.h Normal file
View File

@@ -0,0 +1,46 @@
/**
* @file lscript_heapruntime.h
* @brief classes to manage script heap at runtime
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#if 0
#ifndef LL_LSCRIPT_HEAPRUNTIME_H
#define LL_LSCRIPT_HEAPRUNTIME_H
#include "lscript_byteconvert.h"
const S32 HEAP_BLOCK_HEADER_SIZE = 9;
const S32 HEAP_BLOCK_SPLIT_THRESHOLD = 16;
#endif
#endif

1594
indra/lscript/lscript_execute/lscript_readlso.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

171
indra/lscript/lscript_execute/lscript_readlso.h Normal file
View File

@@ -0,0 +1,171 @@
/**
* @file lscript_readlso.h
* @brief classes to read lso file
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_READLSO_H
#define LL_LSCRIPT_READLSO_H
#include "lscript_byteconvert.h"
#include "linked_lists.h"
// list of op code print functions
void print_noop(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pop(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pops(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_popl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_popv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_popq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_poparg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_popip(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_popbp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_popsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_popslr(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_dup(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_dups(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_dupl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_dupv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_dupq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_store(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_stores(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storel(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storev(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storeq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storeg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storegs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storegl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storegv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_storegq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadlp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadvp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadqp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadgp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadgsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadglp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadgvp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_loadgqp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_push(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushgl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushgs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushgv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushgq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_puship(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushbp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushargb(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushargi(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushargf(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushargs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushargv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushargq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushe(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pushev(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pusheq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_pusharge(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_add(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_sub(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_mul(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_div(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_mod(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_eq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_neq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_leq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_geq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_less(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_greater(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_bitand(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_bitor(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_bitxor(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_booland(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_boolor(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_shl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_shr(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_neg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_bitnot(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_boolnot(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_jump(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_jumpif(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_jumpnif(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_state(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_call(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_return(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_cast(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_stacktos(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_stacktol(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_print(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_calllib(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
void print_calllib_two_byte(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
class LLScriptLSOParse
{
public:
LLScriptLSOParse(LLFILE *fp);
LLScriptLSOParse(U8 *buffer);
~LLScriptLSOParse();
void initOpCodePrinting();
void printData(LLFILE *fp);
void printNameDesc(LLFILE *fp);
void printRegisters(LLFILE *fp);
void printGlobals(LLFILE *fp);
void printGlobalFunctions(LLFILE *fp);
void printStates(LLFILE *fp);
void printHeap(LLFILE *fp);
void printOpCodes(LLFILE *fp, S32 &offset, S32 tabs);
void printOpCodeRange(LLFILE *fp, S32 start, S32 end, S32 tabs);
U8 *mRawData;
void (*mPrintOpCodes[0x100])(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs);
};
void lso_print_tabs(LLFILE *fp, S32 tabs);
#endif

85
indra/lscript/lscript_execute_mono/assembly.cpp Normal file
View File

@@ -0,0 +1,85 @@
/**
* @file llassembly.cpp
* @brief keeps track of user scripts, ensures that only one copy exists for each
*
* $LicenseInfo:firstyear=2007&license=viewergpl$
*
* Copyright (c) 2007-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llassembly.h"
#include <map>
static std::map<std::string, LLAssembly*> sAssemblyMap;
boost::intrusive_ptr<LLAssembly> LLAssembly::create(const std::string& name,
const U8* buffer, U32 size)
{
std::map<std::string, LLAssembly*>::iterator it = sAssemblyMap.find(name);
if (it != sAssemblyMap.end())
{
return it->second;
}
else
{
LLAssembly* a = new LLAssembly(name, buffer, size);
sAssemblyMap[name] = a;
return a;
}
}
LLAssembly::LLAssembly(const std::string &name, const U8* buffer, U32 size) :
mName(name), mRefCount(0), mBuffer(buffer, buffer+size)
{
}
LLAssembly::~LLAssembly()
{
std::map<std::string, LLAssembly*>::iterator it = sAssemblyMap.find(mName);
if (it != sAssemblyMap.end())
{
sAssemblyMap.erase(it);
}
}
void intrusive_ptr_add_ref(LLAssembly* p)
{
++(p->mRefCount);
}
void intrusive_ptr_release(LLAssembly* p)
{
if (0 == --(p->mRefCount))
{
delete p;
}
}

193
indra/lscript/lscript_execute_mono/size.cpp Normal file
View File

@@ -0,0 +1,193 @@
/**
* NOTE: none of this actually applies as this file was taken from mono/samples
* @file size.c
* @brief file from mono samples
*
* $LicenseInfo:firstyear=2007&license=viewergpl$
*
* Copyright (c) 2007-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include <glib.h>
#include <mono/jit/jit.h>
#include <mono/metadata/environment.h>
#include <mono/metadata/profiler.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/llassembly.h>
#include <string.h>
#include "stdtypes.h"
#include "linden_common.h"
#define FIELD_ATTRIBUTE_STATIC 0x10
#define FIELD_ATTRIBUTE_HAS_FIELD_RVA 0x100
static int memory_usage (MonoObject *obj, GHashTable *visited,
int (*functor)(MonoObject*, MonoType*, int));
static int
memory_usage_array (MonoArray *array, GHashTable *visited,
int (*functor)(MonoObject*, MonoType*, int))
{
int total = 0;
MonoClass *array_class = mono_object_get_class ((MonoObject *) array);
MonoClass *element_class = mono_class_get_element_class (array_class);
MonoType *element_type = mono_class_get_type (element_class);
if (MONO_TYPE_IS_REFERENCE (element_type)) {
int i;
for (i = 0; i < mono_array_length (array); i++) {
MonoObject *element = (MonoObject*)mono_array_get (array, gpointer, i);
if (element != NULL)
total += memory_usage (element, visited, functor);
}
}
return total;
}
static int
memory_usage (MonoObject *obj, GHashTable *visited,
int (*functor)(MonoObject*, MonoType*, int))
{
int total = 0;
MonoClass *klass;
MonoType *type;
gpointer iter = NULL;
MonoClassField *field;
if (g_hash_table_lookup (visited, obj))
return 0;
g_hash_table_insert (visited, obj, obj);
klass = mono_object_get_class (obj);
type = mono_class_get_type (klass);
/* This is an array, so drill down into it */
if (type->type == MONO_TYPE_SZARRAY)
total += memory_usage_array ((MonoArray *) obj, visited, functor);
while ((field = mono_class_get_fields (klass, &iter)) != NULL) {
MonoType *ftype = mono_field_get_type (field);
gpointer value;
if ((ftype->attrs & (FIELD_ATTRIBUTE_STATIC | FIELD_ATTRIBUTE_HAS_FIELD_RVA)) != 0)
continue;
/* FIXME: There are probably other types we need to drill down into */
switch (ftype->type) {
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
mono_field_get_value (obj, field, &value);
if (value != NULL)
total += memory_usage ((MonoObject *) value, visited, functor);
break;
case MONO_TYPE_STRING:
mono_field_get_value (obj, field, &value);
if (value != NULL)
total += mono_object_get_size ((MonoObject *) value);
break;
case MONO_TYPE_SZARRAY:
mono_field_get_value (obj, field, &value);
if (value != NULL) {
total += memory_usage_array ((MonoArray *) value, visited, functor);
total += mono_object_get_size ((MonoObject *) value);
}
break;
default:
/* printf ("Got type 0x%x\n", ftype->type); */
/* ignore, this will be included in mono_object_get_size () */
break;
}
}
total = functor(obj, type, total);
return total;
}
int addObjectSize(MonoObject* obj, MonoType* type, int total)
{
return total + mono_object_get_size (obj);
}
/*
* Only returns data for instances, not for static fields, those might
* be larger, or hold larger structures
*/
int
GetMemoryUsage (MonoObject *obj)
{
GHashTable *visited = g_hash_table_new (NULL, NULL);
int n;
n = memory_usage (obj, visited, addObjectSize);
g_hash_table_destroy (visited);
return n;
}
int printObjectSize(MonoObject* obj, MonoType* type, int total)
{
total += mono_object_get_size (obj);
llinfos << "Object type: " << mono_type_full_name(type) << " size: "
<< total << llendl;
return total;
}
/*
* Only returns data for instances, not for static fields, those might
* be larger, or hold larger structures
*/
int
PrintMemoryUsage (MonoObject *obj)
{
GHashTable *visited = g_hash_table_new (NULL, NULL);
int n;
n = memory_usage (obj, visited, printObjectSize);
g_hash_table_destroy (visited);
return n;
}

40
indra/lscript/lscript_export.h Normal file
View File

@@ -0,0 +1,40 @@
/**
* @file lscript_export.h
* @brief Export interface class
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_EXPORT_H
#define LL_LSCRIPT_EXPORT_H
#include "lscript_library.h"
extern LLScriptLibrary gScriptLibrary;
#endif

51
indra/lscript/lscript_http.h Normal file
View File

@@ -0,0 +1,51 @@
/**
* @file lscript_http.h
* @brief LSL HTTP keys
*
* $LicenseInfo:firstyear=2006&license=viewergpl$
*
* Copyright (c) 2006-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
// Keys used in LSL HTTP function <key,value> pair lists.
#ifndef LSCRIPT_HTTP_H
#define LSCRIPT_HTTP_H
enum LLScriptHTTPRequestParameterKey
{
HTTP_METHOD,
HTTP_MIMETYPE,
HTTP_BODY_MAXLENGTH,
HTTP_VERIFY_CERT
};
enum LLScriptHTTPResponseMetadataKey
{
HTTP_BODY_TRUNCATED
};
#endif

431
indra/lscript/lscript_library.h Normal file
View File

@@ -0,0 +1,431 @@
/**
* @file lscript_library.h
* @brief External library interface
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_LIBRARY_H
#define LL_LSCRIPT_LIBRARY_H
#include "lscript_byteformat.h"
#include "v3math.h"
#include "llquaternion.h"
#include "lluuid.h"
#include "lscript_byteconvert.h"
class LLScriptLibData;
class LLScriptLibraryFunction
{
public:
LLScriptLibraryFunction(F32 eu, F32 st, void (*exec_func)(LLScriptLibData *, LLScriptLibData *, const LLUUID &), const char *name, const char *ret_type, const char *args, BOOL god_only = FALSE);
~LLScriptLibraryFunction();
F32 mEnergyUse;
F32 mSleepTime;
void (*mExecFunc)(LLScriptLibData *, LLScriptLibData *, const LLUUID &);
const char *mName;
const char *mReturnType;
const char *mArgs;
BOOL mGodOnly;
};
class LLScriptLibrary
{
public:
LLScriptLibrary();
~LLScriptLibrary();
void init();
void addFunction(F32 eu, F32 st, void (*exec_func)(LLScriptLibData *, LLScriptLibData *, const LLUUID &), const char *name, const char *ret_type, const char *args, BOOL god_only = FALSE);
void assignExec(const char *name, void (*exec_func)(LLScriptLibData *, LLScriptLibData *, const LLUUID &));
std::vector<LLScriptLibraryFunction> mFunctions;
};
extern LLScriptLibrary gScriptLibrary;
class LLScriptLibData
{
public:
// TODO: Change this to a union
LSCRIPTType mType;
S32 mInteger;
F32 mFP;
char *mKey;
char *mString;
LLVector3 mVec;
LLQuaternion mQuat;
LLScriptLibData *mListp;
friend bool operator<=(const LLScriptLibData &a, const LLScriptLibData &b)
{
if (a.mType == b.mType)
{
if (a.mType == LST_INTEGER)
{
return a.mInteger <= b.mInteger;
}
if (a.mType == LST_FLOATINGPOINT)
{
return a.mFP <= b.mFP;
}
if (a.mType == LST_STRING)
{
return strcmp(a.mString, b.mString) <= 0;
}
if (a.mType == LST_KEY)
{
return strcmp(a.mKey, b.mKey) <= 0;
}
if (a.mType == LST_VECTOR)
{
return a.mVec.magVecSquared() <= b.mVec.magVecSquared();
}
}
return TRUE;
}
friend bool operator==(const LLScriptLibData &a, const LLScriptLibData &b)
{
if (a.mType == b.mType)
{
if (a.mType == LST_INTEGER)
{
return a.mInteger == b.mInteger;
}
if (a.mType == LST_FLOATINGPOINT)
{
return a.mFP == b.mFP;
}
if (a.mType == LST_STRING)
{
return !strcmp(a.mString, b.mString);
}
if (a.mType == LST_KEY)
{
return !strcmp(a.mKey, b.mKey);
}
if (a.mType == LST_VECTOR)
{
return a.mVec == b.mVec;
}
if (a.mType == LST_QUATERNION)
{
return a.mQuat == b.mQuat;
}
}
return FALSE;
}
S32 getListLength() const
{
const LLScriptLibData *data = this;
S32 retval = 0;
while (data->mListp)
{
retval++;
data = data->mListp;
}
return retval;
}
BOOL checkForMultipleLists()
{
LLScriptLibData *data = this;
while (data->mListp)
{
data = data->mListp;
if (data->mType == LST_LIST)
return TRUE;
}
return FALSE;
}
S32 getSavedSize()
{
S32 size = 0;
// mType
size += 4;
switch(mType)
{
case LST_INTEGER:
size += 4;
break;
case LST_FLOATINGPOINT:
size += 4;
break;
case LST_KEY:
size += (S32)strlen(mKey) + 1; /*Flawfinder: ignore*/
break;
case LST_STRING:
size += (S32)strlen(mString) + 1; /*Flawfinder: ignore*/
break;
case LST_LIST:
break;
case LST_VECTOR:
size += 12;
break;
case LST_QUATERNION:
size += 16;
break;
default:
break;
}
return size;
}
S32 write2bytestream(U8 *dest)
{
S32 offset = 0;
integer2bytestream(dest, offset, mType);
switch(mType)
{
case LST_INTEGER:
integer2bytestream(dest, offset, mInteger);
break;
case LST_FLOATINGPOINT:
float2bytestream(dest, offset, mFP);
break;
case LST_KEY:
char2bytestream(dest, offset, mKey);
break;
case LST_STRING:
char2bytestream(dest, offset, mString);
break;
case LST_LIST:
break;
case LST_VECTOR:
vector2bytestream(dest, offset, mVec);
break;
case LST_QUATERNION:
quaternion2bytestream(dest, offset, mQuat);
break;
default:
break;
}
return offset;
}
LLScriptLibData() : mType(LST_NULL), mInteger(0), mFP(0.f), mKey(NULL), mString(NULL), mVec(), mQuat(), mListp(NULL)
{
}
LLScriptLibData(const LLScriptLibData &data) : mType(data.mType), mInteger(data.mInteger), mFP(data.mFP), mKey(NULL), mString(NULL), mVec(data.mVec), mQuat(data.mQuat), mListp(NULL)
{
if (data.mKey)
{
mKey = new char[strlen(data.mKey) + 1]; /* Flawfinder: ignore */
if (mKey == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mKey, data.mKey); /* Flawfinder: ignore */
}
if (data.mString)
{
mString = new char[strlen(data.mString) + 1]; /* Flawfinder: ignore */
if (mString == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mString, data.mString); /* Flawfinder: ignore */
}
}
LLScriptLibData(U8 *src, S32 &offset) : mListp(NULL)
{
static char temp[TOP_OF_MEMORY]; /* Flawfinder: ignore */
mType = (LSCRIPTType)bytestream2integer(src, offset);
switch(mType)
{
case LST_INTEGER:
mInteger = bytestream2integer(src, offset);
break;
case LST_FLOATINGPOINT:
mFP = bytestream2float(src, offset);
break;
case LST_KEY:
{
bytestream2char(temp, src, offset, sizeof(temp));
mKey = new char[strlen(temp) + 1]; /* Flawfinder: ignore */
if (mKey == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mKey, temp); /* Flawfinder: ignore */
}
break;
case LST_STRING:
{
bytestream2char(temp, src, offset, sizeof(temp));
mString = new char[strlen(temp) + 1]; /* Flawfinder: ignore */
if (mString == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mString, temp); /* Flawfinder: ignore */
}
break;
case LST_LIST:
break;
case LST_VECTOR:
bytestream2vector(mVec, src, offset);
break;
case LST_QUATERNION:
bytestream2quaternion(mQuat, src, offset);
break;
default:
break;
}
}
void set(U8 *src, S32 &offset)
{
static char temp[TOP_OF_MEMORY]; /* Flawfinder: ignore */
mType = (LSCRIPTType)bytestream2integer(src, offset);
switch(mType)
{
case LST_INTEGER:
mInteger = bytestream2integer(src, offset);
break;
case LST_FLOATINGPOINT:
mFP = bytestream2float(src, offset);
break;
case LST_KEY:
{
bytestream2char(temp, src, offset, sizeof(temp));
mKey = new char[strlen(temp) + 1]; /* Flawfinder: ignore */
if (mKey == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mKey, temp); /* Flawfinder: ignore */
}
break;
case LST_STRING:
{
bytestream2char(temp, src, offset, sizeof(temp));
mString = new char[strlen(temp) + 1]; /* Flawfinder: ignore */
if (mString == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mString, temp); /* Flawfinder: ignore */
}
break;
case LST_LIST:
break;
case LST_VECTOR:
bytestream2vector(mVec, src, offset);
break;
case LST_QUATERNION:
bytestream2quaternion(mQuat, src, offset);
break;
default:
break;
}
}
void print(std::ostream &s, BOOL b_prepend_comma);
void print_separator(std::ostream& ostr, BOOL b_prepend_sep, char* sep);
void setFromCSV(const char *src)
{
mType = LST_STRING;
mString = new char[strlen(src) + 1]; /* Flawfinder: ignore */
if (mString == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mString, src); /* Flawfinder: ignore */
}
LLScriptLibData(S32 integer) : mType(LST_INTEGER), mInteger(integer), mFP(0.f), mKey(NULL), mString(NULL), mVec(), mQuat(), mListp(NULL)
{
}
LLScriptLibData(F32 fp) : mType(LST_FLOATINGPOINT), mInteger(0), mFP(fp), mKey(NULL), mString(NULL), mVec(), mQuat(), mListp(NULL)
{
}
LLScriptLibData(const LLUUID &id) : mType(LST_KEY), mInteger(0), mFP(0.f), mKey(NULL), mString(NULL), mVec(), mQuat(), mListp(NULL)
{
std::string idstr;
id.toString(idstr);
mKey = new char[idstr.length()+1];
LLStringUtil::copy(mKey,idstr.c_str(),idstr.length()+1);
}
LLScriptLibData(const char *string) : mType(LST_STRING), mInteger(0), mFP(0.f), mKey(NULL), mString(NULL), mVec(), mQuat(), mListp(NULL)
{
if (!string)
{
mString = new char[1];
mString[0] = 0;
}
else
{
mString = new char[strlen(string) + 1]; /* Flawfinder: ignore */
if (mString == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
strcpy(mString, string); /* Flawfinder: ignore */
}
}
LLScriptLibData(const LLVector3 &vec) : mType(LST_VECTOR), mInteger(0), mFP(0.f), mKey(NULL), mString(NULL), mVec(vec), mQuat(), mListp(NULL)
{
}
LLScriptLibData(const LLQuaternion &quat) : mType(LST_QUATERNION), mInteger(0), mFP(0.f), mKey(NULL), mString(NULL), mVec(), mQuat(quat), mListp(NULL)
{
}
~LLScriptLibData()
{
delete mListp;
delete [] mKey;
delete [] mString;
}
};
#endif

33
indra/lscript/lscript_library/CMakeLists.txt Normal file
View File

@@ -0,0 +1,33 @@
# -*- cmake -*-
include(00-Common)
include(LLCommon)
include(LLMath)
include(LScript)
set(lscript_library_SOURCE_FILES
lscript_alloc.cpp
lscript_export.cpp
lscript_library.cpp
)
set(lscript_library_HEADER_FILES
CMakeLists.txt
../lscript_library.h
../lscript_export.h
)
set_source_files_properties(${lscript_library_HEADER_FILES}
PROPERTIES HEADER_FILE_ONLY TRUE)
list(APPEND lscript_library_SOURCE_FILES ${lscript_library_HEADER_FILES})
include_directories(
${LLCOMMON_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LSCRIPT_INCLUDE_DIRS}
)
add_library (lscript_library ${lscript_library_SOURCE_FILES})
add_dependencies(lscript_library prepare)

1142
indra/lscript/lscript_library/lscript_alloc.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

32
indra/lscript/lscript_library/lscript_export.cpp Normal file
View File

@@ -0,0 +1,32 @@
/**
* @file lscript_export.cpp
* @brief export interface class
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/

568
indra/lscript/lscript_library/lscript_library.cpp Normal file
View File

@@ -0,0 +1,568 @@
/**
* @file lscript_library.cpp
* @brief external library interface
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
// ## ## ### ######## ## ## #### ## ## ###### #### ####
// ## ## ## ## ## ## ## ### ## ## ### ## ## ## #### ####
// ## ## ## ## ## ## ## #### ## ## #### ## ## #### ####
// ## ## ## ## ## ######## ## ## ## ## ## ## ## ## #### ## ##
// ## ## ## ######### ## ## ## #### ## ## #### ## ##
// ## ## ## ## ## ## ## ## ### ## ## ### ## ## #### ####
// ### ### ## ## ## ## ## ## #### ## ## ###### #### ####
//
// When adding functions, they <b>MUST</b> be appended to the end of
// the init() method. The init() associates the name with a number,
// which is then serialized into the bytecode. Inserting a new
// function in the middle will lead to many sim crashes. Phoenix 2006-04-10.
#include "linden_common.h"
#include "lscript_library.h"
LLScriptLibrary::LLScriptLibrary()
{
init();
}
LLScriptLibrary::~LLScriptLibrary()
{
}
void dummy_func(LLScriptLibData *retval, LLScriptLibData *args, const LLUUID &id)
{
}
void LLScriptLibrary::init()
{
// IF YOU ADD NEW SCRIPT CALLS, YOU MUST PUT THEM AT THE END OF THIS LIST.
// Otherwise the bytecode numbers for each call will be wrong, and all
// existing scripts will crash.
// energy, sleep, dummy_func, name, return type, parameters, gods-only
addFunction(10.f, 0.f, dummy_func, "llSin", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llCos", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llTan", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llAtan2", "f", "ff");
addFunction(10.f, 0.f, dummy_func, "llSqrt", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llPow", "f", "ff");
addFunction(10.f, 0.f, dummy_func, "llAbs", "i", "i");
addFunction(10.f, 0.f, dummy_func, "llFabs", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llFrand", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llFloor", "i", "f");
addFunction(10.f, 0.f, dummy_func, "llCeil", "i", "f");
addFunction(10.f, 0.f, dummy_func, "llRound", "i", "f");
addFunction(10.f, 0.f, dummy_func, "llVecMag", "f", "v");
addFunction(10.f, 0.f, dummy_func, "llVecNorm", "v", "v");
addFunction(10.f, 0.f, dummy_func, "llVecDist", "f", "vv");
addFunction(10.f, 0.f, dummy_func, "llRot2Euler", "v", "q");
addFunction(10.f, 0.f, dummy_func, "llEuler2Rot", "q", "v");
addFunction(10.f, 0.f, dummy_func, "llAxes2Rot", "q", "vvv");
addFunction(10.f, 0.f, dummy_func, "llRot2Fwd", "v", "q");
addFunction(10.f, 0.f, dummy_func, "llRot2Left", "v", "q");
addFunction(10.f, 0.f, dummy_func, "llRot2Up", "v", "q");
addFunction(10.f, 0.f, dummy_func, "llRotBetween", "q", "vv");
addFunction(10.f, 0.f, dummy_func, "llWhisper", NULL, "is");
addFunction(10.f, 0.f, dummy_func, "llSay", NULL, "is");
addFunction(10.f, 0.f, dummy_func, "llShout", NULL, "is");
addFunction(10.f, 0.f, dummy_func, "llListen", "i", "isks");
addFunction(10.f, 0.f, dummy_func, "llListenControl", NULL, "ii");
addFunction(10.f, 0.f, dummy_func, "llListenRemove", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llSensor", NULL, "skiff");
addFunction(10.f, 0.f, dummy_func, "llSensorRepeat", NULL, "skifff");
addFunction(10.f, 0.f, dummy_func, "llSensorRemove", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llDetectedName", "s", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedKey", "k", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedOwner", "k", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedType", "i", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedPos", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedVel", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedGrab", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedRot", "q", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedGroup", "i", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedLinkNumber", "i", "i");
addFunction(0.f, 0.f, dummy_func, "llDie", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llGround", "f", "v");
addFunction(10.f, 0.f, dummy_func, "llCloud", "f", "v");
addFunction(10.f, 0.f, dummy_func, "llWind", "v", "v");
addFunction(10.f, 0.f, dummy_func, "llSetStatus", NULL, "ii");
addFunction(10.f, 0.f, dummy_func, "llGetStatus", "i", "i");
addFunction(10.f, 0.f, dummy_func, "llSetScale", NULL, "v");
addFunction(10.f, 0.f, dummy_func, "llGetScale", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetColor", NULL, "vi");
addFunction(10.f, 0.f, dummy_func, "llGetAlpha", "f", "i");
addFunction(10.f, 0.f, dummy_func, "llSetAlpha", NULL, "fi");
addFunction(10.f, 0.f, dummy_func, "llGetColor", "v", "i");
addFunction(10.f, 0.2f, dummy_func, "llSetTexture", NULL, "si");
addFunction(10.f, 0.2f, dummy_func, "llScaleTexture", NULL, "ffi");
addFunction(10.f, 0.2f, dummy_func, "llOffsetTexture", NULL, "ffi");
addFunction(10.f, 0.2f, dummy_func, "llRotateTexture", NULL, "fi");
addFunction(10.f, 0.f, dummy_func, "llGetTexture", "s", "i");
addFunction(10.f, 0.2f, dummy_func, "llSetPos", NULL, "v");
addFunction(10.f, 0.f, dummy_func, "llGetPos", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetLocalPos", "v", NULL);
addFunction(10.f, 0.2f, dummy_func, "llSetRot", NULL, "q");
addFunction(10.f, 0.f, dummy_func, "llGetRot", "q", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetLocalRot", "q", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetForce", NULL, "vi");
addFunction(10.f, 0.f, dummy_func, "llGetForce", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llTarget", "i", "vf");
addFunction(10.f, 0.f, dummy_func, "llTargetRemove", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llRotTarget", "i", "qf");
addFunction(10.f, 0.f, dummy_func, "llRotTargetRemove", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llMoveToTarget", NULL, "vf");
addFunction(10.f, 0.f, dummy_func, "llStopMoveToTarget", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llApplyImpulse", NULL, "vi");
addFunction(10.f, 0.f, dummy_func, "llApplyRotationalImpulse", NULL, "vi");
addFunction(10.f, 0.f, dummy_func, "llSetTorque", NULL, "vi");
addFunction(10.f, 0.f, dummy_func, "llGetTorque", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetForceAndTorque", NULL, "vvi");
addFunction(10.f, 0.f, dummy_func, "llGetVel", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetAccel", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetOmega", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetTimeOfDay", "f", "");
addFunction(10.f, 0.f, dummy_func, "llGetWallclock", "f", "");
addFunction(10.f, 0.f, dummy_func, "llGetTime", "f", NULL);
addFunction(10.f, 0.f, dummy_func, "llResetTime", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llGetAndResetTime", "f", NULL);
addFunction(10.f, 0.f, dummy_func, "llSound", NULL, "sfii");
addFunction(10.f, 0.f, dummy_func, "llPlaySound", NULL, "sf");
addFunction(10.f, 0.f, dummy_func, "llLoopSound", NULL, "sf");
addFunction(10.f, 0.f, dummy_func, "llLoopSoundMaster", NULL, "sf");
addFunction(10.f, 0.f, dummy_func, "llLoopSoundSlave", NULL, "sf");
addFunction(10.f, 0.f, dummy_func, "llPlaySoundSlave", NULL, "sf");
addFunction(10.f, 0.f, dummy_func, "llTriggerSound", NULL, "sf");
addFunction(10.f, 0.f, dummy_func, "llStopSound", NULL, "");
addFunction(10.f, 1.f, dummy_func, "llPreloadSound", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llGetSubString", "s", "sii");
addFunction(10.f, 0.f, dummy_func, "llDeleteSubString", "s", "sii");
addFunction(10.f, 0.f, dummy_func, "llInsertString", "s", "sis");
addFunction(10.f, 0.f, dummy_func, "llToUpper", "s", "s");
addFunction(10.f, 0.f, dummy_func, "llToLower", "s", "s");
addFunction(10.f, 0.f, dummy_func, "llGiveMoney", "i", "ki");
addFunction(10.f, 0.1f, dummy_func, "llMakeExplosion", NULL, "iffffsv");
addFunction(10.f, 0.1f, dummy_func, "llMakeFountain", NULL, "iffffisvf");
addFunction(10.f, 0.1f, dummy_func, "llMakeSmoke", NULL, "iffffsv");
addFunction(10.f, 0.1f, dummy_func, "llMakeFire", NULL, "iffffsv");
addFunction(200.f, 0.1f, dummy_func, "llRezObject", NULL, "svvqi");
addFunction(10.f, 0.f, dummy_func, "llLookAt", NULL, "vff");
addFunction(10.f, 0.f, dummy_func, "llStopLookAt", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llSetTimerEvent", NULL, "f");
addFunction(0.f, 0.f, dummy_func, "llSleep", NULL, "f");
addFunction(10.f, 0.f, dummy_func, "llGetMass", "f", NULL);
addFunction(10.f, 0.f, dummy_func, "llCollisionFilter", NULL, "ski");
addFunction(10.f, 0.f, dummy_func, "llTakeControls", NULL, "iii");
addFunction(10.f, 0.f, dummy_func, "llReleaseControls", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llAttachToAvatar", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llDetachFromAvatar", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llTakeCamera", NULL, "k");
addFunction(10.f, 0.f, dummy_func, "llReleaseCamera", NULL, "k");
addFunction(10.f, 0.f, dummy_func, "llGetOwner", "k", NULL);
addFunction(10.f, 2.f, dummy_func, "llInstantMessage", NULL, "ks");
addFunction(10.f, 20.f, dummy_func, "llEmail", NULL, "sss");
addFunction(10.f, 0.f, dummy_func, "llGetNextEmail", NULL, "ss");
addFunction(10.f, 0.f, dummy_func, "llGetKey", "k", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetBuoyancy", NULL, "f");
addFunction(10.f, 0.f, dummy_func, "llSetHoverHeight", NULL, "fif");
addFunction(10.f, 0.f, dummy_func, "llStopHover", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llMinEventDelay", NULL, "f");
addFunction(10.f, 0.f, dummy_func, "llSoundPreload", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llRotLookAt", NULL, "qff");
addFunction(10.f, 0.f, dummy_func, "llStringLength", "i", "s");
addFunction(10.f, 0.f, dummy_func, "llStartAnimation", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llStopAnimation", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llPointAt", NULL, "v");
addFunction(10.f, 0.f, dummy_func, "llStopPointAt", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llTargetOmega", NULL, "vff");
addFunction(10.f, 0.f, dummy_func, "llGetStartParameter", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llGodLikeRezObject", NULL, "kv", TRUE);
addFunction(10.f, 0.f, dummy_func, "llRequestPermissions", NULL, "ki");
addFunction(10.f, 0.f, dummy_func, "llGetPermissionsKey", "k", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetPermissions", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetLinkNumber", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetLinkColor", NULL, "ivi");
addFunction(10.f, 1.f, dummy_func, "llCreateLink", NULL, "ki");
addFunction(10.f, 0.f, dummy_func, "llBreakLink", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llBreakAllLinks", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llGetLinkKey", "k", "i");
addFunction(10.f, 0.f, dummy_func, "llGetLinkName", "s", "i");
addFunction(10.f, 0.f, dummy_func, "llGetInventoryNumber", "i", "i");
addFunction(10.f, 0.f, dummy_func, "llGetInventoryName", "s", "ii");
addFunction(10.f, 0.f, dummy_func, "llSetScriptState", NULL, "si");
addFunction(10.f, 0.f, dummy_func, "llGetEnergy", "f", NULL);
addFunction(10.f, 0.f, dummy_func, "llGiveInventory", NULL, "ks");
addFunction(10.f, 0.f, dummy_func, "llRemoveInventory", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llSetText", NULL, "svf");
addFunction(10.f, 0.f, dummy_func, "llWater", "f", "v");
addFunction(10.f, 0.f, dummy_func, "llPassTouches", NULL, "i");
addFunction(10.f, 0.1f, dummy_func, "llRequestAgentData", "k", "ki");
addFunction(10.f, 1.f, dummy_func, "llRequestInventoryData", "k", "s");
addFunction(10.f, 0.f, dummy_func, "llSetDamage", NULL, "f");
addFunction(100.f, 5.f, dummy_func, "llTeleportAgentHome", NULL, "k");
addFunction(10.f, 0.f, dummy_func, "llModifyLand", NULL, "ii");
addFunction(10.f, 0.f, dummy_func, "llCollisionSound", NULL, "sf");
addFunction(10.f, 0.f, dummy_func, "llCollisionSprite", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llGetAnimation", "s", "k");
addFunction(10.f, 0.f, dummy_func, "llResetScript", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llMessageLinked", NULL, "iisk");
addFunction(10.f, 0.f, dummy_func, "llPushObject", NULL, "kvvi");
addFunction(10.f, 0.f, dummy_func, "llPassCollisions", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llGetScriptName", "s", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetNumberOfSides", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llAxisAngle2Rot", "q", "vf");
addFunction(10.f, 0.f, dummy_func, "llRot2Axis", "v", "q");
addFunction(10.f, 0.f, dummy_func, "llRot2Angle", "f", "q");
addFunction(10.f, 0.f, dummy_func, "llAcos", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llAsin", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llAngleBetween", "f", "qq");
addFunction(10.f, 0.f, dummy_func, "llGetInventoryKey", "k", "s");
addFunction(10.f, 0.f, dummy_func, "llAllowInventoryDrop", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llGetSunDirection", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetTextureOffset", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llGetTextureScale", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llGetTextureRot", "f", "i");
addFunction(10.f, 0.f, dummy_func, "llSubStringIndex", "i", "ss");
addFunction(10.f, 0.f, dummy_func, "llGetOwnerKey", "k", "k");
addFunction(10.f, 0.f, dummy_func, "llGetCenterOfMass", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llListSort", "l", "lii");
addFunction(10.f, 0.f, dummy_func, "llGetListLength", "i", "l");
addFunction(10.f, 0.f, dummy_func, "llList2Integer", "i", "li");
addFunction(10.f, 0.f, dummy_func, "llList2Float", "f", "li");
addFunction(10.f, 0.f, dummy_func, "llList2String", "s", "li");
addFunction(10.f, 0.f, dummy_func, "llList2Key", "k", "li");
addFunction(10.f, 0.f, dummy_func, "llList2Vector", "v", "li");
addFunction(10.f, 0.f, dummy_func, "llList2Rot", "q", "li");
addFunction(10.f, 0.f, dummy_func, "llList2List", "l", "lii");
addFunction(10.f, 0.f, dummy_func, "llDeleteSubList", "l", "lii");
addFunction(10.f, 0.f, dummy_func, "llGetListEntryType", "i", "li");
addFunction(10.f, 0.f, dummy_func, "llList2CSV", "s", "l");
addFunction(10.f, 0.f, dummy_func, "llCSV2List", "l", "s");
addFunction(10.f, 0.f, dummy_func, "llListRandomize", "l", "li");
addFunction(10.f, 0.f, dummy_func, "llList2ListStrided", "l", "liii");
addFunction(10.f, 0.f, dummy_func, "llGetRegionCorner", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llListInsertList", "l", "lli");
addFunction(10.f, 0.f, dummy_func, "llListFindList", "i", "ll");
addFunction(10.f, 0.f, dummy_func, "llGetObjectName", "s", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetObjectName", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llGetDate", "s", NULL);
addFunction(10.f, 0.f, dummy_func, "llEdgeOfWorld", "i", "vv");
addFunction(10.f, 0.f, dummy_func, "llGetAgentInfo", "i", "k");
addFunction(10.f, 0.1f, dummy_func, "llAdjustSoundVolume", NULL, "f");
addFunction(10.f, 0.f, dummy_func, "llSetSoundQueueing", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llSetSoundRadius", NULL, "f");
addFunction(10.f, 0.f, dummy_func, "llKey2Name", "s", "k");
addFunction(10.f, 0.f, dummy_func, "llSetTextureAnim", NULL, "iiiifff");
addFunction(10.f, 0.f, dummy_func, "llTriggerSoundLimited", NULL, "sfvv");
addFunction(10.f, 0.f, dummy_func, "llEjectFromLand", NULL, "k");
addFunction(10.f, 0.f, dummy_func, "llParseString2List", "l", "sll");
addFunction(10.f, 0.f, dummy_func, "llOverMyLand", "i", "k");
addFunction(10.f, 0.f, dummy_func, "llGetLandOwnerAt", "k", "v");
addFunction(10.f, 0.1f, dummy_func, "llGetNotecardLine", "k", "si");
addFunction(10.f, 0.f, dummy_func, "llGetAgentSize", "v", "k");
addFunction(10.f, 0.f, dummy_func, "llSameGroup", "i", "k");
addFunction(10.f, 0.f, dummy_func, "llUnSit", NULL, "k");
addFunction(10.f, 0.f, dummy_func, "llGroundSlope", "v", "v");
addFunction(10.f, 0.f, dummy_func, "llGroundNormal", "v", "v");
addFunction(10.f, 0.f, dummy_func, "llGroundContour", "v", "v");
addFunction(10.f, 0.f, dummy_func, "llGetAttached", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetFreeMemory", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetRegionName", "s", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetRegionTimeDilation", "f", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetRegionFPS", "f", NULL);
addFunction(10.f, 0.f, dummy_func, "llParticleSystem", NULL, "l");
addFunction(10.f, 0.f, dummy_func, "llGroundRepel", NULL, "fif");
addFunction(10.f, 3.f, dummy_func, "llGiveInventoryList", NULL, "ksl");
// script calls for vehicle action
addFunction(10.f, 0.f, dummy_func, "llSetVehicleType", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llSetVehicleFloatParam", NULL, "if");
addFunction(10.f, 0.f, dummy_func, "llSetVehicleVectorParam", NULL, "iv");
addFunction(10.f, 0.f, dummy_func, "llSetVehicleRotationParam", NULL, "iq");
addFunction(10.f, 0.f, dummy_func, "llSetVehicleFlags", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llRemoveVehicleFlags", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llSitTarget", NULL, "vq");
addFunction(10.f, 0.f, dummy_func, "llAvatarOnSitTarget", "k", NULL);
addFunction(10.f, 0.1f, dummy_func, "llAddToLandPassList", NULL, "kf");
addFunction(10.f, 0.f, dummy_func, "llSetTouchText", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llSetSitText", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llSetCameraEyeOffset", NULL, "v");
addFunction(10.f, 0.f, dummy_func, "llSetCameraAtOffset", NULL, "v");
addFunction(10.f, 0.f, dummy_func, "llDumpList2String", "s", "ls");
addFunction(10.f, 0.f, dummy_func, "llScriptDanger", "i", "v");
addFunction(10.f, 1.f, dummy_func, "llDialog", NULL, "ksli");
addFunction(10.f, 0.f, dummy_func, "llVolumeDetect", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llResetOtherScript", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llGetScriptState", "i", "s");
addFunction(10.f, 3.f, dummy_func, "llRemoteLoadScript", NULL, "ksii");
addFunction(10.f, 0.2f, dummy_func, "llSetRemoteScriptAccessPin", NULL, "i");
addFunction(10.f, 3.f, dummy_func, "llRemoteLoadScriptPin", NULL, "ksiii");
addFunction(10.f, 1.f, dummy_func, "llOpenRemoteDataChannel", NULL, NULL);
addFunction(10.f, 3.f, dummy_func, "llSendRemoteData", "k", "ksis");
addFunction(10.f, 3.f, dummy_func, "llRemoteDataReply", NULL, "kksi");
addFunction(10.f, 1.f, dummy_func, "llCloseRemoteDataChannel", NULL, "k");
addFunction(10.f, 0.f, dummy_func, "llMD5String", "s", "si");
addFunction(10.f, 0.2f, dummy_func, "llSetPrimitiveParams", NULL, "l");
addFunction(10.f, 0.f, dummy_func, "llStringToBase64", "s", "s");
addFunction(10.f, 0.f, dummy_func, "llBase64ToString", "s", "s");
addFunction(10.f, 0.3f, dummy_func, "llXorBase64Strings", "s", "ss");
addFunction(10.f, 0.f, dummy_func, "llRemoteDataSetRegion", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llLog10", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llLog", "f", "f");
addFunction(10.f, 0.f, dummy_func, "llGetAnimationList", "l", "k");
addFunction(10.f, 2.f, dummy_func, "llSetParcelMusicURL", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llGetRootPosition", "v", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetRootRotation", "q", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetObjectDesc", "s", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetObjectDesc", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llGetCreator", "k", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetTimestamp", "s", NULL);
addFunction(10.f, 0.f, dummy_func, "llSetLinkAlpha", NULL, "ifi");
addFunction(10.f, 0.f, dummy_func, "llGetNumberOfPrims", "i", NULL);
addFunction(10.f, 0.1f, dummy_func, "llGetNumberOfNotecardLines", "k", "s");
addFunction(10.f, 0.f, dummy_func, "llGetBoundingBox", "l", "k");
addFunction(10.f, 0.f, dummy_func, "llGetGeometricCenter", "v", NULL);
addFunction(10.f, 0.2f, dummy_func, "llGetPrimitiveParams", "l", "l");
addFunction(10.f, 0.0f, dummy_func, "llIntegerToBase64", "s", "i");
addFunction(10.f, 0.0f, dummy_func, "llBase64ToInteger", "i", "s");
addFunction(10.f, 0.f, dummy_func, "llGetGMTclock", "f", "");
addFunction(10.f, 10.f, dummy_func, "llGetSimulatorHostname", "s", "");
addFunction(10.f, 0.2f, dummy_func, "llSetLocalRot", NULL, "q");
addFunction(10.f, 0.f, dummy_func, "llParseStringKeepNulls", "l", "sll");
addFunction(200.f, 0.1f, dummy_func, "llRezAtRoot", NULL, "svvqi");
addFunction(10.f, 0.f, dummy_func, "llGetObjectPermMask", "i", "i", FALSE);
addFunction(10.f, 0.f, dummy_func, "llSetObjectPermMask", NULL, "ii", TRUE);
addFunction(10.f, 0.f, dummy_func, "llGetInventoryPermMask", "i", "si", FALSE);
addFunction(10.f, 0.f, dummy_func, "llSetInventoryPermMask", NULL, "sii", TRUE);
addFunction(10.f, 0.f, dummy_func, "llGetInventoryCreator", "k", "s", FALSE);
addFunction(10.f, 0.f, dummy_func, "llOwnerSay", NULL, "s");
addFunction(10.f, 1.f, dummy_func, "llRequestSimulatorData", "k", "si");
addFunction(10.f, 0.f, dummy_func, "llForceMouselook", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llGetObjectMass", "f", "k");
addFunction(10.f, 0.f, dummy_func, "llListReplaceList", "l", "llii");
addFunction(10.f, 10.f, dummy_func, "llLoadURL", NULL, "kss");
addFunction(10.f, 2.f, dummy_func, "llParcelMediaCommandList", NULL, "l");
addFunction(10.f, 2.f, dummy_func, "llParcelMediaQuery", "l", "l");
addFunction(10.f, 1.f, dummy_func, "llModPow", "i", "iii");
addFunction(10.f, 0.f, dummy_func, "llGetInventoryType", "i", "s");
addFunction(10.f, 0.f, dummy_func, "llSetPayPrice", NULL, "il");
addFunction(10.f, 0.f, dummy_func, "llGetCameraPos", "v", "");
addFunction(10.f, 0.f, dummy_func, "llGetCameraRot", "q", "");
addFunction(10.f, 20.f, dummy_func, "llSetPrimURL", NULL, "s");
addFunction(10.f, 20.f, dummy_func, "llRefreshPrimURL", NULL, "");
addFunction(10.f, 0.f, dummy_func, "llEscapeURL", "s", "s");
addFunction(10.f, 0.f, dummy_func, "llUnescapeURL", "s", "s");
addFunction(10.f, 1.f, dummy_func, "llMapDestination", NULL, "svv");
addFunction(10.f, 0.1f, dummy_func, "llAddToLandBanList", NULL, "kf");
addFunction(10.f, 0.1f, dummy_func, "llRemoveFromLandPassList", NULL, "k");
addFunction(10.f, 0.1f, dummy_func, "llRemoveFromLandBanList", NULL, "k");
addFunction(10.f, 0.f, dummy_func, "llSetCameraParams", NULL, "l");
addFunction(10.f, 0.f, dummy_func, "llClearCameraParams", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llListStatistics", "f", "il");
addFunction(10.f, 0.f, dummy_func, "llGetUnixTime", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llGetParcelFlags", "i", "v");
addFunction(10.f, 0.f, dummy_func, "llGetRegionFlags", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llXorBase64StringsCorrect", "s", "ss");
addFunction(10.f, 0.f, dummy_func, "llHTTPRequest", "k", "sls");
addFunction(10.f, 0.1f, dummy_func, "llResetLandBanList", NULL, NULL);
addFunction(10.f, 0.1f, dummy_func, "llResetLandPassList", NULL, NULL);
addFunction(10.f, 0.f, dummy_func, "llGetObjectPrimCount", "i", "k");
addFunction(10.f, 2.0f, dummy_func, "llGetParcelPrimOwners", "l", "v");
addFunction(10.f, 0.f, dummy_func, "llGetParcelPrimCount", "i", "vii");
addFunction(10.f, 0.f, dummy_func, "llGetParcelMaxPrims", "i", "vi");
addFunction(10.f, 0.f, dummy_func, "llGetParcelDetails", "l", "vl");
addFunction(10.f, 0.2f, dummy_func, "llSetLinkPrimitiveParams", NULL, "il");
addFunction(10.f, 0.2f, dummy_func, "llSetLinkTexture", NULL, "isi");
addFunction(10.f, 0.f, dummy_func, "llStringTrim", "s", "si");
addFunction(10.f, 0.f, dummy_func, "llRegionSay", NULL, "is");
addFunction(10.f, 0.f, dummy_func, "llGetObjectDetails", "l", "kl");
addFunction(10.f, 0.f, dummy_func, "llSetClickAction", NULL, "i");
addFunction(10.f, 0.f, dummy_func, "llGetRegionAgentCount", "i", NULL);
addFunction(10.f, 1.f, dummy_func, "llTextBox", NULL, "ksi");
addFunction(10.f, 0.f, dummy_func, "llGetAgentLanguage", "s", "k");
addFunction(10.f, 0.f, dummy_func, "llDetectedTouchUV", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedTouchFace", "i", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedTouchPos", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedTouchNormal", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedTouchBinormal", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llDetectedTouchST", "v", "i");
addFunction(10.f, 0.f, dummy_func, "llSHA1String", "s", "s");
addFunction(10.f, 0.f, dummy_func, "llGetFreeURLs", "i", NULL);
addFunction(10.f, 0.f, dummy_func, "llRequestURL", "k", NULL);
addFunction(10.f, 0.f, dummy_func, "llRequestSecureURL", "k", NULL);
addFunction(10.f, 0.f, dummy_func, "llReleaseURL", NULL, "s");
addFunction(10.f, 0.f, dummy_func, "llHTTPResponse", NULL, "kis");
addFunction(10.f, 0.f, dummy_func, "llGetHTTPHeader", "s", "ks");
// energy, sleep, dummy_func, name, return type, parameters, gods-only
// IF YOU ADD NEW SCRIPT CALLS, YOU MUST PUT THEM AT THE END OF THIS LIST.
// Otherwise the bytecode numbers for each call will be wrong, and all
// existing scripts will crash.
}
LLScriptLibraryFunction::LLScriptLibraryFunction(F32 eu, F32 st, void (*exec_func)(LLScriptLibData *, LLScriptLibData *, const LLUUID &), const char *name, const char *ret_type, const char *args, BOOL god_only)
: mEnergyUse(eu), mSleepTime(st), mExecFunc(exec_func), mName(name), mReturnType(ret_type), mArgs(args), mGodOnly(god_only)
{
}
LLScriptLibraryFunction::~LLScriptLibraryFunction()
{
}
void LLScriptLibrary::addFunction(F32 eu, F32 st, void (*exec_func)(LLScriptLibData *, LLScriptLibData *, const LLUUID &), const char *name, const char *ret_type, const char *args, BOOL god_only)
{
LLScriptLibraryFunction func(eu, st, exec_func, name, ret_type, args, god_only);
mFunctions.push_back(func);
}
void LLScriptLibrary::assignExec(const char *name, void (*exec_func)(LLScriptLibData *, LLScriptLibData *, const LLUUID &))
{
for (std::vector<LLScriptLibraryFunction>::iterator i = mFunctions.begin();
i != mFunctions.end(); ++i)
{
if (!strcmp(name, i->mName))
{
i->mExecFunc = exec_func;
return;
}
}
llerrs << "Unknown LSL function in assignExec: " << name << llendl;
}
void LLScriptLibData::print(std::ostream &s, BOOL b_prepend_comma)
{
char tmp[1024]; /*Flawfinder: ignore*/
if (b_prepend_comma)
{
s << ", ";
}
switch (mType)
{
case LST_INTEGER:
s << mInteger;
break;
case LST_FLOATINGPOINT:
snprintf(tmp, 1024, "%f", mFP); /* Flawfinder: ignore */
s << tmp;
break;
case LST_KEY:
s << mKey;
break;
case LST_STRING:
s << mString;
break;
case LST_VECTOR:
snprintf(tmp, 1024, "<%f, %f, %f>", mVec.mV[VX], /* Flawfinder: ignore */
mVec.mV[VY], mVec.mV[VZ]);
s << tmp;
break;
case LST_QUATERNION:
snprintf(tmp, 1024, "<%f, %f, %f, %f>", mQuat.mQ[VX], mQuat.mQ[VY], /* Flawfinder: ignore */
mQuat.mQ[VZ], mQuat.mQ[VS]);
s << tmp;
break;
default:
break;
}
}
void LLScriptLibData::print_separator(std::ostream& ostr, BOOL b_prepend_sep, char* sep)
{
if (b_prepend_sep)
{
ostr << sep;
}
//print(ostr, FALSE);
{
char tmp[1024]; /* Flawfinder: ignore */
switch (mType)
{
case LST_INTEGER:
ostr << mInteger;
break;
case LST_FLOATINGPOINT:
snprintf(tmp, 1024, "%f", mFP); /* Flawfinder: ignore */
ostr << tmp;
break;
case LST_KEY:
ostr << mKey;
break;
case LST_STRING:
ostr << mString;
break;
case LST_VECTOR:
snprintf(tmp, 1024, "<%f, %f, %f>", mVec.mV[VX], /* Flawfinder: ignore */
mVec.mV[VY], mVec.mV[VZ]);
ostr << tmp;
break;
case LST_QUATERNION:
snprintf(tmp, 1024, "<%f, %f, %f, %f>", mQuat.mQ[VX], mQuat.mQ[VY], /* Flawfinder: ignore */
mQuat.mQ[VZ], mQuat.mQ[VS]);
ostr << tmp;
break;
default:
break;
}
}
}
LLScriptLibrary gScriptLibrary;

42
indra/lscript/lscript_rt_interface.h Normal file
View File

@@ -0,0 +1,42 @@
/**
* @file lscript_rt_interface.h
* @brief Interface between compiler library and applications
*
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LSCRIPT_RT_INTERFACE_H
#define LL_LSCRIPT_RT_INTERFACE_H
BOOL lscript_compile(char *filename, BOOL compile_to_mono, BOOL is_god_like = FALSE);
BOOL lscript_compile(const char* src_filename, const char* dst_filename,
const char* err_filename, BOOL compile_to_mono, const char* class_name, BOOL is_god_like = FALSE);
void lscript_run(const std::string& filename, BOOL b_debug);
#endif