Classes (OO)

[Slice]

Well, if you did use a generic tag for instances instead of the class it would solve some problems.

For example, you could create operators for assigning a value tagged "Instance:" to both floats and ints seamlessly.

The only downside would be functions can't be strict on what type of instance they want.

[Y_Less]

That is a very good thought!

[[HLF]Southclaw]

I'm finally learning about OOP (It's quite simple... no idea why I avoided it before assuming it was complex)

I just want to confirm a bit how this would be used in Pawn/SA:MP.

So for instance, I have some simple Create/Destroy script (Like objects (models, not OOP objects)) would it go something like this:

// Question: Where would this be declared/initiated?
// Could it just be intiated outside of code or would it have to be in a function of some sort
// Like main() or OnGamemode/FilterScriptInit?

class Item()
{
    new
        Float:iPosX,
        Float:iPosZ,
        Float:iPosY,
        iState,
        iSize;      

    method setPos(Float:x, Float:y, Float:z)
    {
        if(z > 100)return print("Too high");
        iPosX = x;
        iPosY = y;
        iPosZ = z;
        return 1; // I assume returns would work as expected
    }
    
    method setState(state)
    {
        if(state == 0 || state == 1 || state == 2 || state == 3)
        {
            iState = state;
        }
        else print("State error");
    }
    
    method setSize(size)
    {
        if(2 < size < 10)iSize = size;
        print("Size error");
    }
}

public OnFilterScriptInit()
{
    new Item:myItem = Item();

    myItem _ setPos(1.0, 2.0, 5.0);
    myItem _ setState(5); // Would print an error
    myItem _ setSize(7);
}

// What about inheriting? Is that possible or just out of the question?

class ItemVersion2 extends Item()
{
    new
        bool:isFlying,
        bool:isSwimming,
        bool:isRunning;
    
    method setRun()
    {
        isRunning = !isRunning;
    }
    // etc...
}

public OnSomething()
{
    new ItemVersion2:mySecondItem = ItemVersion2();
    
    mySecondItem _ setPos(2.0, 2.0, 4.0); // From 'Item'
    mySecondItem _ setRun();
    
    // Also, is direct variable changing possible?
    // Maybe not for the inherited variables, just in general
    
    mySecondItem _ isFlying = true;
}

Sorry for all the questions, I'm probably just thinking too far out the box! I'm kind of new to OOP and I'm not entirely sure how you do these things! But for all I know it could be possible, you've done some pretty good things with Pawn that I would never have thought to be possible


And I'm glad I understand how OOP/Classes work now, I can appreciate this even more!

[Y_Less]

Yes, but there's no "extends" currently - I can't think of a way to do that at all. The closest there is would be membership instead.

[Y_Less]

I'm moving some files about so I thought I would post what little code I had written ages ago here:

// VERY EXPERIMENTAL AND INCOMPLETE CODE!  DO NOT USE CURRENTLY!

#include "y_malloc"
#include "y_inline"

#define method%0(%1) OO_Add(#%0);inline%0(%1)

enum E_OO_CLASS_DATA
{
    E_OO_CLASS_DATA_NAME[32 char],
    //E_OO_CLASS_DATA_METHOD_START,
    E_OO_CLASS_DATA_SIZE
}

enum E_OO_METHOD_DATA
{
    //E_OO_METHOD_DATA_NAME[32 char],
    //E_OO_METHOD_DATA_SPECIFIER,
    E_OO_METHOD_DATA_PARENT,
    // Point to the next method with the same name.  Methods can NEVER be
    // removed (they're static compiled code), so we can just loop through the
    // list linerarly.
    E_OO_METHOD_DATA_SAME,
    // Store the y_inline data locally.
    E_OO_METHOD_DATA_INLINE[E_CALLBACK_DATA]
    //E_OO_METHOD_DATA_PTR
}

#define MAX_OO_METHODS (16)
#define MAX_OO_CLASSES (16)

static stock
    // Temporary storage to put stack variables in.
    YSI_gsMethods,
    YSI_gsStack[256],
    YSI_gsClassData[MAX_OO_CLASSES][E_OO_CLASS_DATA],
    YSI_gsMethodData[MAX_OO_CLASSES * MAX_OO_METHODS][E_OO_METHOD_DATA];

