explained myself

README.md

@@ -10,3 +10,5 @@ fnaf adder(a, b) {
 
 assert_eq(200, adder(able, os));
 ```
+
+Yes, the FNAF part is real.

TAGS~

@@ -0,0 +1,159 @@
+
+Cargo.lock,0
+
+Cargo.toml,0
+
+README.md,130
+# ![SkyLang](.images/slang_logo_dark_transparent_not_motto.png)![SkyLang](.images/slang_logo_dark_transparent_not_motto.png)
1,0
+
+src/codegen/fasm.rs,91
+pub fn fasm_codegen(exprs: &Vec<Expr>, not_a_function: bool) -> String {fasm_codegen
3,27
+
+src/codegen/fasmarm.rs,0
+
+src/codegen/mod.rs,23
+pub mod fasm;fasm
1,0
+
+src/lex/mod.rs,47
+pub mod tok;tok
1,0
+pub mod parse;parse
2,13
+
+src/lex/parse.rs,755
+pub fn match_single_char<'a>(word: &'a str) -> Option<Token<'a>> {match_single_char
6,40
+    macro_rules! tok {tok
7,107
+pub fn match_keyword<'a>(word: &'a str) -> Option<Token<'a>> {match_keyword
38,697
+    macro_rules! tok {tok
39,760
+pub fn match_two_char<'a>(word: &'a str) -> Option<Token<'a>> {match_two_char
66,1310
+    macro_rules! tok {tok
67,1374
+pub fn match_string_literal<'a>(word: &'a str) -> Option<Token<'a>> {match_string_literal
85,1681
+    macro_rules! tok {tok
86,1751
+pub fn match_int_literal<'a>(word: &'a str) -> Option<Token<'a>> {match_int_literal
114,2191
+    macro_rules! tok {tok
115,2258
+pub fn match_identifier<'a>(word: &'a str) -> Option<Token<'a>> {match_identifier
134,2562
+    macro_rules! tok {tok
135,2628
+
+src/lex/tok.rs,2268
+pub struct Token<'a> {Token
6,79
+    tt: TokenType,tt
7,102
+    word: &'a str,word
8,121
+pub enum TokenType {TokenType
12,160
+    EOF,EOF
13,181
+    Semicolon,	// ;Semicolon
16,222
+    Equal,	// =Equal
17,242
+    LeftParen,	// (LeftParen
18,258
+    RightParen, // )RightParen
19,278
+    LeftBrace,	// {LeftBrace
20,299
+    RightBrace, // }RightBrace
21,319
+    Comma,	// ,Comma
22,340
+    Dot,	// .Dot
23,356
+    Minus,	// -Minus
24,370
+    Plus,	// +Plus
25,386
+    Slash,	// /Slash
26,401
+    Star,	// *Star
27,417
+    Percent,	// %Percent
28,432
+    Bang,	// !Bang
29,450
+    Colon,	// :Colon
30,465
+    Less,	// <Less
31,481
+    Greater,	// >Greater
32,496
+    Fn,		// fnFn
35,531
+    Let,	// letLet
36,546
+    If,		// ifIf
37,562
+    Else,	// elseElse
38,577
+    While,	// whileWhile
39,595
+    Elif,	// elifElif
40,615
+    Return,	// returnReturn
41,633
+    For,	// forFor
42,655
+    In,		// inIn
43,671
+    Break,	// breakBreak
44,686
+    Continue,	// continueContinue
45,706
+    EqualEqual,		// ==EqualEqual
48,761
+    BangEqual,		// !=BangEqual
49,784
+    LessEqual,		// <=LessEqual
50,806
+    GreaterEqual,	// >=GreaterEqual
51,828
+    String,	// A string literal.String
54,873
+    Number,	// An integer.Number
55,906
+    Identifier, // An identifier.Identifier
56,933
+    True,	// trueTrue
57,967
+    False,	// falseFalse
58,985
+    Null,	// NoneNull
59,1005
+    Error, // A syntax error.Error
62,1037
+pub struct Lexer<'a> {Lexer
66,1087
+    source: &'a str,source
67,1110
+    tokens: Vec<Token<'a>>,tokens
68,1131
+    current: usize,current
69,1159
+    after: &'a strafter
70,1179
+impl<'a> Lexer<'a> {Lexer
73,1201
+    pub fn new() -> Self {new
74,1222
+impl<'a> std::iter::Iterator for Lexer<'a> {Lexer
84,1386
+    type Item = Option<char>;Item
85,1431
+    fn next(&mut self) -> Option<Self::Item> {next
87,1462
+impl<'a> From<&'a str> for Lexer<'a> {Lexer
92,1579
+    fn from(value: &'a str) -> Self {from
93,1618
+impl<'a> From<&'a std::string::String> for Lexer<'a> {Lexer
103,1800
+    fn from(value: &'a std::string::String) -> Self {from
104,1855
+impl<'a> Token<'a> {Token
114,2057
+    pub fn new(tt: TokenType, word: &'a str) -> Self {new
115,2078
+    pub fn empty() -> Self {empty
122,2171
+
+src/main.rs,102
+pub mod lex;lex
3,21
+pub mod codegen;codegen
4,34
+pub mod parse;parse
7,106
+fn main() {main
9,122
+
+src/parse/ast.rs,2125
+pub enum Expr<'a> {Expr
2,17
+    MathExpr(Math<'a>),MathExpr
3,37
+    FunCall(FunCall<'a>),FunCall
4,61
+    FunDefinition(FunDefinition<'a>),FunDefinition
5,87
+    VarDefinition(VarDefinition<'a>),VarDefinition
6,125
+    Return(Value<'a>),Return
7,163
+    If(IfStatement<'a>),If
8,186
+    BreakpointBreakpoint
9,211
+pub struct Math<'a> {Math
15,279
+    pub left: &'a Value<'a>,left
16,301
+    pub right: &'a Value<'a>,right
17,330
+    pub operator: MathOperatoroperator
18,360
+pub enum MathOperator {MathOperator
22,424
+    OP_ADD,	// AdditionOP_ADD
23,448
+    OP_SUB,	// SubtractionOP_SUB
24,472
+    OP_DIV,	// DivisionOP_DIV
25,499
+    OP_MULT,	// MultiplicationOP_MULT
26,523
+    OP_MOD,	// ModuloOP_MOD
27,554
+pub struct FunCall<'a> {FunCall
33,610
+    pub name: &'a str,name
34,635
+    pub params: Vec<Value<'a>>,params
35,658
+pub struct FunDefinition<'a> {FunDefinition
39,710
+    pub name: &'a str,name
40,741
+    pub contents: Vec<Expr<'a>>,contents
41,764
+pub struct FunParamDef<'a> {FunParamDef
45,817
+    name: &'a str,name
46,846
+    number: u64,number
47,865
+pub struct FunParamCall<'a> {FunParamCall
51,902
+    pub value: Value<'a>,value
52,932
+pub struct VarDefinition<'a> {VarDefinition
58,992
+    pub name: &'a str,name
59,1023
+    pub value: Value<'a>,value
60,1046
+pub struct VarReference<'a> {VarReference
65,1106
+    pub name: &'a str,name
66,1136
+pub struct ParamReference {ParamReference
70,1192
+    pub param_number: u64,param_number
71,1220
+pub enum Value<'a> {Value
75,1280
+    Var(VarReference<'a>),Var
76,1301
+    Param(ParamReference),Param
77,1328
+    Number(u64),Number
78,1355
+pub struct IfStatement<'a> {IfStatement
82,1392
+    pub condition: Condition<'a>,condition
83,1421
+    pub if_true: Vec<Expr<'a>>,if_true
84,1455
+pub struct Condition<'a> {Condition
88,1507
+    pub left: Value<'a>,left
89,1534
+    pub right: Value<'a>,right
90,1559
+    pub between: COND_OP,between
91,1585
+pub enum COND_OP {COND_OP
95,1631
+    EQ,EQ
96,1650
+    NE,NE
97,1658
+impl<'a> Value<'a> {Value
100,1669
+    pub fn unwrap(&self) -> String {unwrap
101,1690
+
+src/parse/mod.rs,21
+pub mod ast;ast
1,0

src/parse/parse.rs

@@ -0,0 +1,29 @@
+use super::ast::*;
+use crate::lex::tok::*;
+use logos::Lexer;
+
+fn parse_var_declaration(tokens: Lexer) -> Option<Expr<VarDefinition>> {
+    let tok = None;
+    match tokens.next() {
+	Let => {
+	    match tokens.next() {
+		Identifier => {
+		    let name = tokens.slice();
+		    println!("{:?}", name);
+		    match tokens.next() {
+			Equal => {
+			    match tokens.next() {
+				Number(n) => {
+				    let value = Value::Number(n);
+				    println!("{:?}", value);
+				    return VarDefenition {name, value};
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
+	_ => None
+    }
+}