[client21]

PHP Code:

public void OnPluginStart()
{
    ArrayList a = new ArrayList();
    Function f = GetFunctionByName(GetMyHandle(), "OnPluginStart");

    // error 130: cannot coerce functions to values
    a.Push(f); 

    // warning 237: coercing functions to and from primitives is unsupported
    // and will be removed in the future
    a.Push(view_as<int>(f));
} 


Are you seriously? Is that really all I can do? :

PHP Code:

public void OnPluginStart()
{
    ArrayList a = new ArrayList();
    Function f = GetFunctionByName(GetMyHandle(), "OnPluginStart");
    DataPack pack = new DataPack();
    pack.WriteFunction(f);
    a.Push(pack);
} 


Very sad

[MAGNAT2645]

You can also use PrivateForward with Call_StartForward.

public void OnPluginStart()
{
	ArrayList a = new ArrayList();
	PrivateForward hFwd = new PrivateForward( ET_Ignore );
	hFwd.AddFunction( null, GetFunctionByName( null, "OnPluginStart" ) );
	a.Push( hFwd );
}

[client21]

Originally Posted by MAGNAT2645 You can also use PrivateForward with Call_StartForward.

Yes, this is also a way, but it still looks silly.
It feels like PushFunction method was planned, but forgotten.
At the moment, there is still such a way (it works) (by Kailo) :

PHP Code:

int Extractor(int[] anchor)
{
    // Stack structure
    // anchor[0] | 0 | old_frame | argn | func
    return anchor[4];
}

int FuncToInt(Function func)
{
    if (func) {} // symbol is never used
    int anchor[1];
    return Extractor(anchor);
}

Function FuncExtractor(Function[] anchor)
{
    // Stack structure
    // anchor[0] | 0 | old_frame | argn | func
    return anchor[4];
}

Function IntToFunc(int func)
{
    if (func) {} // symbol is never used
    Function anchor[1];
    return FuncExtractor(anchor);
}

public void OnPluginStart()
{
    static int t = 0;
    if (++t == 1)
    {
        Handle plugin = GetMyHandle();
        
        Function f = GetFunctionByName(plugin, "OnPluginStart");
        int i = FuncToInt(f);
        
        Call_StartFunction(plugin, IntToFunc(i));
        Call_Finish();
    }
    else {
        PrintToServer("works"); // yes, works
    }
} 


[MAGNAT2645]

As many have said you shouldn't convert functions to/from int since int is not that big so at some point it could break function addresses i think.

[client21]

Originally Posted by MAGNAT2645 As many have said you shouldn't convert functions to/from int since int is not that big so at some point it could break function addresses i think.

I don't think so.

PHP Code:

void PackFunction(cell_t function); 


cell_t = 4 bytes (max value = unsigned int)
int i = StringToInt("4294967295"); // max value = unsigned int
PrintToServer("%u", i);

----

I can also add that the developers forgot to add another method like:
int FetchUInt(int field, DBResult &result=DBVal_Error)

Or:
int FetchInt(int field, DBResult &result=DBVal_Error, bool uint = false)

Because FetchInt can't return unsigned int and we must do: FetchString + StringToInt

[MAGNAT2645]

SourcePawn doesn't support uint as i know (at least most of functions work with signed integer). There's only int (which is signed, from −2147483648 to 2147483647)

EDIT: Maybe i was wrong, i don't really know about unsigned integers, but i know that SourcePawn supports only 32-bit integers.

[asherkin]

Originally Posted by client21 I don't think so. PHP Code: void PackFunction(cell_t function);

You need to decouple the API from the implementation in your head. The SourcePawn language rules were changed to consider Function as a separate type (like char[]) rather than a specialised int (like float) as future work to support closures will require “fat” function references that are larger than 4 bytes.

At the same time data structure that could safely contain these new function references in the future were updated with methods to get/set them — DataPack met the requirements as each entry is a) tagged with type info, so a round trip is type safe, and b) variable sized based on the implementation, so that when the work is done that requires fat references it is all internal changes. The work to implement closures has not been done yet, so obviously internally everything is still a cell_t at the moment.

ArrayList meets neither of those requirements, it has no internal typing and the block size is user-controlled.