Parses an input string of GML code and pushes the resulting tokens into a ds_list (outList).

The list will not be cleared prior, so you should ds_list_clear it yourself unless you are trying to concatenate results from several parse calls.

Returns the number of tokens added to the list.

This global variable stores the number of lines found during the last call to gml_string_parse. Note that it does not count for any pre-existing tokens that might have been in your list.

This function does a post-process pass on a token list to do a few things:

• Highlights local variables (var)
• Highlights global variables (globalvar)
• Highlights macros (#macro)
• Highlights enums (enum <name> { ...constructs })
• Highlights locally defined scripts (#define)

Processing time is usually similar to that of initial parse operation.

tokens = ds_list_create();
gml_string_parse("var i = 1, k = 2; return i + k;", tokens);
gml_string_hint_locals(tokens);

Draws a list of tokens onto screen.

colors is an array of colors per token kind.

fonts (optional) is an array of fonts per token kind.

tokens = ds_list_create();
gml_string_parse("return 1;", tokens);
colors = array_create(gml_string_kind.sizeof, $C0C0C0);
colors[gml_string_kind.keyword] = $71BBFF;

// ...later in Draw event
gml_string_draw(10, 10, tokens, colors);

Like gml_string_draw, but skips drawing tokens outside the ytop..ybot range.

This is handy if you are drawing snippets substantially larger than the viewport, as it'll offer better performance.

var code = string_repeat("// hello!" + chr(13) + chr(10), 100);
tokens = ds_list_create();
gml_string_parse(code, tokens);
colors = array_create(gml_string_kind_sizeof, $C0C0C0);
colors[gml_string_kind.comment] = $5b995b;

// ...later in Draw event
draw_rectangle(0, 50, 200, 150, true);
gml_string_draw_culled(10, 10 - current_time / 100, tokens, 50, 150, colors);

Target GML version.
Can be set to 1 for GMS1 or 2 for GMS2.
This affects how strings will be parsed.

If you do not want tab characters in tokenized output (e.g. GameMaker cannot draw them via draw_text), you can set this variable to a sequence of spaces to use instead.

gml_string_api_tab_string = "    "; // (4 spaces - default)
gml_string_api_tab_string = undefined; // (keep tab characters)

A map with key-value pairs for matching names to token types.

By default this is pre-populated with GML keywords, but you may set additional key-value pairs in it to also highligh your desired functions/constants/variables/etc.

gml_string_api_ident_map[?"abs"] = gml_string_kind_function;
gml_string_api_ident_map[?"fps"] = gml_string_kind_variable;
gml_string_api_ident_map[?"c_white"] = gml_string_kind_constant;
// ...and so on

Maps can be assigned into this map to have gml_string know about global enums during hinting pass.

Values inside inner maps do not matter - gml_string will only run ds_map_exists on them.

Note that you should still assign entries into gml_string_api_ident_map.

gml_string_api_ident_map[?"MyEnum"] = gml_string_kind_enum;
var e = ds_map_create();
e[?"A"] = true;
e[?"B"] = true;
gml_string_api_enum_map[?"MyEnum"] = e;

This ds_map specifies keywords that immediately end processing of local variable declarations (var). You shouldn't have to touch it unless you are using custom keywords and also do not require semicolons.

Adds entries to gml_string_api_ident_map as per definitions in GameMaker fnames-style format. This can be more convenient than assigning identifiers to gml_string_api_ident_map.

The following will be recognized:

• variable_name
• constant_name#
• function_name(

For example,

gml_string_api_load("custom.txt");

would load API entries from a "custom.txt" file.

Like above, but takes fnames content from a string instead.

For example,

gml_string_api_load_from_string(@"
my_func()
my_const#
my_var
");

Not included in the extension's normal output.
This can be used when manually adding tokens (e.g. to have a non-highlighted prefix/suffix).

Syntactically invalid characters
(e.g. if you were to have var pound_sign = £;, £ would be error-kind)

Spaces and tabs. Adjacent characters are joined together into single tokens.

"new line" token. These are not present after nesting tokens.

A single-line comment (// text)

A block comment (/* text */)

#define very specifically

Script name following a #define

Keywords, including operator-keywords

Curly brackets (as it is common to style them differently)

Actual operators and assisting tokens (;, :, (, )...)

Identifiers not recognized as keywords or other structures

Constants (such as c_white)

Built-in variables (such as x)

Built-in functions (such as show_message)

User-defined scripts

Local variables (after running gml_string_hint_locals)

Variables marked via globalvar

GMS2 #macros

Enum names (E for E.A)

Enum fields (A in E.A)

String literals

Numeric literals (1, 1.2, $12, 0x12)

Number of "built-in" token types.
Custom token types should count up from this.

Returns what kind of token this is (e.g. gml_string_kind_number for 4.2).

Changes the token's kind.

Returns the token's text (e.g. "4.2" for 4.2).

Changes the token's text.

Returns whether a token is a "space" kind of token (spaces, new lines, comments).

Returns bracket depth "delta" (e.g. 1 for ( and -1 for )) for the token.
Supports the three kinds of brackets and begin/end. Returns 0 for non-brackets.

Returns a display name for the given token kind, e.g. "curly_bracket" for gml_string_kind_curly_bracket.

Converts a list of tokens into an array of lines, where each line is an array of tokens residing on that line.

If the optional lineCount argument is supplied, it will be used instead of iterating over the list to count the lines before allocating an array.
You can retrieve it from Note that supplying an incorrect lineCount may result in either operation taking longer than it should (due to re-allocating the array on out-of-bounds write) or gml_string_draw_nested crashing due to a missing array in an index.

Draws a 2d array of tokens that you've got from gml_string_nest.
Apart of performance improvements, acts identically to gml_string_draw_culled.

Example renderer function.

Takes a list of tokens and a CSS class prefix so

var tks = [];
gml_string.parse("return 1", tks);
console.log(gml_string.renderToHTML(tks, "gml"));

would give you

<span class="gmlKeyword">return</span> <span class="gmlNumber">1</span>

You are expected to have at least basic knowledge of HTML and how websites work.

1. Create a new directory on your website - called, for example, gml.

2. Upload gml_string.js (from "gml_string (for websites).zip") to that directory.

3. Create a stylesheet file in the same directory - called, for example, gml.css.

This will define how different code bits will look.

For something resembling the syntax highlighting in GameMaker IDE, you can use the following:

.gmlError { color: #f0f }
.gmlCommentLine, .gmlCommentBlock { color: #5B995B }
.gmlMacro, .gmlEnum, .gmlEnumField {
    color: #FF8080;
}
.gmlNumber { color: #FF8080 }
.gmlString { color: #FCF320 }
.gmlKeyword, .gmlCurlyBracket,
.gmlFunction, .gmlScript {
    color: #FFB871;
}
.gmlLocal { color: #FFF899 }
.gmlVariable { color: #58E55A }
.gmlHeaderMeta { color: #A7B }
.gmlHeaderName { color: #77BB5B }

And for light-mode websites, you can use the following (GM8.1-inspired):

.gmlError { color: red }
.gmlCommentLine, .gmlCommentBlock { color: #008000 }
.gmlKeyword, .gmlCurlyBracket {
	color: #00379B;
	font-weight: bold;
}
.gmlNumber, .gmlString { color: #00f }
.gmlLocal { color: #748 }
.gmlHeaderMeta, .gmlHeaderName { color: #0078AA }
.gmlScript { color: #808 }
.gmlFunction, .gmlMacro, .gmlVariable, .gmlEnum, .gmlEnumField {
    color: #990000;
}

4. Create a new JavaScript file in that same directory - called, for example, gml_highlight.js.

This will be the file responsible for loading the API and applying the syntax highlighter.

If you are putting your code in <pre> tags, it can go like this::

gml_string.API.loadFromString(`
is_real(val)
is_numeric(val)
is_string(val)
is_array(val)
// You can paste the entire `fnames` file from the runtime directory in this string
// Find its location via File - Preferences - Runtime Feeds
`);
function highlightCodeBlocks() {
	for (let el of document.querySelectorAll("pre:not(.gml)")) {
		el.classList.add(".gml");
		el.innerHTML = gml_string.renderToHTML(el.innerHTML, "gml");
	}
}
if (document.readyState == "loading") {
	document.addEventListener('DOMContentLoaded', highlightCodeBlocks);
} else highlightCodeBlocks();

5. Include the files in your page template(s).

The easiest would be to put everything inside your <head> tag:

<link rel="stylesheet" href="/gml/gml.css" />
<script src="/gml/gml_string.js"></script>
<script src="/gml/gml_highlight.js"></script>

As per nesting section, you will generally want to convert your token list to nested format if the line count is too high.

Although it may be very tempting to utilize this extension to create a code editor in GameMaker, you should be aware that there's much more to it than syntax highlighting;

Aside of actual editing, to allow editing particularly large files, you would eventually want to not re-highlight an entire file upon typing, and to do so over multiple frames.

Due to very large 1d arrays not actually being 1d in pre-2.3 versions of GMS, you can only have up to 32000 lines in a nested structure and up to 32000 tokens per such line.

Needless to say, this is far more than realistic use cases need, but if you do need more, you would want to look at the implementation and make a custom version that either writes lengths as prefixes (since arr[32003] accesses arr[1,3]), or structure it to add/remove lists to a list.