├── assets
    ├── icon.png
    ├── default_env.tres
    └── icon.png.import
├── docs
    ├── gdlisp-repl.png
    ├── scope.txt
    └── gdlisp-repl.png.import
├── .gitignore
├── entities
    ├── OutputContainer.tscn
    └── OutputContainer.gd
├── screens
    ├── MainScreen.tscn
    └── MainScreen.gd
├── utils
    ├── AppManager.gd
    ├── SaveDataUtil.gd
    ├── GDLispSyntaxDoc.gd
    └── GDLisp.gd
├── tests
    ├── TestRunner.gd
    ├── TestBase.gd
    ├── TestRunner.tscn
    └── SanityTests.gd
├── project.godot
├── README.md
└── LICENSE


/assets/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/you-win/gdlisp/HEAD/assets/icon.png


--------------------------------------------------------------------------------
/docs/gdlisp-repl.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/you-win/gdlisp/HEAD/docs/gdlisp-repl.png


--------------------------------------------------------------------------------
/assets/default_env.tres:
--------------------------------------------------------------------------------
1 | [gd_resource type="Environment" load_steps=2 format=2]
2 | 
3 | [sub_resource type="ProceduralSky" id=1]
4 | 
5 | [resource]
6 | background_mode = 2
7 | background_sky = SubResource( 1 )
8 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # System
 2 | .DS_Store
 3 | *.swp
 4 | *.swo
 5 | .vs/
 6 | .vscode/
 7 | 
 8 | # Rust
 9 | target/
10 | Cargo.lock
11 | **/*.rs.bk
12 | 
13 | # Godot
14 | .import/
15 | export.cfg
16 | export_presets.cfg
17 | .mono/
18 | data_*/
19 | export/
20 | 


--------------------------------------------------------------------------------
/docs/scope.txt:
--------------------------------------------------------------------------------
 1 | ( <- runtime scope
 2 | 	( <- global scope
 3 | 		(def x 10)
 4 | 		(def y 123)
 5 | 		(def x 12) <- error
 6 | 
 7 | 		(exp-1 []
 8 | 			(def a 1)
 9 | 			(def x 2) <- error
10 | 			(def b 3)
11 | 			(goto bad-label) <- error
12 | 			(goto good-label))  
13 | 
14 | 		(exp-2 []
15 | 			(def a 2)
16 | 			(def x 3) <- error
17 | 			(label bad-label)
18 | 			(print "hello")
19 | 			(if (x > 10) (goto end) (+ x 1)))
20 | 
21 | 		(exp-1)
22 | 		
23 | 		(label good-label)
24 | 		
25 | 		(exp-2)
26 | 		(goto good-label))
27 | 		
28 | 	(label end))
29 | 
30 | 


--------------------------------------------------------------------------------
/assets/icon.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/icon.png-b6a7fb2db36edd3d95dc42f1dc8c1c5d.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://assets/icon.png"
13 | dest_files=[ "res://.import/icon.png-b6a7fb2db36edd3d95dc42f1dc8c1c5d.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/docs/gdlisp-repl.png.import:
--------------------------------------------------------------------------------
 1 | [remap]
 2 | 
 3 | importer="texture"
 4 | type="StreamTexture"
 5 | path="res://.import/gdlisp-repl.png-fa23472675ea2aad7fd06f0d6e24609f.stex"
 6 | metadata={
 7 | "vram_texture": false
 8 | }
 9 | 
10 | [deps]
11 | 
12 | source_file="res://docs/gdlisp-repl.png"
13 | dest_files=[ "res://.import/gdlisp-repl.png-fa23472675ea2aad7fd06f0d6e24609f.stex" ]
14 | 
15 | [params]
16 | 
17 | compress/mode=0
18 | compress/lossy_quality=0.7
19 | compress/hdr_mode=0
20 | compress/bptc_ldr=0
21 | compress/normal_map=0
22 | flags/repeat=0
23 | flags/filter=true
24 | flags/mipmaps=false
25 | flags/anisotropic=false
26 | flags/srgb=2
27 | process/fix_alpha_border=true
28 | process/premult_alpha=false
29 | process/HDR_as_SRGB=false
30 | process/invert_color=false
31 | stream=false
32 | size_limit=0
33 | detect_3d=true
34 | svg/scale=1.0
35 | 


--------------------------------------------------------------------------------
/entities/OutputContainer.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=2 format=2]
 2 | 
 3 | [ext_resource path="res://entities/OutputContainer.gd" type="Script" id=1]
 4 | 
 5 | [node name="OutputContainer" type="MarginContainer"]
 6 | anchor_right = 1.0
 7 | anchor_bottom = 1.0
 8 | margin_left = 10.0
 9 | margin_top = 10.0
10 | margin_right = -10.0
11 | margin_bottom = -10.0
12 | script = ExtResource( 1 )
13 | __meta__ = {
14 | "_edit_use_anchors_": false
15 | }
16 | 
17 | [node name="ColorRect" type="ColorRect" parent="."]
18 | margin_right = 1004.0
19 | margin_bottom = 580.0
20 | mouse_filter = 2
21 | color = Color( 1, 1, 1, 0.0862745 )
22 | 
23 | [node name="MarginContainer" type="MarginContainer" parent="."]
24 | margin_right = 1004.0
25 | margin_bottom = 580.0
26 | mouse_filter = 2
27 | custom_constants/margin_right = 10
28 | custom_constants/margin_top = 10
29 | custom_constants/margin_left = 10
30 | custom_constants/margin_bottom = 10
31 | 
32 | [node name="VBoxContainer" type="VBoxContainer" parent="MarginContainer"]
33 | margin_left = 10.0
34 | margin_top = 10.0
35 | margin_right = 994.0
36 | margin_bottom = 570.0
37 | alignment = 1
38 | 
39 | [node name="UpperLabel" type="Label" parent="MarginContainer/VBoxContainer"]
40 | margin_top = 264.0
41 | margin_right = 984.0
42 | margin_bottom = 278.0
43 | 
44 | [node name="LowerLabel" type="Label" parent="MarginContainer/VBoxContainer"]
45 | margin_top = 282.0
46 | margin_right = 984.0
47 | margin_bottom = 296.0
48 | 


--------------------------------------------------------------------------------
/screens/MainScreen.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=2 format=2]
 2 | 
 3 | [ext_resource path="res://screens/MainScreen.gd" type="Script" id=1]
 4 | 
 5 | [node name="MainScreen" type="Control"]
 6 | script = ExtResource( 1 )
 7 | __meta__ = {
 8 | "_edit_use_anchors_": false
 9 | }
10 | 
11 | [node name="CanvasLayer" type="CanvasLayer" parent="."]
12 | 
13 | [node name="ColorRect" type="ColorRect" parent="CanvasLayer"]
14 | anchor_right = 1.0
15 | anchor_bottom = 1.0
16 | color = Color( 0.14902, 0.14902, 0.14902, 1 )
17 | __meta__ = {
18 | "_edit_use_anchors_": false
19 | }
20 | 
21 | [node name="OutputContainer" type="MarginContainer" parent="CanvasLayer"]
22 | anchor_right = 1.0
23 | anchor_bottom = 0.8
24 | margin_left = 10.0
25 | margin_top = 10.0
26 | margin_right = -10.0
27 | margin_bottom = -10.0
28 | __meta__ = {
29 | "_edit_use_anchors_": false
30 | }
31 | 
32 | [node name="ScrollContainer" type="ScrollContainer" parent="CanvasLayer/OutputContainer"]
33 | margin_right = 1004.0
34 | margin_bottom = 460.0
35 | 
36 | [node name="Output" type="VBoxContainer" parent="CanvasLayer/OutputContainer/ScrollContainer"]
37 | margin_right = 1004.0
38 | size_flags_horizontal = 3
39 | 
40 | [node name="InputContainer" type="MarginContainer" parent="CanvasLayer"]
41 | anchor_top = 0.8
42 | anchor_right = 1.0
43 | anchor_bottom = 1.0
44 | margin_left = 10.0
45 | margin_right = -10.0
46 | margin_bottom = -10.0
47 | __meta__ = {
48 | "_edit_use_anchors_": false
49 | }
50 | 
51 | [node name="Input" type="TextEdit" parent="CanvasLayer/InputContainer"]
52 | margin_right = 1004.0
53 | margin_bottom = 110.0
54 | highlight_current_line = true
55 | draw_tabs = true
56 | draw_spaces = true
57 | 


--------------------------------------------------------------------------------
/utils/AppManager.gd:
--------------------------------------------------------------------------------
 1 | extends Node
 2 | 
 3 | signal message_logged(message)
 4 | 
 5 | var sdu: SaveDataUtil = SaveDataUtil.new()
 6 | 
 7 | var current_save_data: Dictionary
 8 | 
 9 | ###############################################################################
10 | # Builtin functions                                                           #
11 | ###############################################################################
12 | 
13 | func _ready() -> void:
14 | 	randomize()
15 | 
16 | ###############################################################################
17 | # Connections                                                                 #
18 | ###############################################################################
19 | 
20 | ###############################################################################
21 | # Private functions                                                           #
22 | ###############################################################################
23 | 
24 | ###############################################################################
25 | # Public functions                                                            #
26 | ###############################################################################
27 | 
28 | func log_message(message: String, is_error: bool = false) -> void:
29 | 	if is_error:
30 | 		message = "[ERROR] %s" % message
31 | 		assert(false, message)
32 | 	print(message)
33 | 	emit_signal("message_logged", message)
34 | 
35 | func does_metadata_exist() -> bool:
36 | 	return sdu.does_metadata_exist()
37 | 
38 | func load_data(path: String = "") -> Dictionary:
39 | 	"""
40 | 	Wrapper around SaveDataUtil.load_data(...)
41 | 	
42 | 	defaults to metadata value if empty string is passed
43 | 	"""
44 | 	return sdu.load_data(path)
45 | 
46 | func save_data(file_name: String, data: Dictionary) -> void:
47 | 	"""
48 | 	Wrapper around SaveDataUtil.save_data(...)
49 | 	"""
50 | 	sdu.save_data(file_name, data)
51 | 


--------------------------------------------------------------------------------
/tests/TestRunner.gd:
--------------------------------------------------------------------------------
 1 | extends Control
 2 | 
 3 | ###############################################################################
 4 | # Builtin functions                                                           #
 5 | ###############################################################################
 6 | 
 7 | func _ready() -> void:
 8 | 	find_node("Sanity").connect("pressed", self, "_sanity_test")
 9 | 	find_node("Tokenizer").connect("pressed", self, "_tokenizer_test")
