Update README.md

Merge pull request #13 from wyst-lang/master

.gitignore

@@ -1,24 +1,31 @@
-# Generated by Cargo
-# will have compiled files and executables
-debug/
-target/
 
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
 
-# These are backup files generated by rustfmt
-**/*.rs.bk
+# Test binary, built with `go test -c`
+*.test
 
-# MSVC Windows builds of rustc generate these, which store debugging information
-*.pdb
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
 
+# Dependency directories (remove the comment below to include it)
+# vendor/
 
-# Added by cargo
-/target
+# Go workspace file
+go.work
 
 # Mac OS
 .DS_Store
 
-#Wyst files for testing
-*.wst
+#vscode
+.vscode
+
+.antlr/
+
+test/
+
+build/

.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/wyst.iml" filepath="$PROJECT_DIR$/.idea/wyst.iml" />
-    </modules>
-  </component>
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

.idea/wyst.iml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="EMPTY_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/target" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-    "rust-analyzer.linkedProjects": [
-        "./Cargo.toml"
-    ],
-    "rust-analyzer.showUnlinkedFileNotification": false
-}

Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "wyst"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-regex = "1.10.4"
-once_cell = "1.19.0"
-clap = { version = "4.0", features = ["derive"] }

README.md

@@ -5,7 +5,16 @@
 <h1 align="center">Wyst
 </h1>
 
-<h3 align="center">Wyst is a programing language that has similar syntax to C and transpiles to Rust</h3>
+<h3 align="center">Wyst is a programing language that is inspired by C and transpiles to Go</h3>
 
-# Alpha
-We are on pure alpha. if you would like to contribute please open a new issue.
+```c
+include io;
+
+void main() {
+  printf("Hello, World!");
+}
+```
+
+# For developers
+
+If the grammar has been updated run: `antlr -Dlanguage=Go -o parser Wyst.g4`

Wyst.g4

@@ -0,0 +1,65 @@
+grammar Wyst;
+
+COMMENT: '//' ~[\r\n]* -> skip;
+MULTILINE_COMMENT: '/*' .*? '*/' -> skip;
+WS: [ \t\r\n]+ -> skip;
+NUMBER: [1-9][0-9]* | '0';
+HEX: '0x' [a-fA-F0-9]*;
+IDENTIFIER: [a-zA-Z_] [a-zA-Z0-9_]* ('::' [a-zA-Z_] [a-zA-Z0-9_]*)*;
+GOIDENTIFIER: '^' [a-zA-Z_] [a-zA-Z0-9_]* ('.' [a-zA-Z_] [a-zA-Z0-9_]*)*;
+MATH: '+' | '-' | '*' | '/' | '==' | '!=' | '>=' | '<=';
+fragment ESC: '\\' . ;
+STRING: ('"' (ESC | ~["\\])* '"') | ('\'' (ESC | ~["\\])* '\'') ;
+MODULE_NAME: [a-zA-Z_] [a-zA-Z0-9_]*;
+
+round_def: '(' (var_def (',' var_def)* ','?)? ')';
+enum_curly: '{' (var_def ';')* '}';
+round_call: '(' (expr (',' expr)* ','?)? ')';
+fn_call: IDENTIFIER round_call;
+func_def: IDENTIFIER IDENTIFIER round_def code_block;
+var_def: IDENTIFIER IDENTIFIER;
+var_def_set: var_def '=' expr;
+call_tree: (fn_call|IDENTIFIER) ('.' (fn_call|IDENTIFIER))*;
+struct_def: 'struct' IDENTIFIER enum_curly;
+namespace: 'namespace' IDENTIFIER '{' (((var_def|var_def_set) ';')|func_def)* '}';
+import_statement: 'include' MODULE_NAME ';';
+use_statement: 'use' IDENTIFIER ';';
+go_import: '%import' STRING ';';
+map: '%map' IDENTIFIER ',' IDENTIFIER ';';
+go_call: GOIDENTIFIER round_call;
+
+// if else statements
+if_expr: '(' expr (('&&'|'||') expr)* ')';
+if_statement: 'if' if_expr code_block*;
+elseif_statement: 'else' if_statement;
+else_statement: 'else' code_block*;
+if_tree: if_statement elseif_statement* else_statement?;
+
+expr:
+    (
+        call_tree |
+        NUMBER |
+        HEX |
+        IDENTIFIER |
+        STRING |
+        go_call |
+        GOIDENTIFIER
+    ) (MATH expr)*;
+
+code_block: '{' (((
+    expr |
+    var_def |
+    var_def_set
+) ';') | (
+    if_tree
+))* '}';
+
+top: (
+    func_def |
+    struct_def |
+    namespace |
+    import_statement |
+    use_statement |
+    go_import |
+    map
+)*;

go.mod

@@ -0,0 +1,16 @@
+module github.com/wyst-lang/wyst
+
+go 1.22
+
+toolchain go1.22.6
+
+require github.com/antlr4-go/antlr/v4 v4.13.1 // direct
+
+require (
+	github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect
+	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/urfave/cli/v2 v2.27.4 // direct
+	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
+	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect
+
+)

go.sum

@@ -0,0 +1,12 @@
+github.com/antlr4-go/antlr/v4 v4.13.1 h1:SqQKkuVZ+zWkMMNkjy5FZe5mr5WURWnlpmOuzYWrPrQ=
+github.com/antlr4-go/antlr/v4 v4.13.1/go.mod h1:GKmUxMtwp6ZgGwZSva4eWPC5mS6vUAmOABFgjdkM7Nw=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/urfave/cli/v2 v2.27.4 h1:o1owoI+02Eb+K107p27wEX9Bb8eqIoZCfLXloLUSWJ8=
+github.com/urfave/cli/v2 v2.27.4/go.mod h1:m4QzxcD2qpra4z7WhzEGn74WZLViBnMpb1ToCAKdGRQ=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=

parser/Wyst.tokens

@@ -0,0 +1,46 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+T__5=6
+T__6=7
+T__7=8
+T__8=9
+T__9=10
+T__10=11
+T__11=12
+T__12=13
+T__13=14
+T__14=15
+T__15=16
+T__16=17
+T__17=18
+COMMENT=19
+MULTILINE_COMMENT=20
+WS=21
+NUMBER=22
+HEX=23
+IDENTIFIER=24
+GOIDENTIFIER=25
+MATH=26
+STRING=27
+MODULE_NAME=28
+'('=1
+','=2
+')'=3
+'{'=4
+';'=5
+'}'=6
+'='=7
+'.'=8
+'struct'=9
+'namespace'=10
+'include'=11
+'use'=12
+'%import'=13
+'%map'=14
+'&&'=15
+'||'=16
+'if'=17
+'else'=18

parser/WystLexer.tokens

@@ -0,0 +1,46 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+T__5=6
+T__6=7
+T__7=8
+T__8=9
+T__9=10
+T__10=11
+T__11=12
+T__12=13
+T__13=14
+T__14=15
+T__15=16
+T__16=17
+T__17=18
+COMMENT=19
+MULTILINE_COMMENT=20
+WS=21
+NUMBER=22
+HEX=23
+IDENTIFIER=24
+GOIDENTIFIER=25
+MATH=26
+STRING=27
+MODULE_NAME=28
+'('=1
+','=2
+')'=3
+'{'=4
+';'=5
+'}'=6
+'='=7
+'.'=8
+'struct'=9
+'namespace'=10
+'include'=11
+'use'=12
+'%import'=13
+'%map'=14
+'&&'=15
+'||'=16
+'if'=17
+'else'=18

parser/wyst_base_listener.go

@@ -0,0 +1,160 @@
+// Code generated from Wyst.g4 by ANTLR 4.13.2. DO NOT EDIT.
+
+package parser // Wyst
+
+import "github.com/antlr4-go/antlr/v4"
+
+// BaseWystListener is a complete listener for a parse tree produced by WystParser.
+type BaseWystListener struct{}
+
+var _ WystListener = &BaseWystListener{}
+
+// VisitTerminal is called when a terminal node is visited.
+func (s *BaseWystListener) VisitTerminal(node antlr.TerminalNode) {}
+
+// VisitErrorNode is called when an error node is visited.
+func (s *BaseWystListener) VisitErrorNode(node antlr.ErrorNode) {}
+
+// EnterEveryRule is called when any rule is entered.
+func (s *BaseWystListener) EnterEveryRule(ctx antlr.ParserRuleContext) {}
+
+// ExitEveryRule is called when any rule is exited.
+func (s *BaseWystListener) ExitEveryRule(ctx antlr.ParserRuleContext) {}
+
+// EnterRound_def is called when production round_def is entered.
+func (s *BaseWystListener) EnterRound_def(ctx *Round_defContext) {}
+
+// ExitRound_def is called when production round_def is exited.
+func (s *BaseWystListener) ExitRound_def(ctx *Round_defContext) {}
+
+// EnterEnum_curly is called when production enum_curly is entered.
+func (s *BaseWystListener) EnterEnum_curly(ctx *Enum_curlyContext) {}
+
+// ExitEnum_curly is called when production enum_curly is exited.
+func (s *BaseWystListener) ExitEnum_curly(ctx *Enum_curlyContext) {}
+
+// EnterRound_call is called when production round_call is entered.
+func (s *BaseWystListener) EnterRound_call(ctx *Round_callContext) {}
+
+// ExitRound_call is called when production round_call is exited.
+func (s *BaseWystListener) ExitRound_call(ctx *Round_callContext) {}
+
+// EnterFn_call is called when production fn_call is entered.
+func (s *BaseWystListener) EnterFn_call(ctx *Fn_callContext) {}
+
+// ExitFn_call is called when production fn_call is exited.
+func (s *BaseWystListener) ExitFn_call(ctx *Fn_callContext) {}
+
+// EnterFunc_def is called when production func_def is entered.
+func (s *BaseWystListener) EnterFunc_def(ctx *Func_defContext) {}
+
+// ExitFunc_def is called when production func_def is exited.
+func (s *BaseWystListener) ExitFunc_def(ctx *Func_defContext) {}
+
+// EnterVar_def is called when production var_def is entered.
+func (s *BaseWystListener) EnterVar_def(ctx *Var_defContext) {}
+
+// ExitVar_def is called when production var_def is exited.
+func (s *BaseWystListener) ExitVar_def(ctx *Var_defContext) {}
+
+// EnterVar_def_set is called when production var_def_set is entered.
+func (s *BaseWystListener) EnterVar_def_set(ctx *Var_def_setContext) {}
+
+// ExitVar_def_set is called when production var_def_set is exited.
+func (s *BaseWystListener) ExitVar_def_set(ctx *Var_def_setContext) {}
+
+// EnterCall_tree is called when production call_tree is entered.
+func (s *BaseWystListener) EnterCall_tree(ctx *Call_treeContext) {}
+
+// ExitCall_tree is called when production call_tree is exited.
+func (s *BaseWystListener) ExitCall_tree(ctx *Call_treeContext) {}
+
+// EnterStruct_def is called when production struct_def is entered.
+func (s *BaseWystListener) EnterStruct_def(ctx *Struct_defContext) {}
+
+// ExitStruct_def is called when production struct_def is exited.
+func (s *BaseWystListener) ExitStruct_def(ctx *Struct_defContext) {}
+
+// EnterNamespace is called when production namespace is entered.
+func (s *BaseWystListener) EnterNamespace(ctx *NamespaceContext) {}
+
+// ExitNamespace is called when production namespace is exited.
+func (s *BaseWystListener) ExitNamespace(ctx *NamespaceContext) {}
+
+// EnterImport_statement is called when production import_statement is entered.
+func (s *BaseWystListener) EnterImport_statement(ctx *Import_statementContext) {}
+
+// ExitImport_statement is called when production import_statement is exited.
+func (s *BaseWystListener) ExitImport_statement(ctx *Import_statementContext) {}
+
+// EnterUse_statement is called when production use_statement is entered.
+func (s *BaseWystListener) EnterUse_statement(ctx *Use_statementContext) {}
+
+// ExitUse_statement is called when production use_statement is exited.
+func (s *BaseWystListener) ExitUse_statement(ctx *Use_statementContext) {}
+
+// EnterGo_import is called when production go_import is entered.
+func (s *BaseWystListener) EnterGo_import(ctx *Go_importContext) {}
+
+// ExitGo_import is called when production go_import is exited.
+func (s *BaseWystListener) ExitGo_import(ctx *Go_importContext) {}
+
+// EnterMap is called when production map is entered.
+func (s *BaseWystListener) EnterMap(ctx *MapContext) {}
+
+// ExitMap is called when production map is exited.
+func (s *BaseWystListener) ExitMap(ctx *MapContext) {}
+
+// EnterGo_call is called when production go_call is entered.
+func (s *BaseWystListener) EnterGo_call(ctx *Go_callContext) {}
+
+// ExitGo_call is called when production go_call is exited.
+func (s *BaseWystListener) ExitGo_call(ctx *Go_callContext) {}
+
+// EnterIf_expr is called when production if_expr is entered.
+func (s *BaseWystListener) EnterIf_expr(ctx *If_exprContext) {}
+
+// ExitIf_expr is called when production if_expr is exited.
+func (s *BaseWystListener) ExitIf_expr(ctx *If_exprContext) {}
+
+// EnterIf_statement is called when production if_statement is entered.
+func (s *BaseWystListener) EnterIf_statement(ctx *If_statementContext) {}
+
+// ExitIf_statement is called when production if_statement is exited.
+func (s *BaseWystListener) ExitIf_statement(ctx *If_statementContext) {}
+
+// EnterElseif_statement is called when production elseif_statement is entered.
+func (s *BaseWystListener) EnterElseif_statement(ctx *Elseif_statementContext) {}
+
+// ExitElseif_statement is called when production elseif_statement is exited.
+func (s *BaseWystListener) ExitElseif_statement(ctx *Elseif_statementContext) {}
+
+// EnterElse_statement is called when production else_statement is entered.
+func (s *BaseWystListener) EnterElse_statement(ctx *Else_statementContext) {}
+
+// ExitElse_statement is called when production else_statement is exited.
+func (s *BaseWystListener) ExitElse_statement(ctx *Else_statementContext) {}
+
+// EnterIf_tree is called when production if_tree is entered.
+func (s *BaseWystListener) EnterIf_tree(ctx *If_treeContext) {}
+
+// ExitIf_tree is called when production if_tree is exited.
+func (s *BaseWystListener) ExitIf_tree(ctx *If_treeContext) {}
+
+// EnterExpr is called when production expr is entered.
+func (s *BaseWystListener) EnterExpr(ctx *ExprContext) {}
+
+// ExitExpr is called when production expr is exited.
+func (s *BaseWystListener) ExitExpr(ctx *ExprContext) {}
+
+// EnterCode_block is called when production code_block is entered.
+func (s *BaseWystListener) EnterCode_block(ctx *Code_blockContext) {}
+
+// ExitCode_block is called when production code_block is exited.
+func (s *BaseWystListener) ExitCode_block(ctx *Code_blockContext) {}
+
+// EnterTop is called when production top is entered.
+func (s *BaseWystListener) EnterTop(ctx *TopContext) {}
+
+// ExitTop is called when production top is exited.
+func (s *BaseWystListener) ExitTop(ctx *TopContext) {}

parser/wyst_lexer.go

@@ -0,0 +1,253 @@
+// Code generated from Wyst.g4 by ANTLR 4.13.2. DO NOT EDIT.
+
+package parser
+
+import (
+	"fmt"
+	"github.com/antlr4-go/antlr/v4"
+	"sync"
+	"unicode"
+)
+
+// Suppress unused import error
+var _ = fmt.Printf
+var _ = sync.Once{}
+var _ = unicode.IsLetter
+
+type WystLexer struct {
+	*antlr.BaseLexer
+	channelNames []string
+	modeNames    []string
+	// TODO: EOF string
+}
+
+var WystLexerLexerStaticData struct {
+	once                   sync.Once
+	serializedATN          []int32
+	ChannelNames           []string
+	ModeNames              []string
+	LiteralNames           []string
+	SymbolicNames          []string
+	RuleNames              []string
+	PredictionContextCache *antlr.PredictionContextCache
+	atn                    *antlr.ATN
+	decisionToDFA          []*antlr.DFA
+}
+
+func wystlexerLexerInit() {
+	staticData := &WystLexerLexerStaticData
+	staticData.ChannelNames = []string{
+		"DEFAULT_TOKEN_CHANNEL", "HIDDEN",
+	}
+	staticData.ModeNames = []string{
+		"DEFAULT_MODE",
+	}
+	staticData.LiteralNames = []string{
+		"", "'('", "','", "')'", "'{'", "';'", "'}'", "'='", "'.'", "'struct'",
+		"'namespace'", "'include'", "'use'", "'%import'", "'%map'", "'&&'",
+		"'||'", "'if'", "'else'",
+	}
+	staticData.SymbolicNames = []string{
+		"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+		"", "", "COMMENT", "MULTILINE_COMMENT", "WS", "NUMBER", "HEX", "IDENTIFIER",
+		"GOIDENTIFIER", "MATH", "STRING", "MODULE_NAME",
+	}
+	staticData.RuleNames = []string{
+		"T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8",
+		"T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16",
+		"T__17", "COMMENT", "MULTILINE_COMMENT", "WS", "NUMBER", "HEX", "IDENTIFIER",
+		"GOIDENTIFIER", "MATH", "ESC", "STRING", "MODULE_NAME",
+	}
+	staticData.PredictionContextCache = antlr.NewPredictionContextCache()
+	staticData.serializedATN = []int32{
+		4, 0, 28, 266, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2,
+		4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2,
+		10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15,
+		7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7,
+		20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25,
+		2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2,
+		1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8,
+		1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9,
+		1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10,
+		1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1,
+		12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14,
+		1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1,
+		17, 1, 18, 1, 18, 1, 18, 1, 18, 5, 18, 136, 8, 18, 10, 18, 12, 18, 139,
+		9, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 147, 8, 19, 10,
+		19, 12, 19, 150, 9, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 4, 20,
+		158, 8, 20, 11, 20, 12, 20, 159, 1, 20, 1, 20, 1, 21, 1, 21, 5, 21, 166,
+		8, 21, 10, 21, 12, 21, 169, 9, 21, 1, 21, 3, 21, 172, 8, 21, 1, 22, 1,
+		22, 1, 22, 1, 22, 5, 22, 178, 8, 22, 10, 22, 12, 22, 181, 9, 22, 1, 23,
+		1, 23, 5, 23, 185, 8, 23, 10, 23, 12, 23, 188, 9, 23, 1, 23, 1, 23, 1,
+		23, 1, 23, 1, 23, 5, 23, 195, 8, 23, 10, 23, 12, 23, 198, 9, 23, 5, 23,
+		200, 8, 23, 10, 23, 12, 23, 203, 9, 23, 1, 24, 1, 24, 1, 24, 5, 24, 208,
+		8, 24, 10, 24, 12, 24, 211, 9, 24, 1, 24, 1, 24, 1, 24, 5, 24, 216, 8,
+		24, 10, 24, 12, 24, 219, 9, 24, 5, 24, 221, 8, 24, 10, 24, 12, 24, 224,
+		9, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3,
+		25, 235, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 5, 27, 243, 8,
+		27, 10, 27, 12, 27, 246, 9, 27, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 252,
+		8, 27, 10, 27, 12, 27, 255, 9, 27, 1, 27, 3, 27, 258, 8, 27, 1, 28, 1,
+		28, 5, 28, 262, 8, 28, 10, 28, 12, 28, 265, 9, 28, 1, 148, 0, 29, 1, 1,
+		3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23,
+		12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41,
+		21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 0, 55, 27, 57, 28, 1, 0,
+		9, 2, 0, 10, 10, 13, 13, 3, 0, 9, 10, 13, 13, 32, 32, 1, 0, 49, 57, 1,
+		0, 48, 57, 3, 0, 48, 57, 65, 70, 97, 102, 3, 0, 65, 90, 95, 95, 97, 122,
+		4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 3, 0, 42, 43, 45, 45, 47, 47, 2,
+		0, 34, 34, 92, 92, 286, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0,
+		0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1,
+		0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21,
+		1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0,
+		29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0,
+		0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0,
+		0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0,
+		0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 1, 59, 1, 0, 0, 0, 3, 61, 1,
+		0, 0, 0, 5, 63, 1, 0, 0, 0, 7, 65, 1, 0, 0, 0, 9, 67, 1, 0, 0, 0, 11, 69,
+		1, 0, 0, 0, 13, 71, 1, 0, 0, 0, 15, 73, 1, 0, 0, 0, 17, 75, 1, 0, 0, 0,
+		19, 82, 1, 0, 0, 0, 21, 92, 1, 0, 0, 0, 23, 100, 1, 0, 0, 0, 25, 104, 1,
+		0, 0, 0, 27, 112, 1, 0, 0, 0, 29, 117, 1, 0, 0, 0, 31, 120, 1, 0, 0, 0,
+		33, 123, 1, 0, 0, 0, 35, 126, 1, 0, 0, 0, 37, 131, 1, 0, 0, 0, 39, 142,
+		1, 0, 0, 0, 41, 157, 1, 0, 0, 0, 43, 171, 1, 0, 0, 0, 45, 173, 1, 0, 0,
+		0, 47, 182, 1, 0, 0, 0, 49, 204, 1, 0, 0, 0, 51, 234, 1, 0, 0, 0, 53, 236,
+		1, 0, 0, 0, 55, 257, 1, 0, 0, 0, 57, 259, 1, 0, 0, 0, 59, 60, 5, 40, 0,
+		0, 60, 2, 1, 0, 0, 0, 61, 62, 5, 44, 0, 0, 62, 4, 1, 0, 0, 0, 63, 64, 5,
+		41, 0, 0, 64, 6, 1, 0, 0, 0, 65, 66, 5, 123, 0, 0, 66, 8, 1, 0, 0, 0, 67,
+		68, 5, 59, 0, 0, 68, 10, 1, 0, 0, 0, 69, 70, 5, 125, 0, 0, 70, 12, 1, 0,
+		0, 0, 71, 72, 5, 61, 0, 0, 72, 14, 1, 0, 0, 0, 73, 74, 5, 46, 0, 0, 74,
+		16, 1, 0, 0, 0, 75, 76, 5, 115, 0, 0, 76, 77, 5, 116, 0, 0, 77, 78, 5,
+		114, 0, 0, 78, 79, 5, 117, 0, 0, 79, 80, 5, 99, 0, 0, 80, 81, 5, 116, 0,
+		0, 81, 18, 1, 0, 0, 0, 82, 83, 5, 110, 0, 0, 83, 84, 5, 97, 0, 0, 84, 85,
+		5, 109, 0, 0, 85, 86, 5, 101, 0, 0, 86, 87, 5, 115, 0, 0, 87, 88, 5, 112,
+		0, 0, 88, 89, 5, 97, 0, 0, 89, 90, 5, 99, 0, 0, 90, 91, 5, 101, 0, 0, 91,
+		20, 1, 0, 0, 0, 92, 93, 5, 105, 0, 0, 93, 94, 5, 110, 0, 0, 94, 95, 5,
+		99, 0, 0, 95, 96, 5, 108, 0, 0, 96, 97, 5, 117, 0, 0, 97, 98, 5, 100, 0,
+		0, 98, 99, 5, 101, 0, 0, 99, 22, 1, 0, 0, 0, 100, 101, 5, 117, 0, 0, 101,
+		102, 5, 115, 0, 0, 102, 103, 5, 101, 0, 0, 103, 24, 1, 0, 0, 0, 104, 105,
+		5, 37, 0, 0, 105, 106, 5, 105, 0, 0, 106, 107, 5, 109, 0, 0, 107, 108,
+		5, 112, 0, 0, 108, 109, 5, 111, 0, 0, 109, 110, 5, 114, 0, 0, 110, 111,
+		5, 116, 0, 0, 111, 26, 1, 0, 0, 0, 112, 113, 5, 37, 0, 0, 113, 114, 5,
+		109, 0, 0, 114, 115, 5, 97, 0, 0, 115, 116, 5, 112, 0, 0, 116, 28, 1, 0,
+		0, 0, 117, 118, 5, 38, 0, 0, 118, 119, 5, 38, 0, 0, 119, 30, 1, 0, 0, 0,
+		120, 121, 5, 124, 0, 0, 121, 122, 5, 124, 0, 0, 122, 32, 1, 0, 0, 0, 123,
+		124, 5, 105, 0, 0, 124, 125, 5, 102, 0, 0, 125, 34, 1, 0, 0, 0, 126, 127,
+		5, 101, 0, 0, 127, 128, 5, 108, 0, 0, 128, 129, 5, 115, 0, 0, 129, 130,
+		5, 101, 0, 0, 130, 36, 1, 0, 0, 0, 131, 132, 5, 47, 0, 0, 132, 133, 5,
+		47, 0, 0, 133, 137, 1, 0, 0, 0, 134, 136, 8, 0, 0, 0, 135, 134, 1, 0, 0,
+		0, 136, 139, 1, 0, 0, 0, 137, 135, 1, 0, 0, 0, 137, 138, 1, 0, 0, 0, 138,
+		140, 1, 0, 0, 0, 139, 137, 1, 0, 0, 0, 140, 141, 6, 18, 0, 0, 141, 38,
+		1, 0, 0, 0, 142, 143, 5, 47, 0, 0, 143, 144, 5, 42, 0, 0, 144, 148, 1,
+		0, 0, 0, 145, 147, 9, 0, 0, 0, 146, 145, 1, 0, 0, 0, 147, 150, 1, 0, 0,
+		0, 148, 149, 1, 0, 0, 0, 148, 146, 1, 0, 0, 0, 149, 151, 1, 0, 0, 0, 150,
+		148, 1, 0, 0, 0, 151, 152, 5, 42, 0, 0, 152, 153, 5, 47, 0, 0, 153, 154,
+		1, 0, 0, 0, 154, 155, 6, 19, 0, 0, 155, 40, 1, 0, 0, 0, 156, 158, 7, 1,
+		0, 0, 157, 156, 1, 0, 0, 0, 158, 159, 1, 0, 0, 0, 159, 157, 1, 0, 0, 0,
+		159, 160, 1, 0, 0, 0, 160, 161, 1, 0, 0, 0, 161, 162, 6, 20, 0, 0, 162,
+		42, 1, 0, 0, 0, 163, 167, 7, 2, 0, 0, 164, 166, 7, 3, 0, 0, 165, 164, 1,
+		0, 0, 0, 166, 169, 1, 0, 0, 0, 167, 165, 1, 0, 0, 0, 167, 168, 1, 0, 0,
+		0, 168, 172, 1, 0, 0, 0, 169, 167, 1, 0, 0, 0, 170, 172, 5, 48, 0, 0, 171,
+		163, 1, 0, 0, 0, 171, 170, 1, 0, 0, 0, 172, 44, 1, 0, 0, 0, 173, 174, 5,
+		48, 0, 0, 174, 175, 5, 120, 0, 0, 175, 179, 1, 0, 0, 0, 176, 178, 7, 4,
+		0, 0, 177, 176, 1, 0, 0, 0, 178, 181, 1, 0, 0, 0, 179, 177, 1, 0, 0, 0,
+		179, 180, 1, 0, 0, 0, 180, 46, 1, 0, 0, 0, 181, 179, 1, 0, 0, 0, 182, 186,
+		7, 5, 0, 0, 183, 185, 7, 6, 0, 0, 184, 183, 1, 0, 0, 0, 185, 188, 1, 0,
+		0, 0, 186, 184, 1, 0, 0, 0, 186, 187, 1, 0, 0, 0, 187, 201, 1, 0, 0, 0,
+		188, 186, 1, 0, 0, 0, 189, 190, 5, 58, 0, 0, 190, 191, 5, 58, 0, 0, 191,
+		192, 1, 0, 0, 0, 192, 196, 7, 5, 0, 0, 193, 195, 7, 6, 0, 0, 194, 193,
+		1, 0, 0, 0, 195, 198, 1, 0, 0, 0, 196, 194, 1, 0, 0, 0, 196, 197, 1, 0,
+		0, 0, 197, 200, 1, 0, 0, 0, 198, 196, 1, 0, 0, 0, 199, 189, 1, 0, 0, 0,
+		200, 203, 1, 0, 0, 0, 201, 199, 1, 0, 0, 0, 201, 202, 1, 0, 0, 0, 202,
+		48, 1, 0, 0, 0, 203, 201, 1, 0, 0, 0, 204, 205, 5, 94, 0, 0, 205, 209,
+		7, 5, 0, 0, 206, 208, 7, 6, 0, 0, 207, 206, 1, 0, 0, 0, 208, 211, 1, 0,
+		0, 0, 209, 207, 1, 0, 0, 0, 209, 210, 1, 0, 0, 0, 210, 222, 1, 0, 0, 0,
+		211, 209, 1, 0, 0, 0, 212, 213, 5, 46, 0, 0, 213, 217, 7, 5, 0, 0, 214,
+		216, 7, 6, 0, 0, 215, 214, 1, 0, 0, 0, 216, 219, 1, 0, 0, 0, 217, 215,
+		1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 221, 1, 0, 0, 0, 219, 217, 1, 0,
+		0, 0, 220, 212, 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 220, 1, 0, 0, 0,
+		222, 223, 1, 0, 0, 0, 223, 50, 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 225, 235,
+		7, 7, 0, 0, 226, 227, 5, 61, 0, 0, 227, 235, 5, 61, 0, 0, 228, 229, 5,
+		33, 0, 0, 229, 235, 5, 61, 0, 0, 230, 231, 5, 62, 0, 0, 231, 235, 5, 61,
+		0, 0, 232, 233, 5, 60, 0, 0, 233, 235, 5, 61, 0, 0, 234, 225, 1, 0, 0,
+		0, 234, 226, 1, 0, 0, 0, 234, 228, 1, 0, 0, 0, 234, 230, 1, 0, 0, 0, 234,
+		232, 1, 0, 0, 0, 235, 52, 1, 0, 0, 0, 236, 237, 5, 92, 0, 0, 237, 238,
+		9, 0, 0, 0, 238, 54, 1, 0, 0, 0, 239, 244, 5, 34, 0, 0, 240, 243, 3, 53,
+		26, 0, 241, 243, 8, 8, 0, 0, 242, 240, 1, 0, 0, 0, 242, 241, 1, 0, 0, 0,
+		243, 246, 1, 0, 0, 0, 244, 242, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245,
+		247, 1, 0, 0, 0, 246, 244, 1, 0, 0, 0, 247, 258, 5, 34, 0, 0, 248, 253,
+		5, 39, 0, 0, 249, 252, 3, 53, 26, 0, 250, 252, 8, 8, 0, 0, 251, 249, 1,
+		0, 0, 0, 251, 250, 1, 0, 0, 0, 252, 255, 1, 0, 0, 0, 253, 251, 1, 0, 0,
+		0, 253, 254, 1, 0, 0, 0, 254, 256, 1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 256,
+		258, 5, 39, 0, 0, 257, 239, 1, 0, 0, 0, 257, 248, 1, 0, 0, 0, 258, 56,
+		1, 0, 0, 0, 259, 263, 7, 5, 0, 0, 260, 262, 7, 6, 0, 0, 261, 260, 1, 0,
+		0, 0, 262, 265, 1, 0, 0, 0, 263, 261, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0,
+		264, 58, 1, 0, 0, 0, 265, 263, 1, 0, 0, 0, 20, 0, 137, 148, 159, 167, 171,
+		179, 186, 196, 201, 209, 217, 222, 234, 242, 244, 251, 253, 257, 263, 1,
+		6, 0, 0,
+	}
+	deserializer := antlr.NewATNDeserializer(nil)
+	staticData.atn = deserializer.Deserialize(staticData.serializedATN)
+	atn := staticData.atn
+	staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
+	decisionToDFA := staticData.decisionToDFA
+	for index, state := range atn.DecisionToState {
+		decisionToDFA[index] = antlr.NewDFA(state, index)
+	}
+}
+
+// WystLexerInit initializes any static state used to implement WystLexer. By default the
+// static state used to implement the lexer is lazily initialized during the first call to
+// NewWystLexer(). You can call this function if you wish to initialize the static state ahead
+// of time.
+func WystLexerInit() {
+	staticData := &WystLexerLexerStaticData
+	staticData.once.Do(wystlexerLexerInit)
+}
+
+// NewWystLexer produces a new lexer instance for the optional input antlr.CharStream.
+func NewWystLexer(input antlr.CharStream) *WystLexer {
+	WystLexerInit()
+	l := new(WystLexer)
+	l.BaseLexer = antlr.NewBaseLexer(input)
+	staticData := &WystLexerLexerStaticData
+	l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache)
+	l.channelNames = staticData.ChannelNames
+	l.modeNames = staticData.ModeNames
+	l.RuleNames = staticData.RuleNames
+	l.LiteralNames = staticData.LiteralNames
+	l.SymbolicNames = staticData.SymbolicNames
+	l.GrammarFileName = "Wyst.g4"
+	// TODO: l.EOF = antlr.TokenEOF
+
+	return l
+}
+
+// WystLexer tokens.
+const (
+	WystLexerT__0              = 1
+	WystLexerT__1              = 2
+	WystLexerT__2              = 3
+	WystLexerT__3              = 4
+	WystLexerT__4              = 5
+	WystLexerT__5              = 6
+	WystLexerT__6              = 7
+	WystLexerT__7              = 8
+	WystLexerT__8              = 9
+	WystLexerT__9              = 10
+	WystLexerT__10             = 11
+	WystLexerT__11             = 12
+	WystLexerT__12             = 13
+	WystLexerT__13             = 14
+	WystLexerT__14             = 15
+	WystLexerT__15             = 16
+	WystLexerT__16             = 17
+	WystLexerT__17             = 18
+	WystLexerCOMMENT           = 19
+	WystLexerMULTILINE_COMMENT = 20
+	WystLexerWS                = 21
+	WystLexerNUMBER            = 22
+	WystLexerHEX               = 23
+	WystLexerIDENTIFIER        = 24
+	WystLexerGOIDENTIFIER      = 25
+	WystLexerMATH              = 26
+	WystLexerSTRING            = 27
+	WystLexerMODULE_NAME       = 28
+)

parser/wyst_listener.go

@@ -0,0 +1,148 @@
+// Code generated from Wyst.g4 by ANTLR 4.13.2. DO NOT EDIT.
+
+package parser // Wyst
+
+import "github.com/antlr4-go/antlr/v4"
+
+// WystListener is a complete listener for a parse tree produced by WystParser.
+type WystListener interface {
+	antlr.ParseTreeListener
+
+	// EnterRound_def is called when entering the round_def production.
+	EnterRound_def(c *Round_defContext)
+
+	// EnterEnum_curly is called when entering the enum_curly production.
+	EnterEnum_curly(c *Enum_curlyContext)
+
+	// EnterRound_call is called when entering the round_call production.
+	EnterRound_call(c *Round_callContext)
+
+	// EnterFn_call is called when entering the fn_call production.
+	EnterFn_call(c *Fn_callContext)
+
+	// EnterFunc_def is called when entering the func_def production.
+	EnterFunc_def(c *Func_defContext)
+
+	// EnterVar_def is called when entering the var_def production.
+	EnterVar_def(c *Var_defContext)
+
+	// EnterVar_def_set is called when entering the var_def_set production.
+	EnterVar_def_set(c *Var_def_setContext)
+
+	// EnterCall_tree is called when entering the call_tree production.
+	EnterCall_tree(c *Call_treeContext)
+
+	// EnterStruct_def is called when entering the struct_def production.
+	EnterStruct_def(c *Struct_defContext)
+
+	// EnterNamespace is called when entering the namespace production.
+	EnterNamespace(c *NamespaceContext)
+
+	// EnterImport_statement is called when entering the import_statement production.
+	EnterImport_statement(c *Import_statementContext)
+
+	// EnterUse_statement is called when entering the use_statement production.
+	EnterUse_statement(c *Use_statementContext)
+
+	// EnterGo_import is called when entering the go_import production.
+	EnterGo_import(c *Go_importContext)
+
+	// EnterMap is called when entering the map production.
+	EnterMap(c *MapContext)
+
+	// EnterGo_call is called when entering the go_call production.
+	EnterGo_call(c *Go_callContext)
+
+	// EnterIf_expr is called when entering the if_expr production.
+	EnterIf_expr(c *If_exprContext)
+
+	// EnterIf_statement is called when entering the if_statement production.
+	EnterIf_statement(c *If_statementContext)
+
+	// EnterElseif_statement is called when entering the elseif_statement production.
+	EnterElseif_statement(c *Elseif_statementContext)
+
+	// EnterElse_statement is called when entering the else_statement production.
+	EnterElse_statement(c *Else_statementContext)
+
+	// EnterIf_tree is called when entering the if_tree production.
+	EnterIf_tree(c *If_treeContext)
+
+	// EnterExpr is called when entering the expr production.
+	EnterExpr(c *ExprContext)
+
+	// EnterCode_block is called when entering the code_block production.
+	EnterCode_block(c *Code_blockContext)
+
+	// EnterTop is called when entering the top production.
+	EnterTop(c *TopContext)
+
+	// ExitRound_def is called when exiting the round_def production.
+	ExitRound_def(c *Round_defContext)
+
+	// ExitEnum_curly is called when exiting the enum_curly production.
+	ExitEnum_curly(c *Enum_curlyContext)
+
+	// ExitRound_call is called when exiting the round_call production.
+	ExitRound_call(c *Round_callContext)
+
+	// ExitFn_call is called when exiting the fn_call production.
+	ExitFn_call(c *Fn_callContext)
+
+	// ExitFunc_def is called when exiting the func_def production.
+	ExitFunc_def(c *Func_defContext)
+
+	// ExitVar_def is called when exiting the var_def production.
+	ExitVar_def(c *Var_defContext)
+
+	// ExitVar_def_set is called when exiting the var_def_set production.
+	ExitVar_def_set(c *Var_def_setContext)
+
+	// ExitCall_tree is called when exiting the call_tree production.
+	ExitCall_tree(c *Call_treeContext)
+
+	// ExitStruct_def is called when exiting the struct_def production.
+	ExitStruct_def(c *Struct_defContext)
+
+	// ExitNamespace is called when exiting the namespace production.
+	ExitNamespace(c *NamespaceContext)
+
+	// ExitImport_statement is called when exiting the import_statement production.
+	ExitImport_statement(c *Import_statementContext)
+
+	// ExitUse_statement is called when exiting the use_statement production.
+	ExitUse_statement(c *Use_statementContext)
+
+	// ExitGo_import is called when exiting the go_import production.
+	ExitGo_import(c *Go_importContext)
+
+	// ExitMap is called when exiting the map production.
+	ExitMap(c *MapContext)
+
+	// ExitGo_call is called when exiting the go_call production.
+	ExitGo_call(c *Go_callContext)
+
+	// ExitIf_expr is called when exiting the if_expr production.
+	ExitIf_expr(c *If_exprContext)
+
+	// ExitIf_statement is called when exiting the if_statement production.
+	ExitIf_statement(c *If_statementContext)
+
+	// ExitElseif_statement is called when exiting the elseif_statement production.
+	ExitElseif_statement(c *Elseif_statementContext)
+
+	// ExitElse_statement is called when exiting the else_statement production.
+	ExitElse_statement(c *Else_statementContext)
+
+	// ExitIf_tree is called when exiting the if_tree production.
+	ExitIf_tree(c *If_treeContext)
+
+	// ExitExpr is called when exiting the expr production.
+	ExitExpr(c *ExprContext)
+
+	// ExitCode_block is called when exiting the code_block production.
+	ExitCode_block(c *Code_blockContext)
+
+	// ExitTop is called when exiting the top production.
+	ExitTop(c *TopContext)
+}

src/compile.rs

@@ -1,55 +0,0 @@
-use std::fs;
-use std::path::Path;
-use std::process::Command;
-use std::io::{Error, ErrorKind};
-
-pub fn write_to_rust_file(transpiled_code: &str, file_name: &str) -> Result<(), Error> {
-    // Determine the file extension based on the provided file_name
-    let mut output_file = String::from(file_name);
-    if let Some(extension) = Path::new(file_name).extension() {
-        if let Some(ext_str) = extension.to_str() {
-            // Replace the existing extension with ".rs" if it's not already ".rs"
-            if ext_str != "rs" {
-                output_file.push_str(".rs");
-            }
-        }
-    } else {
-        // If no extension is provided, append ".rs" to the file_name
-        output_file.push_str(".rs");
-    }
-
-    // Write the transpiled_code to the determined output file
-    fs::write(&output_file, transpiled_code)?;
-
-    Ok(())
-}
-
-pub fn compile_to_executable(rust_file: &str, output_exe: &str) -> Result<(), Error> {
-    let output = Command::new("rustc")
-        .arg(rust_file)
-        .arg("-o")
-        .arg(output_exe) 
-        .output()?;
-
-    // Check if compilation was successful
-    if output.status.success() {
-        println!("Compilation successful!");
-    } else {
-        if let Some(code) = output.status.code() {
-            eprintln!("Compilation failed with error code: {}", code);
-        }
-        if !output.stdout.is_empty() {
-            eprintln!("Compiler output:\n{}", String::from_utf8_lossy(&output.stdout));
-        }
-        if !output.stderr.is_empty() {
-            eprintln!("Compiler errors:\n{}", String::from_utf8_lossy(&output.stderr));
-        }
-        // Compilation failed, delete the temporary Rust file
-        if let Err(err) = fs::remove_file(rust_file) {
-            eprintln!("Failed to delete temporary Rust file: {}", err);
-        }
-        return Err(Error::new(ErrorKind::Other, "Compilation failed"));
-    }
-
-    Ok(())
-}

src/lexer.rs

@@ -1,288 +0,0 @@
-use regex::Regex;
-use once_cell::sync::Lazy;
-use std::fmt;
-
-pub struct LexerState {
-    pub line: usize,
-    pub column: usize
-}
-
-// Define token types
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum TokenType {
-    Keyword,
-    Newline,
-    Whitespace,
-    Number,
-    Identifier,
-    Ptr,
-    Operator,
-    SecondOperator,
-    Semicolon,
-    Round,
-    Curly,
-    Square,
-    Include,
-    String,
-    // EOF,
-}
-
-#[derive(Clone)]
-pub struct Token {
-    pub token_type: TokenType,
-    pub value: String,
-    pub line: usize,
-    pub column: usize
-}
-
-impl fmt::Debug for Token {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "(TokenType: {:?}, TokenValue: {}, Line: {}, Column {})", self.token_type, self.value.replace("\n", "\\n"), self.line, self.column)
-    }
-}
-
-impl fmt::Display for Token {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(\x1b[33mTokenType:\x1b[0m \x1b[35m{:?}\x1b[0m, \x1b[33mTokenValue:\x1b[0m \x1b[32m\"{}\"\x1b[0m, \x1b[33mLine:\x1b[0m \x1b[36m{}\x1b[0m, \x1b[33mColumn:\x1b[0m \x1b[36m{}\x1b[0m)", self.token_type, self.value.replace("\n", "\\n"), self.line, self.column)
-    }
-}
-
-pub struct Node {
-    token_type: TokenType,
-    token_regex: Lazy<Regex>
-}
-
-const SYNTAX: [Node; 14] = [
-    Node {
-        token_type: TokenType::Semicolon,
-        token_regex: Lazy::new(|| Regex::new(r"^\;").unwrap())
-    },
-    Node {
-        token_type: TokenType::SecondOperator,
-        token_regex: Lazy::new(|| Regex::new(r"^,").unwrap())
-    },
-    Node {
-        token_type: TokenType::String,
-        token_regex: Lazy::new(|| Regex::new("^\"").unwrap())
-    },
-    Node {
-        token_type: TokenType::Whitespace,
-        token_regex: Lazy::new(|| Regex::new(r"^\s+").unwrap())
-    },
-    Node {
-        token_type: TokenType::Keyword,
-        token_regex: Lazy::new(|| Regex::new(r"^mut|try|catch|return|fn\b").unwrap())
-    },
-    Node {
-        token_type: TokenType::Identifier,
-        token_regex: Lazy::new(|| Regex::new(r"^[._a-zA-Z][a-zA-Z0-9_]*(:?\s*<[._a-zA-Z][a-zA-Z0-9_<>]*>)?").unwrap())
-    },
-    Node {
-        token_type: TokenType::Number,
-        token_regex: Lazy::new(|| Regex::new(r"^(:?.)?(:?0[x|X])?\d+(:?.\d+)?\b").unwrap())
-    },
-    Node {
-        token_type: TokenType::Ptr,
-        token_regex: Lazy::new(|| Regex::new(r"^->").unwrap())
-    },
-    Node {
-        token_type: TokenType::Operator,
-        token_regex: Lazy::new(|| Regex::new(r"^[|\-|\+|\*|\=|\!]").unwrap())
-    },
-    Node {
-        token_type: TokenType::Round,
-        token_regex: Lazy::new(|| Regex::new(r"^[\(|\)]").unwrap())
-    },
-    Node {
-        token_type: TokenType::Curly,
-        token_regex: Lazy::new(|| Regex::new(r"^[\{|\}]").unwrap())
-    },
-    Node {
-        token_type: TokenType::Square,
-        token_regex: Lazy::new(|| Regex::new(r"^[\[|\]]").unwrap())
-    },
-    Node {
-        token_type: TokenType::Include,
-        token_regex: Lazy::new(|| Regex::new(r"^#include *<(.*?)>").unwrap())
-    },
-    Node {
-        token_type: TokenType::Include,
-        token_regex: Lazy::new(|| Regex::new(r#"^#include *"(.*?)""#).unwrap())
-    }
-];
-
-fn get_first_char(value: &str) -> String {
-    value.chars().next().unwrap().to_string()
-}
-
-pub fn lex(mut code: &str, use_whitespace: bool, state: LexerState) -> Result<Vec<Token>, (LexerState, Vec<Token>)> {
-    let mut state = state;
-    let mut tokens: Vec<Token> = Vec::new();
-    let mut brstr: String = String::new();
-    let mut br_state: LexerState = LexerState { line: 0, column: 0 };
-    let mut brtp: Vec<u8> = Vec::new();
-    while !code.is_empty() {
-        let mut is_match = false;
-        let fch = get_first_char(code);
-        let brln = brtp.len();
-        match fch.as_str() {
-            "\"" => {
-                brstr += "\"";
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 && brtp[brln-1] == 0 {
-                    brtp.pop();
-                    tokens.push(Token {
-                        token_type: TokenType::String,
-                        value: brstr.clone(),
-                        column: br_state.column,
-                        line: br_state.line
-                    });
-                    brstr = String::new();
-                } else if brln == 0 {
-                    brtp.push(0);
-                    br_state.line = state.line;
-                    br_state.column = state.column;
-                }
-            }
-            "'" => {
-                brstr += "'";
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 && brtp[brln-1] == 1 {
-                    brtp.pop();
-                    tokens.push(Token {
-                        token_type: TokenType::String,
-                        value: brstr.clone(),
-                        column: br_state.column,
-                        line: br_state.line
-                    });
-                    brstr = String::new();
-                } else if brln == 0 {
-                    brtp.push(1);
-                    br_state.line = state.line;
-                    br_state.column = state.column;
-                }
-            }
-            "(" => {
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 {
-                    brstr += fch.as_str();
-                } else {
-                    br_state.line = state.line;
-                    br_state.column = state.column;
-                }
-                brtp.push(2);
-            }
-            ")" => {
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 && brtp[brln-1] == 2 {
-                    brtp.pop();
-                    if brln == 1 {
-                        tokens.push(Token {
-                            token_type: TokenType::Round,
-                            value: brstr.clone(),
-                            column: br_state.column,
-                            line: br_state.line
-                        });
-                        brstr = String::new();
-                    } else {brstr += fch.as_str();}
-                } else {brstr += fch.as_str();}
-            }
-            "{" => {
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 {
-                    brstr += fch.as_str();
-                } else {
-                    br_state.line = state.line;
-                    br_state.column = state.column;
-                }
-                brtp.push(3);
-            }
-            "}" => {
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 && brtp[brln-1] == 3 {
-                    brtp.pop();
-                    if brln == 1 {
-                        tokens.push(Token {
-                            token_type: TokenType::Curly,
-                            value: brstr.clone(),
-                            column: br_state.column,
-                            line: br_state.line
-                        });
-                        brstr = String::new();
-                    } else {brstr += fch.as_str();}
-                } else {brstr += fch.as_str();}
-            }
-            "[" => {
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 {
-                    brstr += fch.as_str();
-                } else {
-                    br_state.line = state.line;
-                    br_state.column = state.column;
-                }
-                brtp.push(3);
-            }
-            "]" => {
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 && brtp[brln-1] == 3 {
-                    brtp.pop();
-                    if brln == 1 {
-                        tokens.push(Token {
-                            token_type: TokenType::Square,
-                            value: brstr.clone(),
-                            column: br_state.column,
-                            line: br_state.line
-                        });
-                        brstr = String::new();
-                    } else {brstr += fch.as_str();}
-                } else {brstr += fch.as_str();}
-            }
-            "\\" => {
-                brstr += "\\";
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if code.len() > 0 {
-                    let sch = get_first_char(code);
-                    code = code.strip_prefix(sch.as_str()).expect("");
-                    brstr += &sch;
-                }
-            }
-            "\n" => {
-                code = code.strip_prefix(fch.as_str()).expect("");
-                if brln > 0 {
-                    brstr += "\n";
-                }
-                state.line += 1;
-                state.column = 0;
-            }
-            _ => {
-                if brln > 0 {
-                    code = code.strip_prefix(fch.as_str()).expect("");
-                    brstr += fch.as_str();
-                } else {
-                    for s in &SYNTAX {
-                        if let Some(caps) = s.token_regex.captures(code) {
-                            is_match = true;
-                            code = code.strip_prefix(&caps[0]).unwrap_or(code);
-                            if (!use_whitespace && s.token_type!=TokenType::Whitespace) || use_whitespace {
-                                tokens.push(Token {
-                                    token_type: s.token_type,
-                                    value: caps[0].to_string(),
-                                    line: state.line,
-                                    column: state.column
-                                });
-                            }
-                            state.column += caps[0].len();
-                        } else {
-                            continue;
-                        };
-                        break;
-                    }
-                    if !is_match {
-                        return Err((state, tokens));
-                    }
-                }
-            }
-        }
-    }
-    Ok(tokens)
-}

src/main.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+
+	"github.com/urfave/cli/v2"
+)
+
+func main() {
+	app := &cli.App{
+		Name:    "Wyst",
+		Version: "alpha_0.0.1",
+		Authors: []*cli.Author{
+			{Name: "Orus"},
+		},
+		Usage: "The wyst compiler",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "output",
+				Aliases: []string{"o"},
+				Usage:   "Specifies the output binary file name",
+			},
+		},
+		Action: func(c *cli.Context) error {
+			if c.NArg() < 1 {
+				return cli.Exit("Error: <file> argument is required.", 1)
+			}
+			file := c.Args().Get(0)
+			if FileExists(file) {
+				root := NewRoot(file)
+				WriteRoot(root)
+				cmd := exec.Command("go", "build", "-o", "../out", "./")
+				cmd.Dir = "./build"
+
+				output, err := cmd.CombinedOutput()
+				if err != nil {
+					fmt.Println("Error:", err)
+				}
+				fmt.Println(string(output))
+				// os.RemoveAll(OUT_FOLDER)
+			} else {
+				return cli.Exit(fmt.Sprintf("Error: file '%s' not found.", file), 1)
+			}
+			return nil
+		},
+	}
+	err := app.Run(os.Args)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

src/main.rs

@@ -1,55 +0,0 @@
-mod transpiler;
-mod parser;
-mod lexer;
-mod compile; 
-use std::fs;
-use clap::Parser;
-use lexer::LexerState;
-
-// Arguments for Wyst (short and long version)
-#[derive(Parser)]
-struct Args {
-    #[clap()]
-    file: std::path::PathBuf,
-
-    #[clap(short, long)]
-    rust: Option<String>,
-
-    #[clap(short, long)]
-    compile: Option<String>,
-}
-
-fn main() {
-    let args = Args::parse();
-    let file_content = fs::read_to_string(&args.file)
-        .expect("Error reading file");
-
-    let transpiled_code = transpiler::transpile(file_content, 0, LexerState { line: 1, column: 0 });
-
-    match args.rust {
-        Some(ref rust_file_name) => {
-            // Write transpiled code to Rust file
-            compile::write_to_rust_file(&transpiled_code, rust_file_name)
-                .expect("Error writing to Rust file");
-            println!("Transpiled code written to {}", rust_file_name);
-        }
-        None => {
-            // No Rust file specified, print transpiled code
-            println!("{}", transpiled_code);
-        }
-    }
-
-    match args.compile {
-        Some(ref exe_name) => {
-            // Compile transpiled Rust code into executable
-            compile::write_to_rust_file(&transpiled_code, "temp.rs")
-                .expect("Error writing to temporary Rust file");
-            compile::compile_to_executable("temp.rs", exe_name)
-                .expect("Error compiling to executable");
-            fs::remove_file("temp.rs")
-                .expect("Error removing temporary Rust file");
-            println!("Compiled executable: {}", exe_name);
-        }
-        None => {}
-    }
-}

src/parser.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"github.com/antlr4-go/antlr/v4"
+	"github.com/wyst-lang/wyst/parser"
+)
+
+type ASTNode struct {
+	Rule  string
+	Text  string
+	Inner []ASTNode
+}
+
+func getTokenName(tokenType int, lexer *parser.WystLexer) string {
+	if tokenType >= 0 && tokenType < len(lexer.SymbolicNames) {
+		if lexer.SymbolicNames[tokenType] != "" {
+			return lexer.SymbolicNames[tokenType]
+		}
+		return lexer.LiteralNames[tokenType]
+	}
+	return "UNKNOWN"
+}
+
+func ConvertAST(node antlr.Tree, wparser *parser.WystParser, lexer *parser.WystLexer) ASTNode {
+	var ast = ASTNode{}
+	switch node := node.(type) {
+	case antlr.TerminalNode:
+		token := node.GetSymbol()
+		ast.Text = token.GetText()
+		ast.Rule = getTokenName(token.GetTokenType(), lexer)
+	default:
+		if ruleContext, ok := node.(antlr.RuleContext); ok {
+			ast.Rule = wparser.RuleNames[ruleContext.GetRuleIndex()]
+		}
+		if parseTree, ok := node.(antlr.ParseTree); ok {
+			ast.Text = parseTree.GetText()
+		}
+		for i := 0; i < node.GetChildCount(); i++ {
+			l := ConvertAST(node.GetChild(i), wparser, lexer)
+			if l.Rule != ("'"+l.Text+"'") || l.Text == ";" || l.Text == "," {
+				ast.Inner = append(ast.Inner, l)
+			}
+		}
+	}
+	return ast
+}
+
+func Parse(code string) ASTNode {
+	chars := antlr.NewInputStream(code)
+	lexer := parser.NewWystLexer(chars)
+	stream := antlr.NewCommonTokenStream(lexer, 0)
+	p := parser.NewWystParser(stream)
+	// p.AddErrorListener(antlr.NewDiagnosticErrorListener(true).WithContext(p))
+	tree := p.Top()
+	return ConvertAST(tree, p, lexer)
+}

src/parser.rs

@@ -1,120 +0,0 @@
-use  crate::lexer::{Token, TokenType};
-use std::fmt;
-use regex::Regex;
-use once_cell::sync::Lazy;
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum AstType {
-    FunctionDeceleration,
-    VoidFunctionDeceleration,
-    VariableDeceleration,
-    MutVariableDeceleration,
-    Include,
-    IncludeLocal,
-    CodeBlock,
-    Other
-}
-
-pub struct Ast {
-    pub tokens: Vec<Token>,
-    pub ast_type: AstType
-}
-
-impl fmt::Display for Ast {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "\x1b[36m{:?}:\x1b[0m [\n", self.ast_type)?;
-        for (i, token) in self.tokens.iter().enumerate() {
-            if i < self.tokens.len() - 1 {
-                write!(f, "    {},\n", token)?;
-            } else {
-                write!(f, "    {}\n", token)?;
-            }
-        }
-        write!(f, "]")
-    }
-}
-
-impl fmt::Debug for Ast {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}: [\n", self.ast_type)?;
-        for (i, token) in self.tokens.iter().enumerate() {
-            if i < self.tokens.len() - 1 {
-                write!(f, "    {:?},\n", token)?;
-            } else {
-                write!(f, "    {:?}\n", token)?;
-            }
-        }
-        write!(f, "]")
-    }
-}
-
-pub struct Parser {
-    pub tokens: Vec<Token>,
-    pub index: u32,
-    pub include_regex: Lazy<Regex>,
-    pub include_regex_local: Lazy<Regex>
-}
-
-impl Parser {
-    pub fn new(tokens: Vec<Token>) -> Parser {
-        Parser {
-            tokens: tokens,
-            index: 0,
-            include_regex: Lazy::new(|| Regex::new(r"^(#include *)<(.*?)>").unwrap()),
-            include_regex_local: Lazy::new(|| Regex::new(r#"^(#include *)"(.*?)""#).unwrap())
-        }
-    }
-    pub fn next(&mut self) -> Ast {
-        let mut ast_res: Ast = Ast {tokens: vec![], ast_type: AstType::Other};
-        let index = self.index as usize;
-        if index == self.tokens.len() {panic!("Reached the end of tokens")}
-        let token = &self.tokens[index];
-        match token.token_type {
-            TokenType::Identifier => {
-                ast_res.tokens.push(self.tokens[index].clone());
-                if self.tokens.len()-index > 3 && self.tokens[index+1].token_type==TokenType::Identifier && self.tokens[index+2].token_type==TokenType::Round && self.tokens[index+3].token_type==TokenType::Curly {
-                    ast_res.tokens.push(self.tokens[index+1].clone());
-                    ast_res.tokens.push(self.tokens[index+2].clone());
-                    ast_res.tokens.push(self.tokens[index+3].clone());
-                    if token.value == "void" {
-                        ast_res.ast_type = AstType::VoidFunctionDeceleration;
-                    } else {
-                        ast_res.ast_type = AstType::FunctionDeceleration;
-                    }
-                    self.index += 3;
-                } else if self.tokens.len()-index > 1 {
-                    if token.value == "cb" && self.tokens[index+1].token_type == TokenType::Curly {
-                        ast_res.tokens.push(self.tokens[index+1].clone());
-                        ast_res.ast_type = AstType::CodeBlock;
-                        self.index += 1;
-                    } else if self.tokens[index+1].token_type==TokenType::Identifier {
-                        ast_res.tokens.push(self.tokens[index+1].clone());
-                        ast_res.ast_type = AstType::VariableDeceleration;
-                        self.index += 1;
-                    } else if self.tokens[index+1].value=="mut" && self.tokens[index+2].token_type==TokenType::Identifier {
-                        ast_res.tokens.push(self.tokens[index+2].clone());
-                        ast_res.ast_type = AstType::MutVariableDeceleration;
-                        self.index += 2;
-                    }
-                }
-            }
-            TokenType::Include => {
-                if let Some(caps) = self.include_regex.captures(&token.value) {
-                    ast_res.tokens.push(Token {token_type: TokenType::String, value: caps[2].to_owned().to_string(), line: 0, column: 0});
-                    ast_res.ast_type = AstType::Include;
-                } else if let Some(caps) = self.include_regex_local.captures(&token.value) {
-                    ast_res.tokens.push(Token {token_type: TokenType::String, value: caps[2].to_owned().to_string(), line: 0, column: 0});
-                    ast_res.ast_type = AstType::IncludeLocal;
-                } else {
-                    ast_res.tokens.push(token.clone());
-                    ast_res.ast_type = AstType::Include;
-                }
-            }
-            _ => {
-                ast_res.tokens.push(token.clone());
-            }
-        }
-        self.index += 1;
-        ast_res
-    }
-}

src/transpiler.go

@@ -0,0 +1,190 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+type wmap [2]string
+
+var wyst_map []wmap = []wmap{{"int", "int"}, {"void", "void"}, {"main", "main"}, {"string", "string"}, {"true", "true"}, {"false", "false"}}
+
+func TranspileToken(node ASTNode) string {
+	res := ""
+	switch node.Rule {
+
+	case "NUMBER":
+		res += node.Text
+	case "IDENTIFIER":
+		for _, i := range wyst_map {
+			if node.Text == i[0] {
+				return i[1]
+			}
+		}
+		res += "I0x"
+		for _, c := range node.Text {
+			if c == ':' || c == '.' {
+				res += string(c)
+			} else {
+				res += fmt.Sprintf("%x", c)
+			}
+		}
+		res = strings.ReplaceAll(res, "::", ".I0x")
+	case "HEX":
+		res += node.Text
+	case "MATH":
+		res += node.Text
+	case "STRING":
+		if strings.HasPrefix(node.Text, "'") {
+			res += "\"" + strings.ReplaceAll(strings.TrimSuffix(strings.TrimPrefix(node.Text, "'"), "'"), "\\'", "'") + "\""
+		} else {
+			res += node.Text
+		}
+	case "';'":
+		res += "\n  "
+	case "','":
+		res += ", "
+	case "IDENT":
+		res += fmt.Sprintf("_%#x", node.Text)
+	case "GOIDENTIFIER":
+		res += strings.TrimPrefix(node.Text, "^")
+	default:
+		fmt.Printf("\x1b[33mDEV NOTICE:\x1b[0m Missing token case for '%s'\n", node.Rule)
+
+	}
+
+	return res
+}
+
+func (m *Module) TranspileNode(node ASTNode) string {
+	res := ""
+	if node.Rule == strings.ToUpper(node.Rule) {
+		return TranspileToken(node)
+	}
+	switch node.Rule {
+
+	case "func_def":
+		return_type := m.TranspileNode(node.Inner[0])
+		if return_type == "void" {
+			return_type = ""
+		}
+		res += fmt.Sprintf("func %s%s %s %s", m.TranspileNode(node.Inner[1]), m.TranspileNode(node.Inner[2]), return_type, m.TranspileNode(node.Inner[3]))
+	case "expr":
+		res += m.TranspileNodes(node.Inner)
+	case "code_block":
+		res += fmt.Sprintf("{\n  %s}", strings.TrimRight(m.TranspileNodes(node.Inner), " "))
+	case "var_def":
+		res += fmt.Sprintf("var %s %s", m.TranspileNode(node.Inner[1]), m.TranspileNode(node.Inner[0]))
+	case "round_def":
+		res += fmt.Sprintf("(%s)", strings.TrimRight(strings.ReplaceAll(m.TranspileNodes(node.Inner), "var ", ""), " "))
+	case "call_tree":
+		for i, c := range node.Inner {
+			res += m.TranspileNode(c)
+			if i+1 < len(node.Inner) {
+				res += "."
+			}
+		}
+
+	case "fn_call":
+		res += m.TranspileNode(node.Inner[0])
+		res += m.TranspileNode(node.Inner[1])
+
+	case "struct_def":
+		res += fmt.Sprintf("type %s struct %s\n", m.TranspileNode(node.Inner[0]), m.TranspileNode(node.Inner[1]))
+
+	case "enum_curly":
+		res += fmt.Sprintf("{\n  %s}", strings.TrimRight(m.TranspileNodes(node.Inner), " "))
+
+	case "namespace":
+		namespace_name := "n" + m.TranspileNode(node.Inner[0])
+		res += fmt.Sprintf("type %s struct {\n  ", namespace_name)
+		vals := ""
+		for _, c := range node.Inner {
+			if c.Rule == "var_def" {
+				res += strings.TrimPrefix(m.TranspileNode(c), "var ")
+				res += "\n  "
+			} else if c.Rule == "var_def_set" {
+				res += strings.TrimPrefix(m.TranspileNode(c.Inner[0]), "var ")
+				res += "\n  "
+				vals += fmt.Sprintf("%s: %s, ", m.TranspileNode(c.Inner[0].Inner[1]), m.TranspileNode(c.Inner[1]))
+			}
+		}
+		res += "}\n"
+		for _, c := range node.Inner {
+			if c.Rule == "func_def" {
+				return_type := m.TranspileNode(c.Inner[0])
+				if return_type == "void" {
+					return_type = ""
+				}
+				res += fmt.Sprintf("func (%s) %s%s %s %s", namespace_name, m.TranspileNode(c.Inner[1]), m.TranspileNode(c.Inner[2]), return_type, m.TranspileNode(c.Inner[3]))
+				res += "\n  "
+			}
+		}
+		res += fmt.Sprintf("var %s %s = %s{%s}", m.TranspileNode(node.Inner[0]), namespace_name, namespace_name, vals)
+
+	case "var_def_set":
+		res += fmt.Sprintf("%s = %s", m.TranspileNode(node.Inner[0]), m.TranspileNode(node.Inner[1]))
+
+	case "import_statement":
+		res += fmt.Sprintf("import . \"%s\"\n", m.ImportModule(node.Inner[0].Text))
+
+	case "use_statement":
+		ident := strings.Split(node.Inner[0].Text, "::")
+		ident2 := strings.Split(m.TranspileNode(node.Inner[0]), ".")
+		modname := m.ImportModule(ident[0])
+		md := strings.Split(modname, "/")
+		res += fmt.Sprintf("import %s \"%s\"\n", md[len(md)-1], modname)
+		if len(ident) > 1 {
+			res += fmt.Sprintf("var %s = %s\n", ident2[len(ident2)-1], m.TranspileNode(node.Inner[0]))
+		}
+
+	case "go_import":
+		res += "import " + m.TranspileNode(node.Inner[0]) + "\n"
+
+	case "map":
+		wyst_map = append(wyst_map, wmap{node.Inner[0].Text, node.Inner[2].Text})
+
+	case "go_call":
+		res += m.TranspileNode(node.Inner[0])
+		res += m.TranspileNode(node.Inner[1])
+
+	case "round_call":
+		res += "(" + m.TranspileNodes(node.Inner) + ")"
+
+	case "if_tree":
+		res += m.TranspileNodes(node.Inner)
+
+	case "if_statement":
+		res += "if " + m.TranspileNodes(node.Inner)
+
+	case "if_expr":
+		res += m.TranspileNodes(node.Inner)
+
+	case "else_statement":
+		res += "else "
+		res += m.TranspileNodes(node.Inner)
+
+	case "elseif_statement":
+		res += "else "
+		res += m.TranspileNodes(node.Inner)
+
+	default:
+		fmt.Printf("\x1b[33mDEV NOTICE:\x1b[0m Missing case for '%s'\n", node.Rule)
+
+	}
+	return res
+}
+
+func (m *Module) TranspileNodes(nodes []ASTNode) string {
+	res := ""
+	for i := 0; i < len(nodes); i++ {
+		res += m.TranspileNode(nodes[i])
+	}
+	return res
+}
+
+func (m *Module) Transpile(code string) string {
+	ast := Parse(code)
+	res := m.TranspileNodes(ast.Inner)
+	return res
+}

src/transpiler.rs

@@ -1,150 +0,0 @@
-use crate::lexer::{lex, LexerState, TokenType};
-use crate::parser::{Parser, AstType};
-
-pub fn transpile(input: String, indent: u32, state: LexerState) -> String {
-    let mut result = String::new();
-    
-    if indent == 0 {
-        result += "type int = i32;\n";
-    } else {
-        result += " ".repeat((indent as usize) * 2).as_str();
-    }
-    
-    let lexer_out = lex(input.as_str(), false, state);
-    
-    match lexer_out {
-        Ok(tokens) => {
-            let mut full_ast = Parser::new(tokens.clone());
-            
-            while full_ast.tokens.len() > full_ast.index as usize {
-                let ast = full_ast.next();
-                println!("{ast}");
-                
-                if ast.ast_type == AstType::FunctionDeceleration {
-                    result += format!(
-                        "fn {}({}) -> {} {}",
-                        ast.tokens[1].value,
-                        transpile_round(ast.tokens[2].value.clone(), LexerState {
-                            line: ast.tokens[2].line,
-                            column: ast.tokens[2].column
-                        }),
-                        ast.tokens[0].value,
-                        transpile(
-                            ast.tokens[3].value.clone(),
-                            indent + 1,
-                            LexerState {
-                                line: ast.tokens[3].line,
-                                column: ast.tokens[3].column
-                            }
-                        )
-                    )
-                    .as_str();
-                } else if ast.ast_type == AstType::VoidFunctionDeceleration {
-                    result += format!(
-                        "fn {}({}) {}",
-                        ast.tokens[1].value,
-                        transpile_round(ast.tokens[2].value.clone(), LexerState {
-                            line: ast.tokens[2].line,
-                            column: ast.tokens[2].column
-                        }),
-                        transpile(
-                            ast.tokens[3].value.clone(),
-                            indent + 1,
-                            LexerState {
-                                line: ast.tokens[3].line,
-                                column: ast.tokens[3].column
-                            }
-                        )
-                    )
-                    .as_str();
-                } else if ast.ast_type == AstType::VariableDeceleration {
-                    result += format!("let {}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str();
-                } else if ast.ast_type == AstType::MutVariableDeceleration {
-                    result += format!("let mut {}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str();
-                } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round {
-                    result += format!(
-                        "({})",
-                        transpile_round(ast.tokens[0].value.clone(), LexerState {
-                            line: ast.tokens[0].line,
-                            column: ast.tokens[0].column
-                        })
-                    )
-                    .as_str();
-                } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Curly {
-                    if ast.tokens[0].token_type == TokenType::Newline {
-                        result += (ast.tokens[0].value.as_str().to_owned()
-                            + (" ".repeat((indent as usize) * 2).as_str()))
-                        .as_str();
-                    } else {
-                        result += ast.tokens[0].value.as_str();
-                    }
-                } else {
-                    if ast.tokens[0].token_type == TokenType::Newline {
-                        result += (ast.tokens[0].value.as_str().to_owned()
-                            + (" ".repeat((indent as usize) * 2).as_str()))
-                        .as_str();
-                    } else if ast.tokens[0].token_type == TokenType::Semicolon {
-                        result += ";\n";
-                        result += " ".repeat((indent as usize) * 2).as_str();
-                    } else {
-                        result += ast.tokens[0].value.as_str();
-                    }
-                }
-            }
-            
-            result = result.trim_end().to_string();
-            
-            if indent > 0 {
-                result += "\n";
-                result += " ".repeat((indent as usize - 1) * 2).as_str();
-                return "{\n".to_owned() + result.as_str() + "}";
-            } else {
-                return result;
-            }
-        }
-        Err((state, _tokens)) => {
-            println!("Invalid syntax at code.ws:{}:{}", state.line, state.column);
-            return "".to_string();
-        }
-    }
-}
-
-pub fn transpile_round(input: String, state: LexerState) -> String {
-    let mut result = String::new();
-    let lexer_out = lex(input.as_str(), false, state);
-    
-    match lexer_out {
-        Ok(tokens) => {
-            let mut full_ast = Parser::new(tokens.clone());
-            
-            while full_ast.tokens.len() > full_ast.index as usize {
-                let ast = full_ast.next();
-                println!("{ast}");
-                
-                if ast.ast_type == AstType::VariableDeceleration {
-                    result += format!("{}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str();
-                } else if ast.ast_type == AstType::MutVariableDeceleration {
-                    result += format!("mut {}: {}", ast.tokens[1].value, ast.tokens[0].value).as_str();
-                } else if ast.tokens.len() == 1 && ast.tokens[0].token_type == TokenType::Round {
-                    result += format!(
-                        "({})",
-                        transpile_round(ast.tokens[0].value.clone(), LexerState {
-                            line: ast.tokens[0].line,
-                            column: ast.tokens[0].column
-                        })
-                    )
-                    .as_str();
-                } else {
-                    result += ast.tokens[0].value.as_str()
-                }
-            }
-            
-            result = result.trim_end().to_string();
-            result
-        }
-        Err((state, _tokens)) => {
-            println!("Invalid syntax at code.ws:{}:{}", state.line, state.column);
-            return "".to_string();
-        }
-    }
-}

src/utils.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strings"
+)
+
+const OUT_FOLDER = "build/"
+
+func FileExists(filename string) bool {
+	_, err := os.Stat(filename)
+	return err == nil || !os.IsNotExist(err)
+}
+
+type Module struct {
+	Code  string
+	Name  string
+	Path  string
+	Out   string
+	Inner []Module
+}
+
+func writeFile(file_name, file_content string) {
+	os.MkdirAll(path.Dir(file_name), os.ModePerm)
+	file, err := os.Create(file_name)
+	if err != nil {
+		fmt.Printf("Error creating file (%s): %v\n", file_name, err)
+		return
+	}
+	defer file.Close()
+	_, err = file.WriteString(file_content)
+	if err != nil {
+		fmt.Println("Error writing to file:", err)
+		return
+	}
+}
+
+func readFile(file_name string) string {
+	out, _ := os.ReadFile(file_name)
+	return string(out)
+}
+
+func NewRoot(file_path string) Module {
+	root := Module{}
+
+	root.Path = file_path
+	root.Out = OUT_FOLDER + "main.go"
+	root.Name = "root"
+	root.Code = root.Transpile(readFile(file_path))
+
+	return root
+}
+
+func (root *Module) ImportModule(modname string) string {
+	module := Module{Name: modname}
+	module.Path = path.Join(path.Dir(root.Path), module.Name+".wyst")
+	if !FileExists(module.Path) {
+		module.Path = path.Join(path.Dir(root.Path), module.Name, "mod.wyst")
+	}
+
+	if FileExists(module.Path) {
+		module.Out = fmt.Sprintf("%s/I%#x/%s.go", path.Dir(root.Out), module.Name, module.Name)
+		module.Code = "package " + fmt.Sprintf("_%#x", modname) + "\n" + module.Transpile(readFile(module.Path))
+		root.Inner = append(root.Inner, module)
+	}
+	return fmt.Sprintf("%s/I%#x", path.Dir(root.Out), module.Name)
+}
+
+func WriteModules(root Module) {
+	for _, module := range root.Inner {
+		writeFile(module.Out, module.Code)
+		WriteModules(module)
+	}
+}
+
+func WriteRoot(root Module) {
+	writeFile(OUT_FOLDER+"main.go", "package main\n"+root.Code)
+	writeFile(OUT_FOLDER+"go.mod", "module "+strings.ReplaceAll(OUT_FOLDER, "/", "")+"\n"+"go 1.22\ntoolchain go1.22.6")
+	WriteModules(root)
+}