y_scripting

/*----------------------------------------------------------------------------*-
                    ===============================
                     y_scripting - Access amx data
                    ===============================
Description:
    Allows a script access to information about itself, such as function names.
    This can be used for a range of things, including automatic callback hooking
    and testing.
Legal:
    Version: MPL 1.1

    The contents of this file are subject to the Mozilla Public License Version
    1.1 (the "License"); you may not use this file except in compliance with
    the License. You may obtain a copy of the License at
    http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on an "AS IS" basis,
    WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    for the specific language governing rights and limitations under the
    License.

    The Original Code is the SA:MP script information include.

    The Initial Developer of the Original Code is Alex "Y_Less" Cole.
    Portions created by the Initial Developer are Copyright (C) 2008
    the Initial Developer. All Rights Reserved.

    Contributors:
        ZeeX, koolk

    Thanks:
        Peter, Cam - Support.
        ZeeX - Very productive conversations.
        koolk - IsPlayerinAreaEx code.
        TheAlpha - Danish translation.
        breadfish - German translation.
        Fireburn - Dutch translation.
        yom - French translation.
        50p - Polish translation.
        Zamaroht - Spanish translation.
        Dracoblue, sintax, mabako, Xtreme, other coders - Producing other modes
            for me to strive to better.
        Pixels^ - Running XScripters where the idea was born.
        Matite - Pestering me to release it and using it.

    Very special thanks to:
        Thiadmer - PAWN.
        Kye/Kalcor - SA:MP.
        SA:MP Team past, present and future - SA:MP.
Version:
    1.0
Changelog:
    06/08/10:
        First version
-*----------------------------------------------------------------------------*/

#include <YSI\internal\y_version>

#include <YSI\internal\y_funcinc>

#define Scripting_FastString(%1,%2,%3,%4) \
    (((%1) << 0) | ((%2) << 8) | ((%3) << 16) | ((%4) << 24))

static stock Scripting_GetBase()
{
    static
        s_addr;
    if (!s_addr)
    {
        // Get the data offset.
        #emit LCTRL                     1
        #emit STOR.pri                  s_addr
        // Invert to get the prefix offset relative to the data.
        s_addr = -s_addr;
    }
    return s_addr;
}

static stock Scripting_GetPublics()
{
    static
        s_addr;
    if (!s_addr)
    {
        new
            addr;// = Scripting_GetBase();
        // Get the data offset.
        #emit LCTRL                     1
        #emit STOR.S.pri                addr
        // Invert to get the prefix offset relative to the data.
        addr = -addr;
        // Get the pointer to the publics.
        addr += 32;
        #emit LREF.S.pri                addr
        #emit STOR.pri                  s_addr
        // Adjust to get the relative offset.
        s_addr = s_addr + addr - 32;
    }
    return s_addr;
}

static stock Scripting_GetNatives()
{
    static
        s_addr;
    if (!s_addr)
    {
        new
            addr;// = Scripting_GetBase();
        // Get the data offset.
        #emit LCTRL                     1
        #emit STOR.S.pri                addr
        // Invert to get the prefix offset relative to the data.
        addr = -addr;
        // Get the pointer to the publics.
        addr += 36;
        #emit LREF.S.pri                addr
        #emit STOR.pri                  s_addr
        // Adjust to get the relative offset.
        s_addr = s_addr + addr - 36;
    }
    return s_addr;
}

static stock Scripting_GetLibraries()
{
    static
        s_addr;
    if (!s_addr)
    {
        new
            addr;// = Scripting_GetBase();
        // Get the data offset.
        #emit LCTRL                     1
        #emit STOR.S.pri                addr
        // Invert to get the prefix offset relative to the data.
        addr = -addr;
        // Get the pointer to the publics.
        addr += 40;
        #emit LREF.S.pri                addr
        #emit STOR.pri                  s_addr
        // Adjust to get the relative offset.
        s_addr = s_addr + addr - 40;
    }
    return s_addr;
}

static stock Scripting_GetPubvars()
{
    static
        s_addr;
    if (!s_addr)
    {
        new
            addr;// = Scripting_GetBase();
        // Get the data offset.
        #emit LCTRL                     1
        #emit STOR.S.pri                addr
        // Invert to get the prefix offset relative to the data.
        addr = -addr;
        // Get the pointer to the publics.
        addr += 44;
        #emit LREF.S.pri                addr
        #emit STOR.pri                  s_addr
        // Adjust to get the relative offset.
        s_addr = s_addr + addr - 44;
    }
    return s_addr;
}

