If you are using an outdated (8.0 or earlier) version of GameMaker, and are trying to utilize examples and snippets from more recent versions, or creating systems that are intended to work correctly across multiple versions, this is going to be useful.

Method

There are two primary methods of detecting argument count in pre-8.1 version, being ascending and descending loop.
Obviously,

Descending loop

This is a preferred method of finding number of arguments. Code is as follows:

var argc;
if (gamemaker_version < 810) {
    var v, c; c = 15
    repeat (16) {
        v = argument[c]
        if (is_string(v)) break
        if (v != 0) break
        c -= 1
    }
    argc = c + 1
} else argc = argument_count

... or a more compact version, if you're going to use if often:

var argc; if (gamemaker_version < 810) { var v; argc = 15; repeat (16) {
v = argument[argc]; if (is_string(v)) break; if (v != 0) break; argc -= 1
}; argc += 1 } else argc = argument_count

So, what's going on in there:

• Variable “argc” is defined. This is later to be used instead of argument_count to determine number of arguments.
• An “if” branch follows, depending on GameMaker version. Despite of what one would've thought, version numbers are actually 800 and 810 (no other options - constant has been added in 8.0 and went missing in GameMaker: Studio). For later versions, detection is pretty trivial, being assignment of argument_count to a variable.
• A slightly strangely looking repeat-loop is intended to loop through values [16, 15, 14, ..., 2, 1, 0].
• At each iteration, next argument is pulled by index, and check is performed - if it's either a string (default value for arguments is 0, number) or a non-zero number, program “breaks out of loop”.
• Argument number “argc” variable is set to value, one larger than last valid index (if argument[2] was non-zero, there were 3 arguments).

This method works faster when given many arguments, and it's results are reliable (it will miss if last argument is zero, however there's no way to avoid that case, as far as I know).

Ascending loop

This is a slightly different method of achieving the same goal. It wins some extra (probably not so meaningful on it's scale) performance at expense of a flaw:

var argc;
if (gamemaker_version < 810) {
    var v; argc = 0
    repeat (16) {
        v = argument[argc]
        if (is_real(v)) if (v == 0) break
        argc += 1
    }
} else argc = argument_count

It works similarly to above method, with exception of looping 'upwards' [0, 1, 2, ..., 13, 14, 15], and having slightly different exit condition.
Looping from first argument, it will perform less iterations than first method, if script is given only a few arguments.
It's flaw is, that if a zero argument is passed “in the middle” of argument list, it will stop at that point, thus loosing further arguments.
Though, if it is certain that such conditions will be satisfied, and number of arguments is kept low (e.g. script takes 3-5 strings), this will work faster than descending loop.

Usage

Extra variable

This is method of usage, illustrated in both of examples above. Going this way, you need to replace all occurrences of “argument_count” by “argc”. Such can take some time, but is a preferred method.

If you are porting a script from version 8.1 to an earlier version, you can as well just replace “argc” by “argument_count”, and throw out “else” branch of condition.
And there's even a few ways of doing that, each with it's own pros and cons.

Overriding “instance” variable

After doing replacement, mentioned above, you can as well leave it as-is. This allows to simplify process to copying & pasting code into start of each of affected scripts, at expense of “argument_count” variable “leaking” into instances, and possibly affecting forgotten code that uses it.

Global variable

Issue with extra variables in above method can be solved by making variable “argument_count” global. A downside here is, that declaration line will cause an error in >= 8.1, requiring it to be removed manually.

Local variable

This method involves declaring “argument_count” as a local variable, “var”, and will actually get scripts compatible while still keeping modification process simple. However, a problem comes - alike to global variables, declaration will have to be removed for >= 8.1... except this time it will need to be removed separately in every affected script.

Pre-8.0 versions

It may not be obvious, but to work-around the fact that versions, prior to GameMaker 8.0, did not have a gamemaker_version constant, you can just make your own (a constant, or globalvar).

Example of usage

As an example of usage, a script, that uses first method to display all given arguments in a message, follows:

/// show_values(...values)
// Displays a message, listing all given values
var argc;
if (gamemaker_version < 810) {
    var v, c; c = 15
    repeat (16) {
        v = argument[c]
        if (is_string(v)) break
        if (v != 0) break
        c -= 1
    }
    argc = c + 1
} else argc = argument_count
//
if (argc == 0) return show_message('(no values given)') // no arguments
var i, r;
r = string(argument[0]) // first argument
for (i = 1; i < argc; i += 1) { // other arguments
    r += ', ' + string(argument[i])
}
return show_message('[' + r + ']')

Related posts:

• Variable references in GameMaker (2023 edition)
• GameMaker: Smooth pixel-perfect camera
• GameMaker: 2.3 syntax in details
• A small guide on writing interpreters, part 2
• GameMaker: getting the arguments-array