10 | 	find_node("Parser").connect("pressed", self, "_parser_test")
11 | 	find_node("Evaluator").connect("pressed", self, "_evaluator_test")
12 | 	find_node("EndToEnd").connect("pressed", self, "_end_to_end_test")
13 | 	
14 | 	find_node("RunAll").connect("pressed", self, "_run_all_tests")
15 | 
16 | ###############################################################################
17 | # Connections                                                                 #
18 | ###############################################################################
19 | 
20 | func _sanity_test() -> void:
21 | 	var sanity_test: TestBase = load("res://tests/SanityTests.gd").new()
22 | 	
23 | 	sanity_test.run_tests()
24 | 
25 | func _tokenizer_test() -> void:
26 | 	pass
27 | 
28 | func _parser_test() -> void:
29 | 	pass
30 | 
31 | func _evaluator_test() -> void:
32 | 	pass
33 | 
34 | func _end_to_end_test() -> void:
35 | 	pass
36 | 
37 | func _run_all_tests() -> void:
38 | 	_sanity_test()
39 | 	_tokenizer_test()
40 | 	_parser_test()
41 | 	_evaluator_test()
42 | 	_end_to_end_test()
43 | 
44 | ###############################################################################
45 | # Private functions                                                           #
46 | ###############################################################################
47 | 
48 | ###############################################################################
49 | # Public functions                                                            #
50 | ###############################################################################
51 | 
52 | 
53 | 


--------------------------------------------------------------------------------
/entities/OutputContainer.gd:
--------------------------------------------------------------------------------
 1 | extends MarginContainer
 2 | 
 3 | onready var upper_label: Label = $MarginContainer/VBoxContainer/UpperLabel
 4 | onready var lower_label: Label = $MarginContainer/VBoxContainer/LowerLabel
 5 | 
 6 | var _is_mouse_entered: bool = false
 7 | 
 8 | var upper_text: String = ""
 9 | var lower_text: String = ""
10 | 
11 | ###############################################################################
12 | # Builtin functions                                                           #
13 | ###############################################################################
14 | 
15 | func _ready() -> void:
16 | 	connect("mouse_entered", self, "_mouse_entered")
17 | 	connect("mouse_exited", self, "_mouse_exited")
18 | 	
19 | 	upper_label.text = upper_text
20 | 	lower_label.text = lower_text
21 | 
22 | func _input(event: InputEvent) -> void:
23 | 	if _is_mouse_entered:
24 | 		if event.is_action_pressed("click"):
25 | 			OS.clipboard = _fix_text(upper_label.text)
26 | 
27 | ###############################################################################
28 | # Connections                                                                 #
29 | ###############################################################################
30 | 
31 | func _mouse_entered() -> void:
32 | 	_is_mouse_entered = true
33 | 
34 | func _mouse_exited() -> void:
35 | 	_is_mouse_entered = false
36 | 
37 | ###############################################################################
38 | # Private functions                                                           #
39 | ###############################################################################
40 | 
41 | func _fix_text(text: String) -> String:
42 | 	return text.replace("    ", "\t")
43 | 
44 | ###############################################################################
45 | # Public functions                                                            #
46 | ###############################################################################
47 | 
48 | func get_value() -> String:
49 | 	return upper_label.text.strip_edges()
50 | 


--------------------------------------------------------------------------------
/tests/TestBase.gd:
--------------------------------------------------------------------------------
 1 | class_name TestBase
 2 | extends Reference
 3 | 
 4 | ###############################################################################
 5 | # Builtin functions                                                           #
 6 | ###############################################################################
 7 | 
 8 | ###############################################################################
 9 | # Connections                                                                 #
10 | ###############################################################################
11 | 
12 | ###############################################################################
13 | # Private functions                                                           #
14 | ###############################################################################
15 | 
16 | func _create_empty_result() -> GDLisp.Result:
17 | 	return GDLisp.Result.new(null, null)
18 | 
19 | func _create_atom(token: String) -> GDLisp.Atom:
20 | 	if token.begins_with('"'):
21 | 		return GDLisp.Atom.new(GDLisp.Atom.Str, token.substr(1, token.length() - 2))
22 | 	elif token.is_valid_float():
23 | 		return GDLisp.Atom.new(GDLisp.Atom.Num, token.to_float())
24 | 	else:
25 | 		return GDLisp.Atom.new(GDLisp.Atom.Sym, token)
26 | 
27 | func _create_expression_from_atom(atom: GDLisp.Atom) -> GDLisp.Exp:
28 | 	return GDLisp.Exp.new(GDLisp.Exp.Atom, atom)
29 | 
30 | ###############################################################################
31 | # Public functions                                                            #
32 | ###############################################################################
33 | 
34 | func run_tests() -> void:
35 | 	var test_methods: Array = []
36 | 	var methods: Array = get_method_list()
37 | 	
38 | 	for method in methods:
39 | 		var method_name: String = method["name"]
40 | 		if method_name.left(4).to_lower() == "test":
41 | 			test_methods.append(method_name)
42 | 	
43 | 	print("Running %s tests" % test_methods.size())
44 | 	for method in test_methods:
45 | 		print("\n%s" % method)
46 | 		call(method)
47 | 


--------------------------------------------------------------------------------
/tests/TestRunner.tscn:
--------------------------------------------------------------------------------
 1 | [gd_scene load_steps=2 format=2]
 2 | 
 3 | [ext_resource path="res://tests/TestRunner.gd" type="Script" id=1]
 4 | 
 5 | [node name="TestRunner" type="Control"]
 6 | anchor_right = 1.0
 7 | anchor_bottom = 1.0
 8 | script = ExtResource( 1 )
 9 | __meta__ = {
10 | "_edit_use_anchors_": false
11 | }
12 | 
13 | [node name="CanvasLayer" type="CanvasLayer" parent="."]
14 | 
15 | [node name="VBoxContainer" type="VBoxContainer" parent="CanvasLayer"]
16 | anchor_right = 1.0
17 | anchor_bottom = 1.0
18 | __meta__ = {
19 | "_edit_use_anchors_": false
20 | }
21 | 
22 | [node name="HBoxContainer" type="HBoxContainer" parent="CanvasLayer/VBoxContainer"]
23 | margin_right = 1024.0
24 | margin_bottom = 298.0
25 | size_flags_horizontal = 3
26 | size_flags_vertical = 3
27 | __meta__ = {
28 | "_edit_use_anchors_": false
29 | }
30 | 
31 | [node name="Sanity" type="Button" parent="CanvasLayer/VBoxContainer/HBoxContainer"]
32 | margin_right = 201.0
33 | margin_bottom = 298.0
34 | focus_mode = 0
35 | size_flags_horizontal = 3
36 | text = "Sanity"
37 | 
38 | [node name="Tokenizer" type="Button" parent="CanvasLayer/VBoxContainer/HBoxContainer"]
39 | margin_left = 205.0
40 | margin_right = 407.0
41 | margin_bottom = 298.0
42 | focus_mode = 0
43 | size_flags_horizontal = 3
44 | text = "Tokenizer"
45 | 
46 | [node name="Parser" type="Button" parent="CanvasLayer/VBoxContainer/HBoxContainer"]
47 | margin_left = 411.0
48 | margin_right = 612.0
49 | margin_bottom = 298.0
50 | focus_mode = 0
51 | size_flags_horizontal = 3
52 | text = "Parser"
53 | 
54 | [node name="Evaluator" type="Button" parent="CanvasLayer/VBoxContainer/HBoxContainer"]
55 | margin_left = 616.0
56 | margin_right = 818.0
57 | margin_bottom = 298.0
58 | focus_mode = 0
59 | size_flags_horizontal = 3
60 | text = "Evaluator"
61 | 
62 | [node name="EndToEnd" type="Button" parent="CanvasLayer/VBoxContainer/HBoxContainer"]
63 | margin_left = 822.0
64 | margin_right = 1024.0
65 | margin_bottom = 298.0
66 | focus_mode = 0
67 | size_flags_horizontal = 3
68 | text = "End-to-end"
69 | 
70 | [node name="RunAll" type="Button" parent="CanvasLayer/VBoxContainer"]
71 | margin_top = 302.0
72 | margin_right = 1024.0
73 | margin_bottom = 600.0
74 | focus_mode = 0
75 | size_flags_horizontal = 3
76 | size_flags_vertical = 3
77 | text = "Run all"
78 | 


--------------------------------------------------------------------------------
/project.godot:
--------------------------------------------------------------------------------
 1 | ; Engine configuration file.
 2 | ; It's best edited using the editor UI and not directly,
 3 | ; since the parameters that go here are not all obvious.
 4 | ;
 5 | ; Format:
 6 | ;   [section] ; section goes between []
 7 | ;   param=value ; assign values to parameters
 8 | 
 9 | config_version=4
10 | 
11 | _global_script_classes=[ {
12 | "base": "Reference",
13 | "class": "GDLisp",
14 | "language": "GDScript",
15 | "path": "res://utils/GDLisp.gd"
16 | }, {
17 | "base": "Reference",
18 | "class": "GDLispSyntaxDoc",
19 | "language": "GDScript",
20 | "path": "res://utils/GDLispSyntaxDoc.gd"
21 | }, {
22 | "base": "Reference",
23 | "class": "SaveDataUtil",
24 | "language": "GDScript",
25 | "path": "res://utils/SaveDataUtil.gd"
26 | }, {
27 | "base": "Reference",
28 | "class": "TestBase",
29 | "language": "GDScript",
30 | "path": "res://tests/TestBase.gd"
31 | } ]
32 | _global_script_class_icons={
33 | "GDLisp": "",
34 | "GDLispSyntaxDoc": "",
35 | "SaveDataUtil": "",
36 | "TestBase": ""
37 | }
38 | 
39 | [application]
40 | 
41 | config/name="GDLisp"
42 | run/main_scene="res://screens/MainScreen.tscn"
43 | config/icon="res://assets/icon.png"
44 | 
45 | [autoload]
46 | 
47 | AppManager="*res://utils/AppManager.gd"
48 | 
49 | [input]
50 | 
51 | send_input={
52 | "deadzone": 0.5,
53 | "events": [ Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"pressed":false,"scancode":16777221,"physical_scancode":0,"unicode":0,"echo":false,"script":null)
54 |  ]
55 | }
56 | super={
57 | "deadzone": 0.5,
58 | "events": [ Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"pressed":false,"scancode":16777238,"physical_scancode":0,"unicode":0,"echo":false,"script":null)
59 |  ]
60 | }
61 | click={
62 | "deadzone": 0.5,
63 | "events": [ Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"button_mask":0,"position":Vector2( 0, 0 ),"global_position":Vector2( 0, 0 ),"factor":1.0,"button_index":1,"pressed":false,"doubleclick":false,"script":null)
64 | , Object(InputEventMouseButton,"resource_local_to_scene":false,"resource_name":"","device":0,"alt":false,"shift":false,"control":false,"meta":false,"command":false,"button_mask":0,"position":Vector2( 0, 0 ),"global_position":Vector2( 0, 0 ),"factor":1.0,"button_index":2,"pressed":false,"doubleclick":false,"script":null)
65 |  ]
66 | }
67 | 
68 | [physics]
69 | 
70 | common/enable_pause_aware_picking=true
71 | 
72 | [rendering]
73 | 
74 | quality/driver/driver_name="GLES2"
75 | vram_compression/import_etc=true
76 | vram_compression/import_etc2=false
77 | environment/default_environment="res://assets/default_env.tres"
78 | 