static stock Scripting_GetTags()
{
    static
        s_addr;
    if (!s_addr)
    {
        new
            addr;// = Scripting_GetBase();
        // Get the data offset.
        #emit LCTRL                     1
        #emit STOR.S.pri                addr
        // Invert to get the prefix offset relative to the data.
        addr = -addr;
        // Get the pointer to the publics.
        addr += 48;
        #emit LREF.S.pri                addr
        #emit STOR.pri                  s_addr
        // Adjust to get the relative offset.
        s_addr = s_addr + addr - 48;
    }
    return s_addr;
}

stock Scripting_GetPubvarsCount()
{
    static
        s_count;
    if (!s_count)
    {
        // Get the difference in pointers.
        s_count = (Scripting_GetTags() - Scripting_GetPubvars()) / 8;
    }
    return s_count;
}

static stock Scripting_GetString(addr)
{
    new
        str[32],
        buffer,
        ch,
        idx;
    do
    {
        // Read 4 bytes.
        #emit LREF.S.pri                addr
        #emit STOR.S.pri                buffer
        // Write a character to the buffer.
        ch = buffer & 0xFF;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Write a character to the buffer.
        ch = buffer >> 8 & 0xFF;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Write a character to the buffer.
        ch = buffer >> 16 & 0xFF;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Write a character to the buffer.
        ch = buffer >>> 24;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Get the next address.
        addr += 4;
    }
    while (idx < 32);
    return str;
}