stock OO_StoreParams(GLOBAL_TAG_TYPES:...)
{
    // This function was surprisingly easy to write!  As was the required
    // y_inline "Callback_Array" function - I added just ONE "LOAD.I", but now
    // public functions don't work through that system (not that I really care -
    // they make no sense in OO anyway).
    new
        num = numargs() - 1,
        from,
        to;
    #emit LCTRL      5
    #emit ADD.C      12
    #emit STOR.S.pri from
    #emit CONST.pri  YSI_gsStack
    #emit STOR.S.pri to
    while (num--)
    {
        #emit LREF.S.pri from
        #emit SREF.S.pri to
        from += 4;
        to += 4;
    }
}

static stock OO_GetClass(that)
{
    return 0;
}

stock operator-(CTest:that, __Methods:matches)
{
    new
        cls = OO_GetClass(that);
    while (matches != __Methods:-1)
    {
        if (YSI_gsMethodData[_:matches][E_OO_METHOD_DATA_PARENT] == cls)
        {
            // Found the correct matching function name.
            // TODO: Code rewriting.
            Callback_Array(YSI_gsMethodData[_:matches][E_OO_METHOD_DATA_INLINE], YSI_gsStack);
            return 0;
        }
        matches = __Methods:YSI_gsMethodData[_:matches][E_OO_METHOD_DATA_SAME];
    }
    // Didn't find the correct method.
    return cellmin;
}

//stock OO_

stock OO_Add(const string:method[])
{
    new
        result[E_CALLBACK_DATA];
    //if (Callback_Get(callback_tag:method, YSI_gsMethodData[YSI_gsMethods][E_OO_METHOD_DATA_INLINE])
    if (Callback_Get(callback_tag:method, result))
    {
        printf("Found method %s", method);
    }
}



CTest:CTest()
{
    for (new __memory = 0, __loop; ; ++__loop)
    {
        if (__loop)
        {
            // Allocate the data.
            return;
        }
        else
        {
            for (new CTest:__this, __padding[5]; !__this; ++__this)
            {
                // This is where the main constructor code goes.
                new
                    mVar1 = 10,
                    mVar2 = 20,
                    mVar3 = 30;
                
                static
                    smInAllClasses = 40;
                
                method AddOne()
                {
                    mVar1 += 1;
                }
                
                method AddTwo()
                {
                    mVar2 += 2;
                }
                printf("loop");
            }
        }
    }
}

/*
#define _DEBUG 7

#include <a_samp>
#include <YSI\y_malloc>
#include <YSI\y_inline>
#include <YSI\y_oo>

Get(callback:callback, ...)
{
    new
        result[E_CALLBACK_DATA],
        arr[] = {44, 45, 46},
        num = numargs() - 1,
        tmp,
        addr;
    #emit LCTRL      5
    #emit ADD.C      16
    #emit STOR.S.pri tmp
    #emit ADDR.pri   arr
    #emit STOR.S.pri addr
    while (num--)
    {
        #emit LREF.S.pri tmp
        #emit SREF.S.pri addr
        tmp += 4;
        addr += 4;
    }
    Callback_Get(callback, result);
    Callback_Call(result, 42, 43, 44);
    Callback_Array(result, arr);
}

main()
{
    print("\n----------------------------------");
    print(" Blank Gamemode by your name here");
    print("----------------------------------\n");
    inline Hello(a, b, c)
    {
        printf("%d %d %d", a, b, c);
    }
    Get(using inline Hello, 77, 78, 79);
    CTest();
}
*/

The commented stuff at the end (IIRC) does actually work, but I can't remember what I was doing at the minute. The "CTest" "class" is currently expanded and contains the code that the macros should end up with.

[Gamer_Z]

this stuff is very cool, but isn't it -by the time you create all this - easier/faster to just make a custom compiler which generates sa-mp compatible output(amx) (while maintaining compatibility with current scripts)?

SA-MP won't change the pawn version anymore, At least I think so.

I have a failed attempt at a custom pre-processor.. but it's not a compiler so there is a difference.

[Y_Less]

A compiler is A LOT of work - serious amounts! I would have liked to have written an LLVM front/back end for PAWN/P-code, but don't have the time.

[Gamer_Z]

Originally Posted by Y_Less

A compiler is A LOT of work - serious amounts! I would have liked to have written an LLVM front/back end for PAWN/P-code, but don't have the time.

Hmm my words sounded a bit too big I think, I had in mind modifing the current pawn compiler :P
I read about LLVM on wiki but I still don't understand it. What's it all about? Standalone compiler or something that generates some output and passes the remaining stuff onto the original compiler?

[Blackazur]

That is nice.

[Meta]

This looks nice