--------------------------------------------------------------------------------
/utils/SaveDataUtil.gd:
--------------------------------------------------------------------------------
  1 | class_name SaveDataUtil
  2 | extends Reference
  3 | 
  4 | const SAVE_FILE_EXTENSION: String = "fpwb"
  5 | 
  6 | const METADATA_FILE_NAME: String = "fpwb.fpwb"
  7 | const LAST_SAVE_FILE_KEY: String = "last_save_file"
  8 | const METADATA_TEMPLATE: Dictionary = {
  9 | 	LAST_SAVE_FILE_KEY: ""
 10 | }
 11 | 
 12 | var save_directory_path: String
 13 | 
 14 | ###############################################################################
 15 | # Builtin functions                                                           #
 16 | ###############################################################################
 17 | 
 18 | func _init() -> void:
 19 | 	if not OS.is_debug_build():
 20 | 		save_directory_path = OS.get_executable_path().get_base_dir()
 21 | 	else:
 22 | 		save_directory_path = "res://export/"
 23 | 
 24 | ###############################################################################
 25 | # Connections                                                                 #
 26 | ###############################################################################
 27 | 
 28 | ###############################################################################
 29 | # Private functions                                                           #
 30 | ###############################################################################
 31 | 
 32 | func _load_metadata() -> Dictionary:
 33 | 	"""
 34 | 	metadata is in format:
 35 | 	{
 36 | 		"last_save_file": String
 37 | 	}
 38 | 	"""
 39 | 	var result: Dictionary = {}
 40 | 	
 41 | 	var metadata_exists: bool = false
 42 | 	
 43 | 	var dir: Directory = Directory.new()
 44 | 	if dir.open(save_directory_path) == OK:
 45 | 		dir.list_dir_begin(true, true)
 46 | 		var file_name = dir.get_next()
 47 | 		while file_name != "":
 48 | 			if file_name.get_file() == METADATA_FILE_NAME:
 49 | 				metadata_exists = true
 50 | 				break
 51 | 			file_name = dir.get_next()
 52 | 	
 53 | 	if metadata_exists:
 54 | 		var metadata: Dictionary = load_data(METADATA_FILE_NAME)
 55 | 		if not metadata.empty():
 56 | 			
 57 | 			pass
 58 | 	
 59 | 	return result
 60 | 
 61 | func _save_metadata(last_save_file: String) -> void:
 62 | 	var save_data: Dictionary = METADATA_TEMPLATE.duplicate()
 63 | 	save_data[LAST_SAVE_FILE_KEY] = last_save_file
 64 | 	
 65 | 	var file_path: String = "%s/%s.%s" % [self.save_directory_path, self.METADATA_FILE_NAME, self.SAVE_FILE_EXTENSION]
 66 | 	var save_file: File = File.new()
 67 | 	save_file.open(file_path, File.WRITE)
 68 | 	
 69 | 	save_file.store_string(to_json(save_data))
 70 | 	
 71 | 	save_file.close()
 72 | 
 73 | ###############################################################################
 74 | # Public functions                                                            #
 75 | ###############################################################################
 76 | 
 77 | func does_metadata_exist() -> bool:
 78 | 	var result: bool = false
 79 | 	
 80 | 	var dir: Directory = Directory.new()
 81 | 	if dir.open(save_directory_path) == OK:
 82 | 		dir.list_dir_begin(true, true)
 83 | 		var file_name = dir.get_next()
 84 | 		while file_name != "":
 85 | 			if file_name.get_file() == METADATA_FILE_NAME:
 86 | 				result = true
 87 | 				break
 88 | 			file_name = dir.get_next()
 89 | 	
 90 | 	return result
 91 | 
 92 | func load_data(file_name: String = "") -> Dictionary:
 93 | 	"""
 94 | 	Loads a .fpwb file from the given directory
 95 | 	
 96 | 	returns an empty dictionary if no file is found
 97 | 	"""
 98 | 	var result: Dictionary = {}
 99 | 	
100 | 	if file_name.empty():
101 | 		var metadata: Dictionary = _load_metadata()
102 | 		
103 | 		if metadata.empty():
104 | 			return result
105 | 		
106 | 		file_name = metadata[LAST_SAVE_FILE_KEY]
107 | 	
108 | 	var file_path: String = "%s/%s" % [self.save_directory_path, file_name]
109 | 	
110 | 	var save_file: File = File.new()
111 | 	save_file.open(file_path, File.READ)
112 | 	
113 | 	var data: JSONParseResult = JSON.parse(save_file.get_as_text())
114 | 	if (data.error == OK and typeof(data.result) == TYPE_DICTIONARY):
115 | 		result = data.result
116 | 	
117 | 	save_file.close()
118 | 	
119 | 	return result
120 | 
121 | func save_data(file_name: String, data: Dictionary) -> void:
122 | 	"""
123 | 	data is in format:
124 | 	{
125 | 		...
126 | 	}
127 | 	"""
128 | 	var file_path: String = "%s/%s.%s" % [self.save_directory_path, file_name, self.SAVE_FILE_EXTENSION]
129 | 	var data_to_save: Dictionary = data["data"]
130 | 	
131 | 	var save_file: File = File.new()
132 | 	save_file.open(file_path, File.WRITE)
133 | 	
134 | 	save_file.store_string(to_json(data_to_save))
135 | 	
136 | 	save_file.close()
137 | 	
138 | 	_save_metadata(file_name)
139 | 