static stock Scripting_GetStringFast(addr, buffer)
{
    new
        str[32],
        ch,
        idx;
    do
    {
        // Write a character to the buffer.
        ch = buffer & 0xFF;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Write a character to the buffer.
        ch = buffer >> 8 & 0xFF;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Write a character to the buffer.
        ch = buffer >> 16 & 0xFF;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Write a character to the buffer.
        ch = buffer >>> 24;
        str[idx++] = ch;
        // Check for the end of the string.
        if (!ch) break;
        // Get the next address.
        addr += 4;
        // Read 4 bytes.
        #emit LREF.S.pri                addr
        #emit STOR.S.pri                buffer
    }
    while (idx < 32);
    return str;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetPublicsCount
Params:
    -
Return:
    Number of public functions in a script.
Notes:
    -

native Scripting_GetPublicsCount();

-*----------------------------------------------------------------------------*/

stock Scripting_GetPublicsCount()
{
    static
        s_count;
    if (!s_count)
    {
        // Get the difference in pointers.
        s_count = (Scripting_GetNatives() - Scripting_GetPublics()) / 8;
    }
    return s_count;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetNativesCount
Params:
    -
Return:
    Number of native functions in a script.
Notes:
    -

native Scripting_GetNativesCount();

-*----------------------------------------------------------------------------*/

stock Scripting_GetNativesCount()
{
    static
        s_count;
    if (!s_count)
    {
        // Get the difference in pointers.
        s_count = (Scripting_GetLibraries() - Scripting_GetNatives()) / 8;
    }
    return s_count;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetPublicFast
Params:
    idx - Index of the public to start at.
    buffer[32] - Buffer to store the name in.
    search - Pattern matching parameter.
Return:
    Index of next public.
Notes:
    Gets a string starting with a known 4 character sequence.

native Scripting_GetPublicFast(idx, buffer[32], search);

-*----------------------------------------------------------------------------*/

stock Scripting_GetPublicFast(idx, buffer[32], search)
{
    new
        count = Scripting_GetPublicsCount(),
        base = Scripting_GetBase(),
        pos = idx * 8 + 4 + Scripting_GetPublics(),
        addr;
    while (idx < count)
    {
        // Get the offset in the public records.
        // Get the pointer to the string.
        //pos += publics;
        // Get the address of the string.
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        //printf("%s", Scripting_GetString(Scripting_GetBase() + pos));
        //new
        //  str[32] = Scripting_GetString(base + pos));
        ++idx;
        addr += base;
        new
            chars;
        #emit LREF.S.pri                addr
        #emit STOR.S.pri                chars
        if (chars == search)
        {
            buffer = Scripting_GetStringFast(addr, chars);
            return idx;
        }
        pos += 8;
    }
    buffer[0] = '\0';
    return 0;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetPublicSuffix
Params:
    idx - Index of the public to start at.
    buffer[32] - Buffer to store the name in.
    search - Pattern matching parameter.
Return:
    Index of next public.
Notes:
    Gets a string ending with a known 4 character sequence.

native Scripting_GetPublicFast(idx, buffer[32], search);

-*----------------------------------------------------------------------------*/

stock Scripting_GetPublicSuffix(idx, buffer[32], search)
{
    new
        count = Scripting_GetPublicsCount(),
        base = Scripting_GetBase(),
        // Add 12 to get the pointer to the next string.
        pos = idx * 8 + 12 + Scripting_GetPublics(),
        addr;
    // This code will actually spill in to the natives record, but that's fine.
    while (idx < count)
    {
        // Get the address of the string.
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        ++idx;
        addr = addr + base - 5;
        //addr
        #emit LREF.S.pri                addr
        #emit STOR.S.pri                addr
        if (addr == search)
        {
            pos -= 8;
            #emit LREF.S.pri            pos
            #emit STOR.S.pri            addr
            addr += base;
            buffer = Scripting_GetString(addr);
            return idx;
        }
        pos += 8;
    }
    buffer[0] = '\0';
    return 0;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetNativeFast
Params:
    idx - Index of the native to get.
    buffer[32] - Buffer to store the name in.
    search - Pattern matching parameter.
Return:
    Index of next native.
Notes:
    -

native Scripting_GetNativeFast(idx, buffer[32], search);

-*----------------------------------------------------------------------------*/

stock Scripting_GetNativeFast(idx, buffer[32], search)
{
    new
        count = Scripting_GetNativesCount(),
        base = Scripting_GetBase(),
        pos = idx * 8 + 4 + Scripting_GetNatives()
        addr;
    while (idx < count)
    {
        // Get the offset in the public records.
        new
        // Get the pointer to the string.
        //pos += publics;
        // Get the address of the string.
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        //printf("%s", Scripting_GetString(Scripting_GetBase() + pos));
        //new
        //  str[32] = Scripting_GetString(base + pos));
        ++idx;
        addr += base;
        new
            chars;
        #emit LREF.S.pri                addr
        #emit STOR.S.pri                chars
        if (chars == search)
        {
            buffer = Scripting_GetStringFast(addr, chars);
            return idx;
        }
        pos += 8;
    }
    buffer[0] = '\0';
    return 0;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetPublic
Params:
    idx - Index of the public to get.
    buffer[32] - Buffer to store the name in.
    search[] - Optional pattern matching parameter.
Return:
    Index of next public.
Notes:
    -

native Scripting_GetPublic(idx, buffer[32], search[] = "");

-*----------------------------------------------------------------------------*/

stock Scripting_GetPublic(idx, buffer[32], search[] = "")
{
    new
        count = Scripting_GetPublicsCount(),
        base = Scripting_GetBase(),
        pos = idx * 8 + 4 + Scripting_GetPublics(),
        addr;
    while (idx < count)
    {
        // Get the offset in the public records.
        // Get the pointer to the string.
        //pos += publics;
        // Get the address of the string.
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        //printf("%s", Scripting_GetString(Scripting_GetBase() + pos));
        //new
        //  str[32] = Scripting_GetString(base + pos));
        ++idx;
        buffer = Scripting_GetString(base + addr);
        if (search[0] == '\0' || strfind(buffer, search) != -1)
        {
            return idx;
        }
        pos += 8;
    }
    buffer[0] = '\0';
    return 0;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetNative
Params:
    idx - Index of the native to get.
    buffer[32] - Buffer to store the name in.
    search[] - Optional pattern matching parameter.
Return:
    Index of next native.
Notes:
    -

native Scripting_GetNative(idx, buffer[32], search[] = "");

-*----------------------------------------------------------------------------*/

stock Scripting_GetNative(idx, buffer[32], search[] = "")
{
    new
        count = Scripting_GetNativesCount(),
        base = Scripting_GetBase(),
        pos = idx * 8 + 4 + Scripting_GetNatives(),
        addr;
    while (idx < count)
    {
        // Get the offset in the public records.
        // Get the pointer to the string.
        //pos += publics;
        // Get the address of the string.
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        //printf("%s", Scripting_GetString(Scripting_GetBase() + pos));
        //new
        //  str[32] = Scripting_GetString(base + pos));
        ++idx;
        buffer = Scripting_GetString(base + addr);
        if (search[0] == '\0' || strfind(buffer, search) != -1)
        {
            return idx;
        }
        pos += 8;
    }
    buffer[0] = '\0';
    return 0;
}

static stock Scripting_CompareString(str[], addr)
{
    new
        buffer,
        ch,
        idx;
    do
    {
        // Read 4 bytes.
        #emit LREF.S.pri                addr
        #emit STOR.S.pri                buffer
        ch = buffer & 0xFF;
        if (ch != str[idx++]) return false;
        if (!ch) break;
        ch = buffer >> 8 & 0xFF;
        if (ch != str[idx++]) return false;
        if (!ch) break;
        ch = buffer >> 16 & 0xFF;
        if (ch != str[idx++]) return false;
        if (!ch) break;
        ch = buffer >>> 24;
        if (ch != str[idx++]) return false;
        if (!ch) break;
        addr += 4;
    }
    while (idx < 32);
    return true;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetPublicPointer
Params:
    name[] - Name of the function to get the pointer for.
Return:
    Pointer or -1.
Notes:
    -

native Scripting_GetPublicPointer(name[]);

-*----------------------------------------------------------------------------*/

stock Scripting_GetPublicPointer(name[])
{
    new
        count = Scripting_GetPublicsCount(),
        base = Scripting_GetBase(),
        pos = 4 + Scripting_GetPublics(),
        addr;
    while (count--)
    {
        // Get the offset in the public records.
        // Get the pointer to the string.
        //pos += publics;
        // Get the address of the string.
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        //printf("%s", Scripting_GetString(Scripting_GetBase() + pos));
        //new
        //  str[32] = Scripting_GetString(base + pos));
        if (Scripting_CompareString(name, base + addr))
        {
            //pos = idx * 8 + publics;
            pos -= 4;
            // Get the pointer to the string.
            //pos += publics;
            // Get the address of the string.
            #emit LREF.S.pri            pos
            #emit STOR.S.pri            addr
            // It doesn't really matter what this is relative to, as long as the
            // usage in code is consistent.
            return addr;
        }
        pos += 8;
    }
    return -1;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_RedirectPublic
Params:
    name[] - Name of the function to move.
    pointer - Where to move it to.
Return:
    -
Notes:
    -

native Scripting_RedirectPublic(name[], pointer);

-*----------------------------------------------------------------------------*/

stock Scripting_RedirectPublic(name[], pointer)
{
    new
        count = Scripting_GetPublicsCount(),
        base = Scripting_GetBase(),
        pos = 4 + Scripting_GetPublics(),
        addr;
    while (count--)
    {
        // Get the offset in the public records.
        // Get the pointer to the string.
        //pos += publics;
        // Get the address of the string.
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        //printf("%s", Scripting_GetString(Scripting_GetBase() + pos));
        //new
        //  str[32] = Scripting_GetString(base + pos));
        if (Scripting_CompareString(name, base + addr))
        {
            //pos = idx * 8 + publics;
            pos -= 4;
            // Get the pointer to the string.
            //pos += publics;
            // Get the address of the string.
            #emit LOAD.S.pri            pointer
            #emit SREF.S.pri            pos
            // It doesn't really matter what this is relative to, as long as the
            // usage in code is consistent.
            return;
        }
        pos += 8;
    }
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_GetPublicVariable
Params:
    name[] - Name of the variable to get.
Return:
    -
Notes:
    -

native Scripting_GetPublicVariable(name[]);

-*----------------------------------------------------------------------------*/

stock Scripting_GetPublicVariable(name[])
{
    new
        count = Scripting_GetPubvarsCount(),
        base = Scripting_GetBase(),
        pos = 4 + Scripting_GetPubvars(),
        addr;
    while (count--)
    {
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        if (Scripting_CompareString(name, base + addr))
        {
            pos -= 4;
            // Get the address.
            #emit LREF.S.pri            pos
            #emit STOR.S.pri            addr
            // Get the value.
            #emit LREF.S.pri            addr
            #emit STOR.S.pri            pos
            return pos;
        }
        pos += 8;
    }
    return -1;
}

/*----------------------------------------------------------------------------*-
Function:
    Scripting_SetPublicVariable
Params:
    name[] - Name of the variable to set.
    value - Value to set it to.
Return:
    -
Notes:
    -

native Scripting_SetPublicVariable(name[], value);

-*----------------------------------------------------------------------------*/

stock Scripting_SetPublicVariable(name[], value)
{
    new
        count = Scripting_GetPubvarsCount(),
        base = Scripting_GetBase(),
        pos = 4 + Scripting_GetPubvars(),
        addr;
    while (count--)
    {
        #emit LREF.S.pri                pos
        #emit STOR.S.pri                addr
        if (Scripting_CompareString(name, base + addr))
        {
            pos -= 4;
            // Get the address.
            #emit LREF.S.pri            pos
            #emit STOR.S.pri            addr
            // Get the value.
            #emit LOAD.S.pri            value
            #emit SREF.S.pri            addr
            return pos;
        }
        pos += 8;
    }
    return -1;
}