gdharness 1.2.25 → 1.2.26

package/build/godot/addons/gdharness_runtime/runtime_pad.gd

@@ -0,0 +1,150 @@
+extends RefCounted
+
+## What reaches the running game the way a controller reaches it: a button pressed and a stick or
+## trigger moved, as the events a pad sends.
+##
+## The events themselves rather than the actions bound to them: a game reading the pad in _input or
+## _unhandled_input looks for InputEventJoypadButton and InputEventJoypadMotion, and an action
+## reached it as an InputEventAction it never reads, so a controller layout could only be driven by
+## calling the game's own methods. The engine still fires the actions bound to a button from these.
+
+const Read = preload("reading.gd")
+
+## Controller buttons by the names Godot gives them, for a caller naming one rather than numbering it.
+const JOY_BUTTONS: Dictionary[String, int] = {
+	"a": JOY_BUTTON_A,
+	"b": JOY_BUTTON_B,
+	"x": JOY_BUTTON_X,
+	"y": JOY_BUTTON_Y,
+	"back": JOY_BUTTON_BACK,
+	"guide": JOY_BUTTON_GUIDE,
+	"start": JOY_BUTTON_START,
+	"left_stick": JOY_BUTTON_LEFT_STICK,
+	"right_stick": JOY_BUTTON_RIGHT_STICK,
+	"left_shoulder": JOY_BUTTON_LEFT_SHOULDER,
+	"right_shoulder": JOY_BUTTON_RIGHT_SHOULDER,
+	"dpad_up": JOY_BUTTON_DPAD_UP,
+	"dpad_down": JOY_BUTTON_DPAD_DOWN,
+	"dpad_left": JOY_BUTTON_DPAD_LEFT,
+	"dpad_right": JOY_BUTTON_DPAD_RIGHT,
+	"misc1": JOY_BUTTON_MISC1,
+	"paddle1": JOY_BUTTON_PADDLE1,
+	"paddle2": JOY_BUTTON_PADDLE2,
+	"paddle3": JOY_BUTTON_PADDLE3,
+	"paddle4": JOY_BUTTON_PADDLE4,
+	"touchpad": JOY_BUTTON_TOUCHPAD,
+}
+
+## Stick and trigger axes by the names Godot gives them.
+const JOY_AXES: Dictionary[String, int] = {
+	"left_x": JOY_AXIS_LEFT_X,
+	"left_y": JOY_AXIS_LEFT_Y,
+	"right_x": JOY_AXIS_RIGHT_X,
+	"right_y": JOY_AXIS_RIGHT_Y,
+	"trigger_left": JOY_AXIS_TRIGGER_LEFT,
+	"trigger_right": JOY_AXIS_TRIGGER_RIGHT,
+}
+
+var _host: Node
+
+
+func _init(host: Node) -> void:
+	_host = host
+
+
+## Presses a controller button, and lets go of it again unless asked to hold it, as a key press does:
+## a button left down is a press that never ends, and everything reading it goes on seeing it.
+func inject_joypad_button(params: Dictionary) -> Dictionary:
+	var given: Variant = params.get("button", null)
+	var button: int = _named_or_numbered(given, JOY_BUTTONS, JOY_BUTTON_MAX)
+	if button < 0:
+		return {"type": "error", "message": _not_one_of("button", given, JOY_BUTTONS, JOY_BUTTON_MAX)}
+	var device: int = Read.as_int(params.get("device", 0), 0)
+	var held: bool = Read.as_bool(params.get("pressed", true), true)
+	var whole: bool = not params.has("pressed")
+
+	Input.parse_input_event(_button(button, device, whole or held))
+	if whole:
+		# A frame between the halves, as a key has, so a game that acts on the press and one that
+		# acts on the release each get a frame to do it in.
+		await _host.get_tree().process_frame
+		Input.parse_input_event(_button(button, device, false))
+		await _host.get_tree().process_frame
+
+	return {
+		"type": "input_injected",
+		"input_type": "joypad_button",
+		"button": button,
+		"button_name": _name_of(button, JOY_BUTTONS),
+		"device": device,
+		"pressed": held and not whole,
+		"whole": whole,
+	}
+
+
+## Moves a stick or trigger axis to a value, where it stays until another motion moves it, as a
+## stick held over does.
+func inject_joypad_motion(params: Dictionary) -> Dictionary:
+	var given: Variant = params.get("axis", null)
+	var axis: int = _named_or_numbered(given, JOY_AXES, JOY_AXIS_MAX)
+	if axis < 0:
+		return {"type": "error", "message": _not_one_of("axis", given, JOY_AXES, JOY_AXIS_MAX)}
+	if not params.has("value"):
+		return {"type": "error", "message": "joypad_motion needs value, where the axis is, -1 to 1"}
+	var value: float = Read.as_float(params.get("value"), 0.0)
+	if value < -1.0 or value > 1.0:
+		return {
+			"type": "error", "message": "value %s is outside -1 to 1, the whole travel of an axis" % value
+		}
+	var device: int = Read.as_int(params.get("device", 0), 0)
+
+	var event: InputEventJoypadMotion = InputEventJoypadMotion.new()
+	event.axis = axis as JoyAxis
+	event.axis_value = value
+	event.device = device
+	Input.parse_input_event(event)
+
+	return {
+		"type": "input_injected",
+		"input_type": "joypad_motion",
+		"axis": axis,
+		"axis_name": _name_of(axis, JOY_AXES),
+		"value": value,
+		"device": device,
+	}
+
+
+static func _button(button: int, device: int, down: bool) -> InputEventJoypadButton:
+	var event: InputEventJoypadButton = InputEventJoypadButton.new()
+	event.button_index = button as JoyButton
+	event.pressed = down
+	event.device = device
+	return event
+
+
+## [param given] as one of [param names], or as a number below [param count], or -1 for neither.
+static func _named_or_numbered(given: Variant, names: Dictionary[String, int], count: int) -> int:
+	if given is String:
+		var named: String = given
+		return Read.as_int(names.get(named.strip_edges().to_lower(), -1), -1)
+	if given is int or given is float:
+		var number: int = Read.as_int(given, -1)
+		return number if number >= 0 and number < count else -1
+	return -1
+
+
+static func _not_one_of(
+	argument: String, given: Variant, names: Dictionary[String, int], count: int
+) -> String:
+	return (
+		"%s %s is not one: give its name, one of %s, or its number, 0 to %d"
+		% [argument, JSON.stringify(given), ", ".join(PackedStringArray(names.keys())), count - 1]
+	)
+
+
+## The name [param number] goes by in [param names], or empty for a number with none.
+static func _name_of(number: int, names: Dictionary[String, int]) -> String:
+	for named: String in names:
+		if names[named] == number:
+			return named
+	return ""