--------------------------------------------------------------------------------
/utils/GDLispSyntaxDoc.gd:
--------------------------------------------------------------------------------
  1 | class_name GDLispSyntaxDoc
  2 | extends Reference
  3 | 
  4 | ###############################################################################
  5 | # Builtin functions                                                           #
  6 | ###############################################################################
  7 | 
  8 | ###############################################################################
  9 | # Connections                                                                 #
 10 | ###############################################################################
 11 | 
 12 | ###############################################################################
 13 | # Private functions                                                           #
 14 | ###############################################################################
 15 | 
 16 | ###############################################################################
 17 | # Public functions                                                            #
 18 | ###############################################################################
 19 | 
 20 | static func get_long() -> String:
 21 | 	return """ *** GDLisp Syntax ***
 22 | ### Define a variable `(def <identifier> <value>)`
 23 | Creates a variable in the current scope and sets it to the specified value. Can shadow outer variables if used in an inner scope.
 24 | 
 25 | The below example will set variable `x` to value `0` in the current scope.
 26 | 
 27 | `(def x 0)`
 28 | 
 29 | ### Update a variable `(= <identifier> <value>)`
 30 | Finds a variable in the current or any outer scope (in that order) and sets it to the specified value.
 31 | 
 32 | The below example will set variable `x` to value `10`.
 33 | 
 34 | `(= x 10)`
 35 | 
 36 | ### Create a list `[ <value> ... ]` or `(list <value> ... )`
 37 | Creates and returns a list with the specified values. An empty list can be created if no values are specified.
 38 | 
 39 | The below example creates a list with the values `1`, `2`, and `3` and stores it in variable `x`.
 40 | 
 41 | `(def x [1 2 3])`
 42 | 
 43 | ### Create a table `{ <key> <value> ... }` or `(table <key> <value> ...)`
 44 | Creates and returns a table (aka a dictionary) with the specified values. An empty table can be created if no values are specified.
 45 | 
 46 | The below example creates a table with the key/value pair `"hello": "world"` and stores it in variable `x`.
 47 | 
 48 | `(def x { "hello" "world" })`
 49 | 
 50 | ### Create a lambda expression `(lam [<parameters>] <expression> ...)`
 51 | Creates and returns a lambda expression that takes the specified parameters and runs the specified expressions. A lambda expression does not need any parameters but must have at least 1 expression.
 52 | 
 53 | The below example creates a lambda expression and assigns it to the variable `double`. The lambda expression is then used to double the value `2`. The returned value will equal `4`.
 54 | 
 55 | ```
 56 | (def double (lam [ x ] (+ x x)))
 57 | 
 58 | (double 2)
 59 | ```
 60 | 
 61 | ### Create a macro `(macro [<parameters>] <expression> ...)`
 62 | Not yet implemented.
 63 | 
 64 | ### Call a method from a raw value `(raw <object> <method> <optional param> ...)`
 65 | Gets an object and calls the `callv` function on it.
 66 | 
 67 | ### If statements `(if <condition> <expression if true> <expression if false>)`
 68 | Evaluates the condition and selects an expression to execute.
 69 | 
 70 | The below example checks to see if 1 is less than 2. If this is true, the `double` lambda expression will be executed, otherwise the built-in `print` function will be called.
 71 | 
 72 | `(if (< 1 2) (double 1) (print "this is not possible"))`
 73 | 
 74 | ### While statements `(while <condition> <expression> ...)`
 75 | Executes the given expressions while the condition is true. There must be at least 1 expression to execute.
 76 | 
 77 | The below example creates and increments a variable `x` from 0 to 5.
 78 | 
 79 | ```
 80 | (def x 0)
 81 | (while (<= x 5) (= x (+ x 1)))
 82 | ```
 83 | 
 84 | ### Do block `(do <expression> ...)`
 85 | Executes the given expressions. There must be at least 1 expression to execute. Do blocks create an implicit inner scope.
 86 | 
 87 | The below example creates a variable `x` and sets it equal to `0`. Then the do block will shadow the variable `x` and set it equal to `10`. Outside of the do block, the built-in function `print` will print the value of `x`, which will be `0`.
 88 | 
 89 | ```
 90 | (def x 0)
 91 | (do (def x 10))
 92 | (print x)
 93 | ```
 94 | 
 95 | ### Label `(label <identifier>)`
 96 | Not yet implemented.
 97 | Marks the current expression as a `goto` location.
 98 | 
 99 | ### Goto `(goto <label>)`
100 | Not yet implemented.
101 | Moves execution to the specified `label`. The `label` must be in the same scope or an outer scope. If the `label` has not be interpreted yet, then the interpreter will conduct a breadth-first search for the `label`.
102 | 
103 | """
104 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # GDLisp
  2 | A Lisp-style language and REPL written using GDScript and Godot 3.3.
  3 | 
  4 | ## Quickstart
  5 | Run the main scene. Start writing Lisp-style stuff.
  6 | 
  7 | ## Integration into Godot games/apps
  8 | Take the `gdlisp.gd` file and drop it into your project. Create a new `gdlisp` object.
  9 | 
 10 | A dictionary of initialization variables can be passed as an argument (e.g. `var gdlisp = GDLISP.new({"some-identifier": myobject})`). If you want to be able to modify objects from GDLisp, these initialization variables must be some sort of reference (i.e. not a primitive). 
 11 | 
 12 | Call `gdlisp.parse_string('(print "hello world"))` to start execution. The `parse_string` method will return an array of return values, depending on how many root S-expressions were passed.
 13 | 
 14 | ## Motivation
 15 | It seemed like a cool idea at the time. I also wanted to write a language that had goto statements in it. [This website was a big help for the initial interpreter.](https://norvig.com/lispy.html). I tried to avoid referencing any explicit Make a Lisp (MAL) implementations.
 16 | 
 17 | ## Implementation notes
 18 | - Arrays and Dictionaries are wrapped in the GDLArray and GDLDictionary classes respectively. This was done so that `set`/`get` can be called on Arrays and Dictionaries in GDLisp.
 19 | 
 20 | ## TODO
 21 | - finish implementing macros
 22 | - finish implementing a way to access lists and tables
 23 | - allow for compilation to GDScript
 24 | - self host the interpreter
 25 | 
 26 | ## Syntax
 27 | 
 28 | ### Define a variable `(def <identifier> <value>)`
 29 | Creates a variable in the current scope and sets it to the specified value. Can shadow outer variables if used in an inner scope.
 30 | 
 31 | The below example will set variable `x` to value `0` in the current scope.
 32 | 
 33 | `(def x 0)`
 34 | 
 35 | ### Update a variable `(= <identifier> <value>)`
 36 | Finds a variable in the current or any outer scope (in that order) and sets it to the specified value.
 37 | 
 38 | The below example will set variable `x` to value `10`.
 39 | 
 40 | `(= x 10)`
 41 | 
 42 | ### Create a list `[ <value> ... ]` or `(list <value> ... )`
 43 | Creates and returns a list with the specified values. An empty list can be created if no values are specified.
 44 | 
 45 | The below example creates a list with the values `1`, `2`, and `3` and stores it in variable `x`.
 46 | 
 47 | `(def x [1 2 3])`
 48 | 
 49 | ### Create a table `{ <key> <value> ... }` or `(table <key> <value> ...)`
 50 | Creates and returns a table (aka a dictionary) with the specified values. An empty table can be created if no values are specified.
 51 | 
 52 | The below example creates a table with the key/value pair `"hello": "world"` and stores it in variable `x`.
 53 | 
 54 | `(def x { "hello" "world" })`
 55 | 
 56 | ### Create a lambda expression `(lam [<parameters>] <expression> ...)`
 57 | Creates and returns a lambda expression that takes the specified parameters and runs the specified expressions. A lambda expression does not need any parameters but must have at least 1 expression.
 58 | 
 59 | The below example creates a lambda expression and assigns it to the variable `double`. The lambda expression is then used to double the value `2`. The returned value will equal `4`.
 60 | 
 61 | ```
 62 | (def double (lam [ x ] (+ x x)))
 63 | 
 64 | (double 2)
 65 | ```
 66 | 
 67 | ### Create a macro `(macro [<parameters>] <expression> ...)`
 68 | Not yet implemented.
 69 | 
 70 | ### Call a method from a raw value `(raw <object> <method> <optional param> ...)`
 71 | Gets an object and calls the `callv` function on it.
 72 | 
 73 | ### If statements `(if <condition> <expression if true> <expression if false>)`
 74 | Evaluates the condition and selects an expression to execute.
 75 | 
 76 | The below example checks to see if 1 is less than 2. If this is true, the `double` lambda expression will be executed, otherwise the built-in `print` function will be called.
 77 | 
 78 | `(if (< 1 2) (double 1) (print "this is not possible"))`
 79 | 
 80 | ### While statements `(while <condition> <expression> ...)`
 81 | Executes the given expressions while the condition is true. There must be at least 1 expression to execute.
 82 | 
 83 | The below example creates and increments a variable `x` from 0 to 5.
 84 | 
 85 | ```
 86 | (def x 0)
 87 | (while (<= x 5) (= x (+ x 1)))
 88 | ```
 89 | 
 90 | ### Do block `(do <expression> ...)`
 91 | Executes the given expressions. There must be at least 1 expression to execute. Do blocks create an implicit inner scope.
 92 | 
 93 | The below example creates a variable `x` and sets it equal to `0`. Then the do block will shadow the variable `x` and set it equal to `10`. Outside of the do block, the built-in function `print` will print the value of `x`, which will be `0`.
 94 | 
 95 | ```
 96 | (def x 0)
 97 | (do (def x 10))
 98 | (print x)
 99 | ```
100 | 
101 | ### Label `(label <identifier>)`
102 | Not yet implemented.
103 | Marks the current expression as a `goto` location.
104 | 
105 | ### Goto `(goto <label>)`
106 | Not yet implemented.
107 | Moves execution to the specified `label`. The `label` must be in the same scope or an outer scope. If the `label` has not be interpreted yet, then the interpreter will conduct a breadth-first search for the `label`.
108 | 


--------------------------------------------------------------------------------
/tests/SanityTests.gd:
--------------------------------------------------------------------------------
  1 | extends TestBase
  2 | 
  3 | ###############################################################################
  4 | # Tokenizer                                                                   #
  5 | ###############################################################################
  6 | 
  7 | func test_simple_tokenizer() -> void:
  8 | 	var tokenizer: GDLisp.Tokenizer = GDLisp.Tokenizer.new()
  9 | 	
 10 | 	var result: GDLisp.Result = tokenizer.tokenize('(print "hello world")')
 11 | 	
 12 | 	assert(result.is_ok())
 13 | 	
 14 | 	var unwrapped_results: Array = result.unwrap()
 15 | 	
 16 | 	assert(unwrapped_results == ['(', 'print', '"hello world"', ')'])
 17 | 	
 18 | 	print(unwrapped_results)
 19 | 
 20 | ###############################################################################
 21 | # Parser                                                                      #
 22 | ###############################################################################
 23 | 
 24 | func test_simple_parser() -> void:
 25 | 	var input: Array = ['(', 'print', '"hello world"', ')']
 26 | 	input.invert()
 27 | 	
 28 | 	var result = _create_empty_result()
 29 | 	var parser := GDLisp.Parser.new(result)
 30 | 	
 31 | 	var expression := parser.parse(input)
 32 | 	
 33 | 	assert(expression.type == GDLisp.Exp.List)
 34 | 	
 35 | 	assert(result.is_ok())
 36 | 	
 37 | 	var unwrapped_results = result.unwrap()
 38 | 	
 39 | 	assert(unwrapped_results.to_string() == "[print, hello world]")
 40 | 	
 41 | 	print(unwrapped_results)
 42 | 
 43 | ###############################################################################
 44 | # Evaluator                                                                   #
 45 | ###############################################################################
 46 | 
 47 | func test_simple_evaluator() -> void:
 48 | 	var gdlisp := GDLisp.new()
 49 | 
 50 | 	var input := GDLisp.Exp.new(GDLisp.Exp.List, [])
 51 | 	input.append(_create_expression_from_atom(_create_atom("+")))
 52 | 	input.append(_create_expression_from_atom(_create_atom('1')))
 53 | 	input.append(_create_expression_from_atom(_create_atom('1')))
 54 | 	
 55 | 	var result = _create_empty_result()
 56 | 	var evaluator := GDLisp.Evaluator.new(result, gdlisp.global_env)
 57 | 
 58 | 	var eval_result = evaluator.eval(input, gdlisp.global_env)
 59 | 
 60 | 	assert(result.is_ok())
 61 | 	
 62 | 	var unwrapped_results = result.unwrap()
 63 | 	
 64 | 	assert(unwrapped_results == 2)
 65 | 	
 66 | 	print(unwrapped_results)
 67 | 
 68 | ###############################################################################
 69 | # GDLisp                                                                      #
 70 | ###############################################################################
 71 | 
 72 | func test_hello_world() -> void:
 73 | 	var output = GDLisp.new().parse_string('(print "hello world")')
 74 | 	
 75 | 	print(output)
 76 | 
 77 | func test_simple_addition() -> void:
 78 | 	var output = GDLisp.new().parse_string('(+ 1 1)')
 79 | 
 80 | 	assert(output[0] == 2)
 81 | 	
 82 | 	print(output)
 83 | 
 84 | func test_nested_simple_addition() -> void:
 85 | 	var output = GDLisp.new().parse_string('(+ 1 (+ 1 (+ 1 1)))')
 86 | 
 87 | 	assert(output[0] == 4)
 88 | 
 89 | 	print(output)
 90 | 
 91 | func test_setting_variables() -> void:
 92 | 	var output = GDLisp.new().parse_string('(def x 1) (+ 1 x)')
 93 | 
 94 | 	assert(output[1] == 2)
 95 | 
 96 | 	print(output)
 97 | 
 98 | func test_simple_return() -> void:
 99 | 	var output = GDLisp.new().parse_string('(def x 1)(x)')
100 | 	
101 | 	assert(output[1] == 1)
102 | 	
103 | 	print(output)
104 | 
105 | func test_while_loop() -> void:
106 | 	var output = GDLisp.new().parse_string('(def x 0)(while (< x 5)(print x)(= x (+ x 1)))(x)')
107 | 
108 | 	assert(output[2] == 5)
109 | 
110 | 	print(output)
111 | 
112 | func test_do() -> void:
113 | 	var output = GDLisp.new().parse_string('(def x 100)(do (def x 0) (= x (+ x 1)) (print x) (def x -10) (print x))(x)')
114 | 	
115 | 	assert(output[2] == 100)
116 | 	
117 | 	print(output)
118 | 
119 | func test_list() -> void:
120 | 	var output = GDLisp.new().parse_string('(def x [1 2 3 4])(x)')
121 | 	
122 | 	assert(output[1].get_raw_value()[2] == 3)
123 | 	
124 | 	print(output)
125 | 
126 | func test_table() -> void:
127 | 	var output = GDLisp.new().parse_string('(def x { "1" 2 "3" 4 })(x)')
128 | 	
129 | 	assert(output[1].get_raw_value()["3"] == 4)
130 | 	
131 | 	print(output)
132 | 
133 | func test_lambda_simple() -> void:
134 | 	var output = GDLisp.new().parse_string("""
135 | (def x
136 | 	(lam [x y]
137 | 		(def z (+ x y))
138 | 		(print z)
139 | 		(z)))
140 | (x 1 1)
141 | 	""")
142 | 
143 | 	assert(output[1] == 2)
144 | 
145 | 	print(output)
146 | 
147 | func test_lambda_redefine_builtin() -> void:
148 | 	var input: String = """
149 | (def +
150 | 	(lam [x y]
151 | 		(- x (- 0 y))))
152 | 
153 | (def sign
154 | 	(lam [x]
155 | 		(if (> x 0)
156 | 			(1)
157 | 			(-1))))
158 | 
159 | (def *
160 | 	(lam [x y]
161 | 		(def return-value 0)
162 | 		(def counter y)
163 | 		(def incrementer (sign y))
164 | 		(= incrementer (- 0 incrementer))
165 | 		(while (!= counter 0)
166 | 			(= return-value (+ return-value x))
167 | 			(= counter (+ counter incrementer)))
168 | 		(return-value)))
169 | 
170 | (* 10 2)
171 | 	"""
172 | 
173 | 	var output = GDLisp.new().parse_string(input)
174 | 
175 | 	assert(output[3] == 20)
176 | 
177 | 	print(output)
178 | 
179 | func test_macro_simple() -> void:
180 | 	var output = GDLisp.new().parse_string("""
181 | (def infix (macro [code]
182 | 	(raw code get 1)
183 | 	(raw code get 0)
184 | 	(raw code get 2)))
185 | 
186 | (infix (1 + 1))
187 | """)
188 | 	
189 | 	assert(output[1] == 2)
190 | 
191 | 	print(output)
192 | 
193 | func test_goto() -> void:
194 | 	print("not yet implemented")
195 | 	pass
196 | 


--------------------------------------------------------------------------------
/screens/MainScreen.gd:
--------------------------------------------------------------------------------
  1 | extends Control
  2 | 
  3 | const MAX_OUTPUT_COUNT: int = 50
  4 | 
  5 | const OUTPUT_CONTAINER: Resource = preload("res://entities/OutputContainer.tscn")
  6 | 
  7 | const HELP_TEXT: String = """*** GDLisp ***
  8 | There are several REPL-only commands for convenience.
  9 | 	help
 10 | 		Show this message
 11 | 	syntax
 12 | 		Show a list of reserved symbols in GDLisp and usage
 13 | 	clear
 14 | 		Clears the current repl output (DOES NOT RESET THE REPL STATE)
 15 | 	reset
 16 | 		Resets the current REPL state
 17 | 	blurb
 18 | 		Get a random blurb
 19 | 	exit
 20 | 		Exits the repl"""
 21 | 
 22 | const CUSTOM_REPL_COMMANDS := ["help", "syntax", "clear", "reset", "blurb", "exit"]
 23 | 
 24 | onready var output: VBoxContainer = $CanvasLayer/OutputContainer/ScrollContainer/Output
 25 | onready var scroll_container: ScrollContainer = $CanvasLayer/OutputContainer/ScrollContainer
 26 | onready var input: TextEdit = $CanvasLayer/InputContainer/Input
 27 | 
 28 | var _gd_lisp: GDLisp = GDLisp.new()
 29 | 
 30 | var _is_super_pressed: bool = false
 31 | 
 32 | var _current_history_position: int = 0
 33 | var _current_input_state: String = ""
 34 | 
 35 | ###############################################################################
 36 | # Builtin functions                                                           #
 37 | ###############################################################################
 38 | 
 39 | func _ready() -> void:
 40 | 	if OS.is_debug_build():
 41 | 		_create_output_box("Running sanity tests", "uwu")
 42 | 		
 43 | 		var sanity_test: TestBase = load("res://tests/SanityTests.gd").new()
 44 | 		sanity_test.run_tests()
 45 | 		
 46 | 		_create_output_box("Finished running sanity tests", "owo")
 47 | 	
 48 | 	input.grab_focus()
 49 | 	
 50 | 	_create_output_box(HELP_TEXT, _generate_random_blurb())
 51 | 
 52 | func _input(event: InputEvent) -> void:
 53 | 	if event.is_action_pressed("super"):
 54 | 		_is_super_pressed = true
 55 | 	elif event.is_action_released("super"):
 56 | 		_is_super_pressed = false
 57 | 	elif _is_super_pressed:
 58 | 		if event.is_action_pressed("send_input"):
 59 | 			if input.text in CUSTOM_REPL_COMMANDS:
 60 | 				_handle_custom_repl_commands()
 61 | 			else:
 62 | 				_send_input()
 63 | 			get_tree().set_input_as_handled()
 64 | 		elif event.is_action_pressed("ui_up"):
 65 | 			_put_history_input(-1)
 66 | 		elif event.is_action_pressed("ui_down"):
 67 | 			_put_history_input(1)
 68 | 
 69 | ###############################################################################
 70 | # Connections                                                                 #
 71 | ###############################################################################
 72 | 
 73 | ###############################################################################
 74 | # Private functions                                                           #
 75 | ###############################################################################
 76 | 
 77 | func _send_input() -> void:
 78 | 	var gd_lisp_result = _gd_lisp.parse_string(input.text)
 79 | 	var gd_lisp_text: String = ""
 80 | 	if gd_lisp_result:
 81 | 		gd_lisp_text = str(gd_lisp_result)
 82 | 	else:
 83 | 		gd_lisp_text = "~done"
 84 | 	
 85 | 	_create_output_box(input.text, gd_lisp_text)
 86 | 	
 87 | 	_update_input_box()
 88 | 
 89 | func _create_output_box(upper: String, lower: String) -> void:
 90 | 	var output_container: MarginContainer = OUTPUT_CONTAINER.instance()
 91 | 	output_container.upper_text = _fix_text(upper)
 92 | 	output_container.lower_text = _fix_text(lower)
 93 | 	output.call_deferred("add_child", output_container)
 94 | 
 95 | func _fix_text(text: String) -> String:
 96 | 	return text.replace("\t", "    ")
 97 | 
 98 | func _put_history_input(direction: int) -> void:
 99 | 	var child_count: int = output.get_child_count()
100 | 	var new_position: int = _current_history_position + direction
101 | 	if new_position == child_count:
102 | 		input.text = _current_input_state
103 | 		_current_history_position = new_position
104 | 	elif (new_position < child_count and new_position >= 0):
105 | 		if _current_history_position == child_count:
106 | 			_current_input_state = input.text
107 | 		
108 | 		_current_history_position = new_position
109 | 		
110 | 		input.text = output.get_child(_current_history_position).get_value().strip_edges()
111 | 
112 | func _handle_custom_repl_commands() -> void:
113 | 	var output_text: String
114 | 	match input.text:
115 | 		"help":
116 | 			output_text = HELP_TEXT
117 | 		"syntax":
118 | 			output_text = GDLispSyntaxDoc.get_long()
119 | 		"clear":
120 | 			output_text = _generate_random_blurb()
121 | 			for c in output.get_children():
122 | 				c.free()
123 | 			yield(get_tree(), "idle_frame")
124 | 		"reset":
125 | 			output_text = "Creating a new GDLisp environment!?"
126 | 			_gd_lisp = GDLisp.new()
127 | 		"blurb":
128 | 			output_text = _generate_random_blurb()
129 | 		"exit":
130 | 			get_tree().quit()
131 | 		_:
132 | 			AppManager.log_message("This shouldn't be possible lmao: %s" % input.text, true)
133 | 	
134 | 	if input.text != "clear":
135 | 		_create_output_box(input.text, output_text)
136 | 	
137 | 	_update_input_box()
138 | 
139 | func _update_input_box() -> void:
140 | 	yield(get_tree(), "idle_frame")
141 | 	
142 | 	while output.get_child_count() > 50:
143 | 		output.get_child(0).free()
144 | 	
145 | 	yield(get_tree(), "idle_frame")
146 | 	
147 | 	scroll_container.scroll_vertical = int(scroll_container.get_v_scrollbar().max_value)
148 | 	
149 | 	# Clear input
150 | 	input.text = ""
151 | 	
152 | 	# Set history, child_count + 1 is the current input
153 | 	_current_history_position = output.get_child_count()
154 | 	_current_input_state = ""
155 | 
156 | func _generate_random_blurb() -> String:
157 | 	"""
158 | 	Not setting this list as a const at the top since it's not really relevant
159 | 	10/10 software dev
160 | 	"""
161 | 	var blurbs := [
162 | 		# small
163 | 		"glhf", "send help", "uwu", "owo", "nl is egg", "ur mum", "tuturu~",
164 | 		"exusai gang", "ggez", "gottem",
165 | 		
166 | 		# long
167 | 		"but my performance q.q", "try using a goto ;)", "what is this garbage",
168 | 		"to boldly go where humans have collectively agreed not to go",
169 | 		"I've been using the same reusable water bottle for 15 years *flexes*",
170 | 		
171 | 		# promo
172 | 		"remember to lik an subscrb", "github.com/you-win/openseeface-gd",
173 | 		"hi youtube", "hi twitch", "sometimes youwin"
174 | 	]
175 | 	return blurbs[randi() % blurbs.size()]
176 | 
177 | ###############################################################################
178 | # Public functions                                                            #
179 | ###############################################################################
180 | 
181 | 
182 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       License shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       Licensor shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       Legal Entity shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       control means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       You (or Your) shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       Source form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       Object form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       Work shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       Derivative Works shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       Contribution shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, submitted
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as Not a Contribution.
 61 | 
 62 |       Contributor shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a NOTICE text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an AS IS BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets []
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same printed page as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright 2021 Timothy Yuen
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the License);
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an AS IS BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/utils/GDLisp.gd:
--------------------------------------------------------------------------------
  1 | class_name GDLisp
  2 | extends Reference
  3 | 
  4 | class Result:
  5 | 	var _tuple: Tuple2
  6 | 
  7 | 	func _init(v0, v1) -> void:
  8 | 		_tuple = Tuple2.new(v0, v1)
  9 | 
 10 | 	func unwrap():
 11 | 		# Error
 12 | 		if _tuple.g1():
 13 | 			AppManager.log_message("Unwrapped an error", true)
 14 | 			return null
 15 | 		else:
 16 | 			return _tuple.g0()
 17 | 
 18 | 	func unwrap_err() -> String:
 19 | 		return _tuple.g1()
 20 | 
 21 | 	func is_ok() -> bool:
 22 | 		return not _tuple.g1()
 23 | 
 24 | 	func is_err() -> bool:
 25 | 		return not is_ok()
 26 | 
 27 | 	func set_value(value) -> void:
 28 | 		_tuple.s0(value)
 29 | 
 30 | 	func set_error(value) -> void:
 31 | 		_tuple.s1(value)
 32 | 
 33 | class Error extends Exp:
 34 | 	func _init(error_message: String, exp_type: int = Exp.Atom).(exp_type, error_message) -> void:
 35 | 		self.type = exp_type
 36 | 		self.value = error_message
 37 | 
 38 | class None extends Exp:
 39 | 	func _init(exp_type: int = Exp.None, exp_value = null).(exp_type, exp_value) -> void:
 40 | 		self.type = exp_type
 41 | 		self.value = exp_value
 42 | 
 43 | class Tuple2:
 44 | 	var _v0
 45 | 	var _v1
 46 | 
 47 | 	func _init(v0, v1) -> void:
 48 | 		_v0 = v0
 49 | 		_v1 = v1
 50 | 
 51 | 	func g0():
 52 | 		return _v0
 53 | 	
 54 | 	func g1():
 55 | 		return _v1
 56 | 	
 57 | 	func s0(value):
 58 | 		_v0 = value
 59 | 
 60 | 	func s1(value):
 61 | 		_v1 = value
 62 | 
 63 | class Tuple3 extends Tuple2:
 64 | 	var _v2
 65 | 
 66 | 	func _init(v0, v1, v2).(v0, v1) -> void:
 67 | 		_v2 = v2
 68 | 
 69 | 	func g2():
 70 | 		return _v2
 71 | 
 72 | 	func s2(value):
 73 | 		_v2 = value
 74 | 
 75 | class GDLCollectionWrapper:
 76 | 	var _value
 77 | 	
 78 | 	func set(key, value) -> void:
 79 | 		_value[key] = value
 80 | 	
 81 | 	func get(key):
 82 | 		return _value[key]
 83 | 	
 84 | 	func get_raw_value():
 85 | 		return _value
 86 | 	
 87 | 	func duplicate():
 88 | 		return _value.duplicate(true)
 89 | 	
 90 | 	func _to_string() -> String:
 91 | 		return "GDLCollectionWrapper:%s" % str(_value)
 92 | 
 93 | class GDLArray extends GDLCollectionWrapper:
 94 | 	func _init(value: Array = []) -> void:
 95 | 		_value = value
 96 | 	
 97 | 	func append(value) -> void:
 98 | 		_value.append(value)
 99 | 
