[Potato Uno]

Perfect. Thanks!

[Impact123]

I recently found out two incompatibilities with old code and thought I let you know about it. You can use this and this to check yourself.

PHP Code:

stock MyFunction(client, MyEnum:data)
{
}

enum MyEnum
{
}; 


It compiles if the enum is defined before it's used.

PHP Code:

public OnPluginStart()
{
    SomeFunc(10);
}

SomeFunc(size)
{
    new String:buffer[size][1024];
    new size2 = sizeof(buffer[]);
    #pragma unused size2
} 


It compiles when size is changed to a static number, this might help in finding out what's causing it.

[BAILOPAN]

@Impact123 - Thanks, I will take a look at the first bug. The second example will probably not be fixed (at least, not for 1.7). New-style syntax does not support partial fixed-length arrays, that is, a nested array either contains all fixed-length arrays or all indeterminate arrays. The new behavior of sizeof reflects that. The intent is to have code like,

PHP Code:

static const int kBufferSize = 1024;

void SomeFunc(int size)
{
    char buffer[size][kBufferSize];
} 


[Impact123]

Here's another thing i found so far.

PHP Code:

stock static SomeStaticStock()
{
} 


It compiles if the static keyword is omitted, or, as asherkin noted below, the order is switched.

Edit: This can be ignored, see here.

[asherkin]

I believe static needs to be before stock.

[nergal]

may i ask why there's no official IDE for sourcepawn? ;3

[Impact123]

@asherkin
Yes and no. I searched a little bit and found this commit that seems to have fixed it.
I'm an idiot for not testing this with the newest compiler.

[BAILOPAN]

The *intended* grammar is "static" "stock", I had to cave in to older plugins unfortunately.

Evidence suggests that a good IDE takes a few hundred million dollars and about 10 years of development. I checked under my couch and couldn't find that much money. I'll check under the cushions a second time, but until then there's lots of very good editors out there (Sublime is popular).

[Exolent[jNr]]

So I stumbled across the feature that you can chain methodmaps (see below).

Spoiler

#include <sourcemod>

enum Chain
{
    INVALID_CHAIN = -1
};

methodmap Chain
{
    public Chain Do()
    {
        // Some other code
        return this;
    }
};

public Plugin myinfo =
{
    name = "",
    author = "",
    version = "",
    description = "",
    url = ""
};

public void OnPluginStart()
{
    Chain test = view_as<Chain>(1);

    test.Do().Do().Do();
}

I think this would be useful to implement in some of the methodmaps that come with sourcemod, such as StringMap. Of course, this would only work with functions where return value isn't needed.

Here would be an example:

Spoiler

void SomeFunction()
{
    StringMap foo = new StringMap();

    int value;
    foo.SetValue("bar", 1).SetString("full", "foobar").GetValue("bar", value);
}

This wouldn't be difficult to change in the current methodmaps for at least the functions that would normally return void, or even some like StringMap.GetValue() that returns a boolean. It could be modified to support default values like KeyValues.GetNum().

If not possible, I could even write up some extended methodmaps to apply this functionality under types (tags? I don't know the term here) like StringMapEx.

[BAILOPAN]

Yup, the accessor grammar is recursive so you can use the result of an accessor as an accessor.

SQL query building or something would be more amenable to this treatment - StringMap doesn't strike me as a good candidate. Chaining isn't to reduce keystrokes, it's to make a complex, compound operation *more* clear than it would have been otherwise. For example,

PHP Code:

  map.Set("a", 5)
  map.Set("b", 6) 


Is a lot more clear (and maintainable) than,

PHP Code:

  map.Set("a", 5).Set("b", 6) 


For other APIs this is not true. Imagine an API like,

PHP Code:

  builder = SQL.Select("first_name", "last_name")
  builder.From("table_a")
  builder.Join("table_b")
  builder.On("a_id = b_id")
  builder.Where("a_id > 500") 


If we chain it...

PHP Code:

  builder = SQL.Select("first_name", "last_name").
    From("table_a").
    Join("table_b").On("a_id = b_id").
    Where("a_id > 500") 


Now chaining is a huge improvement. A bunch of directly related, order-dependent operations are formatted to look exactly like the operation they perform.