package/build/godot/addons/gdharness_runtime/runtime_pad.gd.uid

@@ -0,0 +1 @@
+uid://cj164fjnsnn1y

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -718,6 +718,11 @@ func get_metrics(params: Dictionary) -> Dictionary:
 		"render_total_objects": Performance.get_monitor(Performance.RENDER_TOTAL_OBJECTS_IN_FRAME),
 		"render_total_primitives": Performance.get_monitor(Performance.RENDER_TOTAL_PRIMITIVES_IN_FRAME),
 		"render_total_draw_calls": Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME),
+		# The GPU's half of the game's memory, in bytes, which memory_static does not count: a game
+		# committing 2.3 GB answered 298 MB there, and the rest could not be asked about.
+		"render_video_mem_used": Performance.get_monitor(Performance.RENDER_VIDEO_MEM_USED),
+		"render_texture_mem_used": Performance.get_monitor(Performance.RENDER_TEXTURE_MEM_USED),
+		"render_buffer_mem_used": Performance.get_monitor(Performance.RENDER_BUFFER_MEM_USED),
 	}
 
 	if metrics.is_empty():

package/build/godot/operations/import_pipeline.gd

@@ -46,6 +46,9 @@ const IMPORTER_VERSIONS: Dictionary[String, int] = {"scene": 1, "animation_libra
 ## The VRAM compression formats a project can ask for, each behind its
 ## `rendering/textures/vram_compression/import_<format>` setting.
 const VRAM_FORMATS: Array[String] = ["s3tc_bptc", "etc2_astc"]
+## Options keyed by OpenType tags, by the importer that holds them. The engine keys them by the tag as
+## an int, which a caller can also name, as "liga" for ligatures.
+const OPENTYPE_OPTIONS: Dictionary[String, Array] = {"font_data_dynamic": ["opentype_features"]}
 const EDITOR_DIRECTORY: String = "res://.godot/editor"
 const EDITOR_CACHE_PREFIX: String = "filesystem_cache"
 
@@ -177,6 +180,7 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		return _log.failure("Failed to parse import file: " + str(err))
 
 	# Every option checked before any is written, so a refused one leaves the sidecar as it was.
+	var importer: String = str(config.get_value("remap", "importer", ""))
 	var fitted_values: Dictionary = {}
 	var refused: Array[String] = []
 	for key: Variant in options:
@@ -184,6 +188,13 @@ func set_import_options(params: Dictionary) -> Dictionary:
 		var held: Variant = config.get_value("params", name, null)
 		var given: Variant = _values.deserialize_value(options[key])
 		var value: Variant = _as_option(_values.fitted(options[key], typeof(held)), held)
+		if value is Dictionary:
+			var entries: Dictionary = value
+			var keyed: Dictionary = _keyed_as_option(name, entries, held, importer)
+			if keyed.has("refused"):
+				refused.append(str(keyed["refused"]))
+				continue
+			value = keyed["value"]
 		# A number the option cannot hold whole is refused rather than truncated: 2.5 fitted to an
 		# enum option became 2, which is another setting.
 		var lossy: bool = (
@@ -227,6 +238,87 @@ static func _as_option(given: Variant, held: Variant) -> Variant:
 	return given
 
 
+## [param given] with the keys and values a dictionary option holds as ints made ints again.
+##
+## JSON names every key as a string and every number as a float, so a font's opentype_features was
+## written as {"1818847073": 0.0}. The importer hands that to FontFile.opentype_feature_overrides,
+## which keys features by their tag as an int, so the call reported success and the font kept its
+## ligatures. A key is an int where the importer keys the option by OpenType tags, or where every key
+## the option holds already is one; a value is an int where every value held is, or for a tag.
+## Answers the dictionary under value, or why it cannot be written under refused.
+static func _keyed_as_option(name: String, given: Dictionary, held: Variant, importer: String) -> Dictionary:
+	var tag_options: Array = OPENTYPE_OPTIONS.get(importer, [])
+	var tagged: bool = name in tag_options
+	var numbered_keys: bool = tagged or _all_ints(held, true)
+	var whole_values: bool = tagged or _all_ints(held, false)
+	if not numbered_keys and not whole_values:
+		return {"value": given}
+	var keyed: Dictionary = {}
+	for key: Variant in given:
+		var as_key: Variant = key
+		if numbered_keys:
+			as_key = _int_key(key, tagged)
+			if as_key == null:
+				var wanted: String = (
+					'OpenType tags, by name such as "liga" or as the number TextServer.name_to_tag gives'
+					if tagged
+					else "ints"
+				)
+				return {
+					"refused": "%s is keyed by %s, and %s is not one" % [name, wanted, JSON.stringify(key)]
+				}
+		var value: Variant = given[key]
+		if whole_values and value is float:
+			var number: float = value
+			if number == floorf(number):
+				value = int(number)
+		keyed[as_key] = value
+	return {"value": keyed}
+
+
+## [param key] as an int key, or null when it is not one: a whole number, written as a number or as
+## a string of digits, or where [param tagged], an OpenType tag's four characters.
+static func _int_key(key: Variant, tagged: bool) -> Variant:
+	if key is int:
+		return key
+	if key is float:
+		var number: float = key
+		if number != floorf(number):
+			return null
+		return int(number)
+	if not key is String:
+		return null
+	var text: String = key
+	if text.is_valid_int():
+		return text.to_int()
+	# Exactly four printable characters, since the engine reads a longer name by its first four and
+	# "ligatures" would quietly become "liga".
+	if tagged and text.length() == 4 and _printable(text):
+		return TextServerManager.get_primary_interface().name_to_tag(text)
+	return null
+
+
+static func _printable(text: String) -> bool:
+	for i: int in text.length():
+		var code: int = text.unicode_at(i)
+		if code < 0x20 or code > 0x7e:
+			return false
+	return true
+
+
+## Whether [param held] is a dictionary that is not empty and whose keys, or values, are all ints.
+static func _all_ints(held: Variant, keys: bool) -> bool:
+	if not held is Dictionary:
+		return false
+	var dictionary: Dictionary = held
+	if dictionary.is_empty():
+		return false
+	for item: Variant in dictionary.keys() if keys else dictionary.values():
+		if not item is int:
+			return false
+	return true
+
+
 # The names of the project's export presets, in the order export_presets.cfg holds them.
 static func _preset_names() -> Array[String]:
 	var names: Array[String] = []

package/build/godot/operations/input_actions.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -172,7 +173,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 	# Through ProjectSettings so the file is saved the way the editor saves it, header and
 	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
 	ProjectSettings.set_setting("input/" + action_name, action)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -205,7 +206,7 @@ func remove_input_action(params: Dictionary) -> Dictionary:
 			)
 		)
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 	return {"action_name": action_name, "removed": true}