100 | class GDLDictionary extends GDLCollectionWrapper:
101 | 	func _init(value: Dictionary = {}) -> void:
102 | 		_value = value
103 | 
104 | class Env:
105 | 	var _inner: Dictionary # This scope
106 | 	var _outer: Env # Outer scope
107 | 
108 | 	func _init(outer: Env = null, param_names: Array = [], param_values: Array = []) -> void:
109 | 		_inner = {}
110 | 		if outer: # If null, then there is probably no global scope
111 | 			_outer = outer
112 | 
113 | 		# params and call_args must match up
114 | 		if param_names.size() != param_values.size():
115 | 			return
116 | 		
117 | 		for i in param_names.size():
118 | 			_inner[param_names[i]] = param_values[i]
119 | 
120 | 	func find(key: String):
121 | 		if key in _inner:
122 | 			return _inner[key]
123 | 		elif _outer:
124 | 			return _outer.find(key)
125 | 
126 | 		return null
127 | 
128 | 		# return Error.new("Attempted to reference non-existent value")
129 | 
130 | 	func add(key: String, value) -> void:
131 | 		_inner[key] = value
132 | 
133 | 	func remove(key: String) -> bool:
134 | 		return _inner.erase(key)
135 | 
136 | 	func set_existing_value(key: String, value) -> bool:
137 | 		if key in _inner:
138 | 			_inner[key] = value
139 | 			return true
140 | 		elif _outer:
141 | 			return _outer.set_existing_value(key, value)
142 | 		return false
143 | 
144 | var global_environment_dictionary: Dictionary = {
145 | 	# Operators
146 | 	"+": funcref(EnvUtils, "plus"),
147 | 	"-": funcref(EnvUtils, "minus"),
148 | 	"*": funcref(EnvUtils, "multiply"),
149 | 	"/": funcref(EnvUtils, "divide"),
150 | 	"==": funcref(EnvUtils, "equals"),
151 | 	"!=": funcref(EnvUtils, "not_equals"),
152 | 	"<": funcref(EnvUtils, "less_than"),
153 | 	"<=": funcref(EnvUtils, "less_than_or_equal_to"),
154 | 	">": funcref(EnvUtils, "greater_than"),
155 | 	">=": funcref(EnvUtils, "greater_than_or_equal_to"),
156 | 	
157 | 	# Primitives
158 | 	"true": true,
159 | 	"false": false,
160 | 	
161 | 	# Builtin functions
162 | 	"print": funcref(EnvUtils, "print"),
163 | 	"self": self,
164 | 
165 | 	# Label indexing
166 | 	"__labels__": {} # String: LabelData
167 | }
168 | 
169 | var global_env: Env = Env.new()
170 | 
171 | class EnvUtils:
172 | 	static func plus(a: Array):
173 | 		if a.size() < 2:
174 | 			return a[0]
175 | 
176 | 		var result = a[0]
177 | 		for i in a.slice(1, a.size() - 1):
178 | 			result += i
179 | 		return result
180 | 	
181 | 	static func minus(a: Array):
182 | 		if a.size() < 2:
183 | 			return -a[0]
184 | 
185 | 		var result = a[0]
186 | 		for i in a.slice(1, a.size() - 1):
187 | 			result -= i
188 | 		return result
189 | 	
190 | 	static func multiply(a: Array):
191 | 		if a.size() < 2:
192 | 			return 0
193 | 		
194 | 		var result = a[0]
195 | 		for i in a.slice(1, a.size() - 1):
196 | 			result *= i
197 | 		return result
198 | 	
199 | 	static func divide(a: Array):
200 | 		if a.size() < 2:
201 | 			return 0
202 | 		
203 | 		var result = a[0]
204 | 		for i in a.slice(1, a.size() - 1):
205 | 			result /= i
206 | 		return result
207 | 
208 | 	static func equals(a: Array):
209 | 		if a.size() != 2:
210 | 			return false
211 | 		return a[0] == a[1]
212 | 
213 | 	static func not_equals(a: Array):
214 | 		if a.size() != 2:
215 | 			return false
216 | 		return a[0] != a[1]
217 | 	
218 | 	static func less_than(a: Array):
219 | 		if a.size() != 2:
220 | 			return false
221 | 		return a[0] < a[1]
222 | 	
223 | 	static func less_than_or_equal_to(a: Array):
224 | 		if a.size() != 2:
225 | 			return false
226 | 		return a[0] <= a[1]
227 | 	
228 | 	static func greater_than(a: Array):
229 | 		if a.size() != 2:
230 | 			return false
231 | 		return a[0] > a[1]
232 | 	
233 | 	static func greater_than_or_equal_to(a: Array):
234 | 		if a.size() != 2:
235 | 			return false
236 | 		return a[0] >= a[1]
237 | 	
238 | 	static func print(a: Array):
239 | 		var result: String = ""
240 | 		if a.size() < 1:
241 | 			return result
242 | 		for i in a:
243 | 			result += str(i)
244 | 		print(result)
245 | 
246 | class Atom:
247 | 	enum { Sym = 0, Num, Str }
248 | 	var type: int
249 | 	var value
250 | 	
251 | 	func _init(atom_type: int, atom_value) -> void:
252 | 		type = atom_type
253 | 		value = atom_value
254 | 	
255 | 	func _to_string() -> String:
256 | 		if type == Num:
257 | 			return str(value)
258 | 		return value
259 | 	
260 | 	func get_value():
261 | 		return value
262 | 
263 | class Exp:
264 | 	enum { None = 0, Atom, List }
265 | 	var type: int
266 | 	var value
267 | 	
268 | 	func _init(exp_type: int, exp_value) -> void:
269 | 		type = exp_type
270 | 		value = exp_value
271 | 	
272 | 	func _to_string() -> String:
273 | 		if type == Atom:
274 | 			return value.to_string()
275 | 		return str(value)
276 | 	
277 | 	func append(v) -> void:
278 | 		match type:
279 | 			List:
280 | 				if typeof(v) == TYPE_ARRAY:
281 | 					(value as Array).append_array(v)
282 | 				else:
283 | 					(value as Array).append(v)
284 | 			Atom:
285 | 				AppManager.log_message("Tried to append to an Atom")
286 | 	
287 | 	func get_value():
288 | 		match type:
289 | 			List:
290 | 				return (value as Array)
291 | 			Atom:
292 | 				return value
293 | 	
294 | 	func get_raw_value():
295 | 		match type:
296 | 			List:
297 | 				return (value as Array)
298 | 			Atom:
299 | 				return value.get_value()
300 | 
301 | class Tokenizer:
302 | 	enum { None = 0, ParseExpression, ParseSpace, ParseSymbol, ParseQuotation, ParseBracket, ParseEscapeCharacter }
303 | 
304 | 	var current_type: int = None
305 | 	var is_escape_character: bool = false
306 | 
307 | 	var token_builder: PoolStringArray = PoolStringArray()
308 | 
309 | 	func _build_token(result: Array) -> void:
310 | 		if token_builder.size() != 0:
311 | 			result.append(token_builder.join(""))
312 | 			token_builder = PoolStringArray()
313 | 
314 | 	func tokenize(value: String) -> Result:
315 | 		var result: Array = []
316 | 		var error
317 | 
318 | 		var paren_counter: int = 0
319 | 		var square_bracket_counter: int = 0
320 | 		var curly_bracket_counter: int = 0
321 | 		
322 | 		# Checks for raw strings of size 1
323 | 		if value.length() <= 2:
324 | 			return Result.new(result, "Program too short")
325 | 
326 | 		for i in value.length():
327 | 			var c: String = value[i]
328 | 			if c == '"':
329 | 				if is_escape_character: # This is a double quote literal
330 | 					token_builder.append(c)
331 | 					is_escape_character = false
332 | 				elif current_type == ParseQuotation: # Close the double quote
333 | 					token_builder.append(c)
334 | 					current_type = None
335 | 					_build_token(result)
336 | 				else: # Open the double quote
337 | 					token_builder.append(c)
338 | 					current_type = ParseQuotation
339 | 			elif current_type == ParseQuotation:
340 | 				if c == "\\":
341 | 					is_escape_character = true
342 | 				else:
343 | 					token_builder.append(c)
344 | 			else:
345 | 				match c:
346 | 					"(":
347 | 						paren_counter += 1
348 | 						_build_token(result)
349 | 						current_type = ParseExpression
350 | 						result.append(c)
351 | 					")":
352 | 						paren_counter -= 1
353 | 						_build_token(result)
354 | 						current_type = None
355 | 						result.append(c)
356 | 					"[":
357 | 						square_bracket_counter += 1
358 | 						_build_token(result)
359 | 						current_type = ParseBracket
360 | 						result.append(c)
361 | 					"]":
362 | 						square_bracket_counter -= 1
363 | 						_build_token(result)
364 | 						current_type = None
365 | 						result.append(c)
366 | 					"{":
367 | 						curly_bracket_counter += 1
368 | 						_build_token(result)
369 | 						current_type = ParseBracket
370 | 						result.append(c)
371 | 					"}":
372 | 						curly_bracket_counter -= 1
373 | 						_build_token(result)
374 | 						current_type = None
375 | 						result.append(c)
376 | 					" ", "\r\n", "\n", "\t":
377 | 						_build_token(result)
378 | 						current_type = ParseSpace
379 | 					# "\\":
380 | 						# if current_type == ParseQuotation:
381 | 							# is_escape_character = true
382 | 					_:
383 | 						current_type = ParseSymbol
384 | 						token_builder.append(c)
385 | 		
386 | 		if paren_counter != 0:
387 | 			result.clear()
388 | 			error = "Mismatched parens"
389 | 
390 | 		if square_bracket_counter != 0:
391 | 			result.clear()
392 | 			error = "Mismatched square brackets"
393 | 
394 | 		if curly_bracket_counter != 0:
395 | 			result.clear()
396 | 			error = "Mismatched curly brackets"
397 | 
398 | 		return Result.new(result, error)
399 | 
400 | class Parser:
401 | 	var _depth: int = 0
402 | 	var _result: Result
403 | 
404 | 	var _is_quoted: bool = false
405 | 
406 | 	func _init(result: Result) -> void:
407 | 		_result = result
408 | 	
409 | 	func parse(tokens: Array) -> Exp:
410 | 		var list_expression: Exp = Exp.new(Exp.List, [])
411 | 
412 | 		if _result.is_err():
413 | 			return _error("Aborting due to previous error")
414 | 
415 | 		if tokens.size() == 0:
416 | 			return _error("Unexpected EOF")
417 | 		
418 | 		var token: String = tokens.pop_back()
419 | 		
420 | 		if tokens.size() == 0:
421 | 			return _error("Unexpected EOF")
422 | 		
423 | 		match token:
424 | 			"(":
425 | 				_depth += 1
426 | 				while tokens[tokens.size() - 1] != ")":
427 | 					list_expression.append(parse(tokens))
428 | 				tokens.pop_back() # Remove last ')'
429 | 			")":
430 | 				return _error("Unexpected )")
431 | 			"[":
432 | 				_depth += 1
433 | 				list_expression.append(Exp.new(Exp.Atom, _atom("list")))
434 | 				while tokens[tokens.size() - 1] != "]":
435 | 					list_expression.append(parse(tokens))
436 | 				tokens.pop_back() # Remove last ']'
437 | 			"]":
438 | 				return _error("Unexpected ]")
439 | 			"{":
440 | 				_depth += 1
441 | 				list_expression.append(Exp.new(Exp.Atom, _atom("table")))
442 | 				while tokens[tokens.size() - 1] != "}":
443 | 					list_expression.append(parse(tokens))
444 | 				tokens.pop_back() # Remove last '}'
445 | 			"}":
446 | 				return _error("Unexpected }")
447 | 			"'":
448 | 				_is_quoted = true
449 | 				return Exp.new(Exp.Atom, _atom("'"))
450 | 			_:
451 | 				return Exp.new(Exp.Atom, _atom(token))
452 | 
453 | 		_depth -= 1
454 | 		if _depth == 0:
455 | 			_result.set_value(list_expression)
456 | 
457 | 		return list_expression
458 | 	
459 | 	func _atom(token: String) -> Atom:
460 | 		if token.begins_with('"'):
461 | 			return Atom.new(Atom.Str, token.substr(1, token.length() - 2))
462 | 		elif token.is_valid_float():
463 | 			return Atom.new(Atom.Num, token.to_float())
464 | 		else:
465 | 			return Atom.new(Atom.Sym, token)
466 | 
467 | 	func _error(error_message: String) -> Exp:
468 | 		_result.set_error(error_message)
469 | 		return None.new()
470 | 
471 | class Evaluator:
472 | 	var _depth: int = 0
473 | 	var _result: Result
474 | 	
475 | 	# TODO store initial exp here
476 | 
477 | 	var _s_expression_stack: Array = []
478 | 
479 | 	func _init(result: Result, env: Env) -> void:
480 | 		_result = result
481 | 		env.add("__evaluator__", self)
482 | 
483 | 	# TODO change v to be an exp pointer
484 | 	# Access actual expressions from the stored expressions
485 | 	func eval(v: Exp, env: Env):
486 | 		var eval_value
487 | 		_depth += 1
488 | 		
489 | 		if v.type == Exp.Atom:
490 | 			match v.get_value().type:
491 | 				Atom.Sym:
492 | 					var raw_value = v.get_raw_value()
493 | 					var env_value = env.find(raw_value)
494 | 					
495 | 					if env_value == null:
496 | 						AppManager.log_message("Undefined symbol %s" % raw_value)
497 | 						eval_value = "Undefined symbol"
498 | 						_result.set_error(eval_value)
499 | 						continue
500 | 					
501 | 					eval_value = env_value
502 | 				Atom.Str:
503 | 					eval_value = v.get_raw_value()
504 | 				Atom.Num:
505 | 					eval_value = v.get_raw_value()
506 | 		elif v.type == Exp.List:
507 | 			_s_expression_stack.push_back(v)
508 | 			var list: Array = v.get_value()
509 | 			if list.size() != 0:
510 | 				match list[0].get_raw_value():
511 | 					"if": # (if () () ())
512 | 						# TODO maybe change this to be varargs?
513 | 						if not _has_exact_args(list.size(), 4, "if"):
514 | 							return
515 | 						var test = list[1]
516 | 						var consequence = list[2]
517 | 						var alt = list[3]
518 | 						var expression
519 | 						if (eval(test, env)):
520 | 							expression = consequence
521 | 						else:
522 | 							expression = alt
523 | 						eval_value = eval(expression, env)
524 | 					"do": # (do () ...)
525 | 						if not _has_enough_args(list.size(), 2, "do"):
526 | 							return
527 | 						var inner_env = Env.new(env)
528 | 						for s in list.slice(1, list.size()):
529 | 							eval_value = eval(s, inner_env)
530 | 					"while": # (while (test) ())
531 | 						if not _has_enough_args(list.size(), 3, "while"):
532 | 							return
533 | 						var test = list[1]
534 | 						while eval(test, env):
535 | 							for s in list.slice(2, list.size()):
536 | 								eval_value = eval(s, env)
537 | 					"for": # (for [] ())
538 | 						pass
539 | 					"def": # Create new variable in the current scope (def () ())
540 | 						if not _has_exact_args(list.size(), 3, "def"):
541 | 							return
542 | 						var symbol = list[1]
543 | 						var expression = list[2]
544 | 						env.add(symbol.get_raw_value(), eval(expression, env))
545 | 					"=": # Sets a variable in the current or outer scope (= () ())
546 | 						if not _has_exact_args(list.size(), 3, "="):
547 | 							return
548 | 						var symbol = list[1]
549 | 						var expression = list[2]
550 | 						if not env.set_existing_value(symbol.get_raw_value(), eval(expression, env)):
551 | 							eval_value = "Tried to set a non-existent variable %s" % symbol
552 | 							_result.set_error(eval_value)
553 | 							return
554 | 					"list": # Returns a Godot array (list () ...)
555 | 						eval_value = GDLArray.new()
556 | 						if list.size() >= 2:
557 | 							for item in list.slice(1, list.size() - 1, 1, true):
558 | 								eval_value.append(eval(item, env))
559 | 					"table":
560 | 						eval_value = GDLDictionary.new()
561 | 						if list.size() >= 2:
562 | 							# Check for equal pairs
563 | 							if not (list.size() - 1) % 2 == 0:
564 | 								eval_value = "Unbalanced key/value pairs for table"
565 | 								_result.set_error(eval_value)
566 | 								return
567 | 							var idx: int = 1
568 | 							while idx < list.size():
569 | 								eval_value.set(eval(list[idx], env), eval(list[idx + 1], env))
570 | 								idx += 2
571 | 					"lam": # Lambda (lam [] () ...)
572 | 						if not _has_enough_args(list.size(), 3, "lam"):
573 | 							return
574 | 						var arg_names = list[1].get_raw_value()
575 | 						if not arg_names is Array:
576 | 							eval_value = "lam expects a list of parameter names"
577 | 							_result.set_error(eval_value)
578 | 							return
579 | 						if arg_names.size() == 1: # Can never be 0, so let us crash if it somehow is
580 | 							arg_names = []
581 | 						else:
582 | 							arg_names = arg_names.slice(1, arg_names.size() - 1)
583 | 							for i in arg_names.size():
584 | 								arg_names[i] = arg_names[i].get_raw_value()
585 | 
586 | 						var expressions = Exp.new(Exp.List, [])
587 | 						expressions.append(Exp.new(Exp.Atom, Atom.new(Atom.Sym, "do")))
588 | 						for expression in list.slice(2, list.size() - 1, 1, true):
589 | 							expressions.append(expression)
590 | 
591 | 						eval_value = Procedure.new(arg_names, expressions, Env.new(env))
592 | 					"macro": # (macro [] () ...)
593 | 						if not _has_enough_args(list.size(), 3, "macro"):
594 | 							return
595 | 						var arg_names = list[1].get_raw_value()
596 | 						if arg_names.size() < 2:
597 | 							arg_names = []
598 | 						else:
599 | 							arg_names = arg_names.slice(1, arg_names.size() - 1)
600 | 							for i in arg_names.size():
601 | 								arg_names[i] = arg_names[i].get_raw_value()
602 | 
603 | 						eval_value = Macro.new(arg_names, list.slice(2, list.size() - 1, 1, true), Env.new(env))
604 | 					"raw": # (raw () () ...)
605 | 						if not _has_enough_args(list.size(), 3, "raw"):
606 | 							return
607 | 						var object = eval(list[1], env)
608 | 						var method = list[2].get_raw_value()
609 | 						if not method is String:
610 | 							eval_value = "method in raw call must be a String"
611 | 							_result.set_error(eval_value)
612 | 							return
613 | 						var call_args := []
614 | 						if list.size() > 3:
615 | 							for i in list.slice(3, list.size() - 1, 1, true):
616 | 								call_args.append(i.get_raw_value())
617 | 						eval_value = object.callv(method, call_args)
618 | 					"expr": # (expr ())
619 | 						if not _has_exact_args(list.size(), 2, "expr"):
620 | 							return
621 | 						var input_expression = list[1].get_raw_value()
622 | 						if not input_expression is String:
623 | 							eval_value = "Expression body must be a String"
624 | 							_result.set_error(eval_value)
625 | 							return
626 | 						var godot_expression: Expression = Expression.new()
627 | 						var error = godot_expression.parse(input_expression)
628 | 						if error != OK:
629 | 							eval_value = "Failed to parse expression"
630 | 							_result.set_error(eval_value)
631 | 							return
632 | 						eval_value = godot_expression.execute()
633 | 					"label": # Label all nested S-expressions (label ())
634 | 						if not _has_exact_args(list.size(), 2, "label"):
635 | 							return
636 | 						var label_name = list[1].get_raw_value()
637 | 						var label_data: LabelData = LabelData.new(label_name, env, _s_expression_stack.slice(0, _s_expression_stack.size() - 2))
638 | 						
639 | 						env.find("__labels__")[label_name] = label_data
640 | 					"goto": # Goto specified label (goto ())
641 | 						if not _has_exact_args(list.size(), 2, "goto"):
642 | 							return
643 | 						var global_label_dictionary: Dictionary = env.find("__labels__")
644 | 						var label_data: LabelData
645 | 						
646 | 						# TODO implement breadth-first search for labels
647 | 						if not global_label_dictionary.has(list[1].get_raw_value()): # label was not cached
648 | 							for i in _s_expression_stack[0].get_raw_value():
649 | 								if i.type == Exp.List:
650 | 									pass
651 | 						else:
652 | 							label_data = global_label_dictionary[list[1].get_raw_value()]
653 | 
654 | 						# TODO fill this out
655 | 					"import": # Import file from relative path (import ())
656 | 						pass
657 | 					_:
658 | 						var procedure = eval(list[0], env)
659 | 						if procedure is Macro:
660 | 							# We don't want to evaluate anything yet until the macro is expanded
661 | 							eval_value = eval(procedure.expand(list.slice(1, list.size() - 1, 1, true)), Env.new(env))
662 | 							continue
663 | 						elif (not procedure is FuncRef and not procedure is Procedure):
664 | 							eval_value = procedure
665 | 							# NOTE this is the catch-all match, so this continue is okay
666 | 							continue
667 | 						var args: Array = []
668 | 						for arg in list.slice(1, list.size() - 1, 1, true):
669 | 							args.append(eval(arg, env))
670 | 						if procedure is String:
671 | 							eval_value = "Invalid procedure: %s" % procedure
672 | 							_result.set_error(eval_value)
673 | 							return
674 | 						eval_value = procedure.call_func(args)
675 | 		
676 | 		_depth -= 1
677 | 		
678 | 		if _depth == 0:
679 | 			_result.set_value(eval_value)
680 | 		
681 | 		return eval_value
682 | 
683 | 	func _has_exact_args(list_size: int, expected_size: int, statement_type: String) -> bool:
684 | 		if list_size != expected_size:
685 | 			_result.set_error("Unexpected amount of arguments (%s vs %s) for %s" % [list_size, expected_size, statement_type])
686 | 			return false
687 | 		return true
688 | 	
689 | 	func _has_enough_args(list_size: int, minimum_size: int, statement_type: String) -> bool:
690 | 		if list_size < minimum_size:
691 | 			_result.set_error("Insufficient arguments for %s" % statement_type)
692 | 			return false
693 | 		return true
694 | 
695 | class Procedure:
696 | 	var stored_arg_names: Array
697 | 	var stored_expressions: Exp
698 | 	var stored_env: Env
699 | 
700 | 	func _init(arg_names: Array, expressions: Exp, env: Env) -> void:
701 | 		stored_arg_names = arg_names
702 | 		stored_expressions = expressions
703 | 		stored_env = env
704 | 
705 | 	func call_func(arg_values: Array):
706 | 		for i in stored_arg_names.size():
707 | 			stored_env.add(stored_arg_names[i], arg_values[i])
708 | 		
709 | 		return stored_env.find("__evaluator__").eval(stored_expressions, stored_env)
710 | 
711 | # TODO only works for single-level macros, nested expressions don't work
712 | # probably want to write a custom eval function that only evaluates atoms
713 | class Macro:
714 | 	"""
715 | 	Example
716 | 	(def infix (macro [code]
717 | 		(raw code get 0)
718 | 		(raw code get 1)
719 | 		(raw code get 2)))
720 | 	(infix (1 + 1))
721 | 	"""
722 | 	var stored_arg_names: Array
723 | 	var stored_expression: Array
724 | 	var stored_env: Env
725 | 
726 | 	func _init(arg_names: Array, expression: Array, env: Env) -> void:
727 | 		stored_arg_names = arg_names
728 | 		stored_expression = expression
729 | 		stored_env = env
730 | 
731 | 	func expand(expressions: Array) -> Exp:
732 | 		var result_expression := Exp.new(Exp.List, [])
733 | 		
734 | 		for i in stored_arg_names.size():
735 | 			var raw_value = expressions[i].get_raw_value()
736 | 			stored_env.add(stored_arg_names[i], GDLArray.new(raw_value))
737 | 
738 | 		var evaluator: Evaluator = stored_env.find("__evaluator__")
739 | 		var is_quoted: bool = false
740 | 		for se in stored_expression:
741 | 			var raw_value = se.get_raw_value()
742 | 			if (raw_value is String and raw_value == "'"):
743 | 				is_quoted = true
744 | 			elif is_quoted:
745 | 				is_quoted = false
746 | 				result_expression.append(se)
747 | 			else:
748 | 				result_expression.append(evaluator.eval(se, stored_env))
749 | 		
750 | 		return result_expression
751 | 
752 | class LabelData:
753 | 	var name: String
754 | 	var scope: Env
755 | 	var stack: Array
756 | 
757 | 	func _init(label_name: String, outer_env: Env, label_stack: Array) -> void:
758 | 		name = label_name
759 | 		scope = outer_env
760 | 		stack = label_stack
761 | 
762 | ###############################################################################
763 | # Builtin functions                                                           #
764 | ###############################################################################
765 | 
766 | func _init() -> void:
767 | 	# NOTE we don't duplicate here since it doesn't really matter + it's a global
768 | 	global_env._inner = global_environment_dictionary
769 | 
770 | ###############################################################################
771 | # Connections                                                                 #
772 | ###############################################################################
773 | 
774 | ###############################################################################
775 | # Private functions                                                           #
776 | ###############################################################################
777 | 
778 | func _tokenize(value: String) -> Result:
779 | 	var tokenizer: Tokenizer = Tokenizer.new()
780 | 
781 | 	return tokenizer.tokenize(value)
782 | 
783 | func _parse(tokens: Array, result: Result) -> Exp:
784 | 	var parser: Parser = Parser.new(result)
785 | 
786 | 	return parser.parse(tokens)
787 | 
788 | func _eval(v: Exp, result: Result, eval_env: Env = global_env):
789 | 	var evaluator: Evaluator = Evaluator.new(result, eval_env)
790 | 
791 | 	return evaluator.eval(v, eval_env)
792 | 
793 | ###############################################################################
794 | # Public functions                                                            #
795 | ###############################################################################
796 | 
797 | func parse_string(value: String):
798 | 	var result: Array = []
799 | 	# String
800 | 	var tokenize_result: Result = _tokenize(value)
801 | 	if tokenize_result.is_err():
802 | 		return tokenize_result.unwrap_err()
803 | 	var tokens: Array = tokenize_result.unwrap()
804 | 	
805 | 	tokens.invert()
806 | 
807 | 	var parsed_tokens_array: Array = []
808 | 	while tokens.size() != 0:
809 | 		var parser_result: Result = Result.new(null, null)
810 | 		_parse(tokens, parser_result)
811 | 
812 | 		if parser_result.is_err():
813 | 			return parser_result.unwrap_err()
814 | 		
815 | 		parsed_tokens_array.append(parser_result.unwrap())
816 | 
817 | 	for i in parsed_tokens_array:
818 | 		var eval_result: Result = Result.new(null, null)
819 | 		_eval(i, eval_result)
820 | 
821 | 		if eval_result.is_err():
822 | 			return eval_result.unwrap_err()
823 | 
824 | 		result.append(eval_result.unwrap())
825 | 	
826 | 	return result
827 | 


--------------------------------------------------------------------------------