package/build/godot/operations/plugins.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Patterns = preload("patterns.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 
 var _log: Log
 
@@ -171,11 +172,11 @@ static func _names_of(paths: Array[String]) -> Array[String]:
 func _save_enabled_paths(paths: Array[String]) -> Error:
 	if paths.is_empty():
 		ProjectSettings.set_setting("editor_plugins/enabled", null)
-		return ProjectSettings.save()
+		return ProjectFile.save()
 
 	# Kept in an Array[String] and converted here, because appending to a packed array answers with
 	# whether it worked and a project holding return_value_discarded at error level will not compile
 	# a script that drops that answer. The conversion is what matters: an Array[String] handed to
 	# set_setting is written as Array[String]([...]), which the editor does not read as a plugin list.
 	ProjectSettings.set_setting("editor_plugins/enabled", PackedStringArray(paths))
-	return ProjectSettings.save()
+	return ProjectFile.save()

package/build/godot/operations/project_config.gd

@@ -2,6 +2,7 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 const Log = preload("logger.gd")
+const ProjectFile = preload("project_file.gd")
 const Serialisation = preload("serialisation.gd")
 
 var _log: Log
@@ -124,12 +125,7 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 			)
 		final_value = type_convert(final_value, wanted)
 
-	ProjectSettings.set_setting(setting_path, final_value)
-	var err: Error = ProjectSettings.save()
-	if err != OK:
-		return _log.failure("Failed to save project.godot: " + error_string(err))
-
-	return {
+	var answer: Dictionary = {
 		"setting_path": setting_path,
 		"old_value": _values.serialize_value(old_value) if had_value else null,
 		"new_value": _values.serialize_value(final_value),
@@ -137,6 +133,18 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		"was_default": was_default,
 		"saved": true,
 	}
+	# The same value in the same type is no change, and the file is left alone: a save rewrites it
+	# whole. The type is compared as well, so an int setting the file holds as 50.0 is still put right.
+	if had_value and typeof(old_value) == typeof(final_value) and old_value == final_value:
+		answer["saved"] = false
+		answer["unchanged"] = true
+		return answer
+
+	ProjectSettings.set_setting(setting_path, final_value)
+	var err: Error = ProjectFile.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+	return answer
 
 
 # The type a setting wants, or TYPE_NIL where the engine names none and there is nothing to go on.
@@ -201,7 +209,7 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	# "Global Variable" column. Without it the node still comes up under the root; only the name
 	# stops resolving.
 	ProjectSettings.set_setting(setting, ("*" if global else "") + path)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -226,7 +234,7 @@ func remove_autoload(params: Dictionary) -> Dictionary:
 
 	var old_value: String = str(ProjectSettings.get_setting(setting))
 	ProjectSettings.set_setting(setting, null)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
@@ -275,7 +283,7 @@ func set_main_scene(params: Dictionary) -> Dictionary:
 	var old_main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
 
 	ProjectSettings.set_setting("application/run/main_scene", scene_path)
-	var err: Error = ProjectSettings.save()
+	var err: Error = ProjectFile.save()
 
 	if err != OK:
 		return _log.failure("Failed to save project settings: " + str(err))

package/build/godot/operations/project_file.gd

@@ -0,0 +1,202 @@
+extends RefCounted
+
+## project.godot written through the engine's own save, in the order the file already held.
+##
+## The engine writes each section's keys in the order it registered them, and an engine running a
+## script registers them in another order than the editor does, so a one-setting change moved lines
+## nobody touched across several sections and a commit of it read as a rewrite. The save is still the
+## engine's, for what only it gets right: the header, each value's text and dropping a key that is
+## back at its default. Only the order is taken from the file as it was.
+
+const PATH: String = "res://project.godot"
+
+
+## Saves the project's settings, keeping the sections and keys already in the file where they were.
+## A key or a section new to the file goes where the engine put it relative to its neighbours.
+static func save() -> Error:
+	var before: String = FileAccess.get_file_as_string(PATH)
+	var err: Error = ProjectSettings.save()
+	if err != OK or before.is_empty():
+		return err
+	var written: String = FileAccess.get_file_as_string(PATH)
+	var kept: String = in_order_of(before, written)
+	if kept == written:
+		return OK
+	var file: FileAccess = FileAccess.open(PATH, FileAccess.WRITE)
+	if file == null:
+		return FileAccess.get_open_error()
+	if not file.store_string(kept):
+		return file.get_error()
+	file.close()
+	return OK
+
+
+## [param written] with its sections and their keys put in the order [param before] has them. Every
+## line of the result is a line of [param written], so nothing the engine wrote is lost or changed.
+static func in_order_of(before: String, written: String) -> String:
+	var old: Dictionary = _parsed(before)
+	var fresh: Dictionary = _parsed(written)
+	var old_sections: Array[Dictionary] = old["sections"]
+	var fresh_sections: Array[Dictionary] = fresh["sections"]
+
+	var old_names: Array[String] = []
+	var old_keys: Dictionary[String, Array] = {}
+	for section: Dictionary in old_sections:
+		var name: String = section["name"]
+		old_names.append(name)
+		var keys: Array[String] = []
+		for entry: Dictionary in section["entries"]:
+			keys.append(str(entry["key"]))
+		old_keys[name] = keys
+
+	var by_name: Dictionary[String, Dictionary] = {}
+	var fresh_names: Array[String] = []
+	for section: Dictionary in fresh_sections:
+		var name: String = section["name"]
+		by_name[name] = section
+		fresh_names.append(name)
+
+	var text: String = fresh["preamble"]
+	var at: int = 0
+	for name: String in _merged(old_names, fresh_names):
+		var section: Dictionary = by_name[name]
+		var entries: Array[Dictionary] = section["entries"]
+		var entry_of: Dictionary[String, String] = {}
+		var fresh_keys: Array[String] = []
+		for entry: Dictionary in entries:
+			var key: String = entry["key"]
+			entry_of[key] = str(entry["text"])
+			fresh_keys.append(key)
+		var known: Array = old_keys.get(name, [])
+		var held: Array[String] = []
+		held.assign(known)
+		text += str(section["head"])
+		for key: String in _merged(held, fresh_keys):
+			text += entry_of[key]
+		# The blank lines closing a section belong to its place in the file rather than to the
+		# section, so the last one keeps the ending the engine gave the file wherever it moved from.
+		var placed: Dictionary = fresh_sections[at]
+		text += str(placed["tail"])
+		at += 1
+	return text
+
+
+## The names of [param wanted] in the order [param held] lists them, those [param held] lacks each
+## placed after the name [param wanted] puts before it. Names [param wanted] lacks are left out.
+static func _merged(held: Array[String], wanted: Array[String]) -> Array[String]:
+	var order: Array[String] = []
+	for name: String in held:
+		if name in wanted and not name in order:
+			order.append(name)
+	var after: int = -1
+	for name: String in wanted:
+		var placed: int = order.find(name)
+		if placed == -1:
+			after += 1
+			# Not checked: a position inside the array cannot be refused.
+			var _inserted: int = order.insert(after, name)
+		else:
+			after = placed
+	return order
+
+
+## [param text] as a preamble (the header and anything before the first section) and its sections,
+## each with its header line and the blank lines after it, its entries, and the blank lines closing it.
+static func _parsed(text: String) -> Dictionary:
+	var preamble: String = ""
+	var sections: Array[Dictionary] = []
+	var current: Dictionary = {}
+	var body: Array[String] = []
+	for line: String in _logical_lines(text):
+		var stripped: String = line.strip_edges()
+		if stripped.begins_with("[") and stripped.ends_with("]"):
+			if not current.is_empty():
+				_close(current, body)
+				sections.append(current)
+			current = {"name": stripped.substr(1, stripped.length() - 2), "head": line}
+			body = []
+		elif current.is_empty():
+			preamble += line
+		elif body.is_empty() and stripped.is_empty():
+			current["head"] = str(current["head"]) + line
+		else:
+			body.append(line)
+	if not current.is_empty():
+		_close(current, body)
+		sections.append(current)
+	return {"preamble": preamble, "sections": sections}
+
+
+## Fills in [param section]'s entries and closing blank lines from the lines after its head. A blank
+## or comment line between two entries stays with the entry before it.
+static func _close(section: Dictionary, body: Array[String]) -> void:
+	var tail: String = ""
+	while not body.is_empty() and body[body.size() - 1].strip_edges().is_empty():
+		tail = body[body.size() - 1] + tail
+		body.remove_at(body.size() - 1)
+	var entries: Array[Dictionary] = []
+	for line: String in body:
+		var stripped: String = line.strip_edges()
+		if entries.is_empty() or not (stripped.is_empty() or stripped.begins_with(";")):
+			entries.append({"key": _key_of(line), "text": line})
+		else:
+			var last: Dictionary = entries[entries.size() - 1]
+			last["text"] = str(last["text"]) + line
+	section["entries"] = entries
+	section["tail"] = tail
+
+
+## The key an entry sets: everything before its first `=` outside quotes, since a key with spaces or
+## symbols in it is written quoted.
+static func _key_of(line: String) -> String:
+	var quoted: bool = false
+	for i: int in line.length():
+		var c: String = line[i]
+		if c == '"' and (i == 0 or line[i - 1] != "\\"):
+			quoted = not quoted
+		elif c == "=" and not quoted:
+			return line.substr(0, i).strip_edges()
+	return line.strip_edges()
+
+
+## [param text] split into lines that each end where an entry does: a value holding a dictionary, an
+## array or a string runs over several lines, and splitting it there would sort its halves apart.
+## Each piece keeps its line ending, so joining them gives the text back.
+static func _logical_lines(text: String) -> Array[String]:
+	var lines: Array[String] = []
+	var start: int = 0
+	var depth: int = 0
+	var quoted: bool = false
+	var escaped: bool = false
+	var comment: bool = false
+	for i: int in text.length():
+		var c: String = text[i]
+		if i == start:
+			comment = c == ";"
+		if comment:
+			if c == "\n":
+				lines.append(text.substr(start, i + 1 - start))
+				start = i + 1
+			continue
+		if quoted:
+			if escaped:
+				escaped = false
+			elif c == "\\":
+				escaped = true
+			elif c == '"':
+				quoted = false
+			continue
+		match c:
+			'"':
+				quoted = true
+			"[", "(", "{":
+				depth += 1
+			"]", ")", "}":
+				depth = maxi(depth - 1, 0)
+			"\n":
+				if depth == 0:
+					lines.append(text.substr(start, i + 1 - start))
+					start = i + 1
+	if start < text.length():
+		lines.append(text.substr(start))
+	return lines