@@ -19,6 +19,7 @@ pub use error::{ParserError, ParserErrorKind};
19
19
pub mod ast;
20
20
mod error;
21
21
22
+ // MARK: Parser Struct
22
23
pub struct Parser < ' a > {
23
24
tokens : Peekable < Iter < ' a , LexerToken > > ,
24
25
token : Option < LexerToken > ,
@@ -62,6 +63,7 @@ impl<'a> Parser<'a> {
62
63
parser
63
64
}
64
65
66
+ // MARK: Parse
65
67
pub fn parse ( & mut self ) -> ProgramTree {
66
68
let mut statements = ProgramTree :: new ( ) ;
67
69
@@ -92,6 +94,7 @@ impl<'a> Parser<'a> {
92
94
} ) ) ;
93
95
}
94
96
97
+ // MARK: Statement
95
98
fn parse_statement ( & mut self , token : & LexerToken ) -> ParserResult < Option < Statement > > {
96
99
use LexerTokenKind :: * ;
97
100
Ok ( Some ( match & token. kind {
@@ -107,6 +110,7 @@ impl<'a> Parser<'a> {
107
110
} ) )
108
111
}
109
112
113
+ // MARK: Var Stmt
110
114
fn var_decl ( & mut self ) -> ParserResult < Statement > {
111
115
self . expect_token ( & LexerTokenKind :: Var ) ?;
112
116
let value = self . parse_var ( ) ?;
@@ -115,6 +119,7 @@ impl<'a> Parser<'a> {
115
119
Ok ( Statement :: Variable ( Box :: from ( value) ) )
116
120
}
117
121
122
+ // MARK: Var Parsing
118
123
fn parse_var ( & mut self ) -> ParserResult < Variable > {
119
124
let identifier = self
120
125
. expect_token ( & LexerTokenKind :: Identifier ) ?
@@ -151,6 +156,7 @@ impl<'a> Parser<'a> {
151
156
} )
152
157
}
153
158
159
+ // MARK: Func Decl
154
160
fn func_decl ( & mut self ) -> ParserResult < Statement > {
155
161
self . expect_token ( & LexerTokenKind :: Function ) ?;
156
162
@@ -199,16 +205,7 @@ impl<'a> Parser<'a> {
199
205
Ok ( Statement :: Function ( Box :: from ( function) ) )
200
206
}
201
207
202
- fn parse_if ( & mut self ) -> ParserResult < Statement > {
203
- self . expect_token ( & LexerTokenKind :: If ) ?;
204
-
205
- if let Some ( expr) = self . if_expr ( ) ? {
206
- Ok ( Statement :: If ( Box :: from ( expr) ) )
207
- } else {
208
- Err ( ParserErrorKind :: UnexpectedEnd )
209
- }
210
- }
211
-
208
+ // MARK: Block Parsing
212
209
fn parse_inline_block ( & mut self ) -> ParserResult < WithCursor < Block > > {
213
210
let Some ( next) = self . peek ( ) . cloned ( ) else {
214
211
return Err ( ParserErrorKind :: ExpectedStatement ) ;
@@ -222,7 +219,6 @@ impl<'a> Parser<'a> {
222
219
Ok ( WithCursor :: create_with ( start, self . cursor , vec ! [ stmt] ) )
223
220
}
224
221
225
-
226
222
fn parse_block ( & mut self ) -> ParserResult < WithCursor < Block > > {
227
223
let mut block = Block :: new ( ) ;
228
224
let start = self . cursor ;
@@ -246,6 +242,7 @@ impl<'a> Parser<'a> {
246
242
self . assignment ( )
247
243
}
248
244
245
+ // MARK: Assignment
249
246
fn assignment ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
250
247
let_expr ! ( lhs = self . logic_or( ) ?) ;
251
248
@@ -280,6 +277,7 @@ impl<'a> Parser<'a> {
280
277
Ok ( Some ( lhs) )
281
278
}
282
279
280
+ // MARK: Logic OR
283
281
fn logic_or ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
284
282
let_expr ! ( mut lhs = self . logic_and( ) ?) ;
285
283
@@ -302,6 +300,7 @@ impl<'a> Parser<'a> {
302
300
Ok ( Some ( lhs) )
303
301
}
304
302
303
+ // MARK: Logic AND
305
304
fn logic_and ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
306
305
let_expr ! ( mut lhs = self . cmp_equality( ) ?) ;
307
306
@@ -324,6 +323,7 @@ impl<'a> Parser<'a> {
324
323
Ok ( Some ( lhs) )
325
324
}
326
325
326
+ // MARK: Cmp Equal
327
327
fn cmp_equality ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
328
328
let_expr ! ( mut lhs = self . cmp_lgt( ) ?) ;
329
329
@@ -348,6 +348,7 @@ impl<'a> Parser<'a> {
348
348
Ok ( Some ( lhs) )
349
349
}
350
350
351
+ // MARK: Cmp LGT
351
352
fn cmp_lgt ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
352
353
let_expr ! ( mut lhs = self . arith_add_sub( ) ?) ;
353
354
@@ -375,6 +376,7 @@ impl<'a> Parser<'a> {
375
376
Ok ( Some ( lhs) )
376
377
}
377
378
379
+ // MARK: Arith Add Sub
378
380
fn arith_add_sub ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
379
381
let_expr ! ( mut lhs = self . arith_mul_div( ) ?) ;
380
382
@@ -399,6 +401,7 @@ impl<'a> Parser<'a> {
399
401
Ok ( Some ( lhs) )
400
402
}
401
403
404
+ // MARK: Arith Mul Div
402
405
fn arith_mul_div ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
403
406
let_expr ! ( mut lhs = self . unary( ) ?) ;
404
407
@@ -423,6 +426,8 @@ impl<'a> Parser<'a> {
423
426
Ok ( Some ( lhs) )
424
427
}
425
428
429
+
430
+ // MARK: Unary
426
431
fn unary ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
427
432
let_expr ! ( mut lhs = self . func_invoke( ) ?) ;
428
433
@@ -444,6 +449,7 @@ impl<'a> Parser<'a> {
444
449
Ok ( Some ( lhs) )
445
450
}
446
451
452
+ // MARK: Func Invoke
447
453
fn func_invoke ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
448
454
let_expr ! ( mut expr = self . literals( ) ?) ;
449
455
@@ -483,6 +489,7 @@ impl<'a> Parser<'a> {
483
489
Ok ( Some ( expr) )
484
490
}
485
491
492
+ // MARK: Literals
486
493
fn literals ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
487
494
let_expr ! ( token = self . peek( ) ) ;
488
495
@@ -532,6 +539,7 @@ impl<'a> Parser<'a> {
532
539
Ok ( Some ( WithCursor :: create_with ( token. start , token. end , expr) ) )
533
540
}
534
541
542
+ // MARK: Grouping
535
543
fn group ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
536
544
let_expr ! ( mut expr = self . expression( ) ?) ;
537
545
@@ -542,6 +550,7 @@ impl<'a> Parser<'a> {
542
550
Ok ( Some ( expr) )
543
551
}
544
552
553
+ // MARK: If Expr
545
554
fn if_expr ( & mut self ) -> ParserResult < Option < WithCursor < Expression > > > {
546
555
let_expr ! ( condition = self . expression( ) ?) ;
547
556
@@ -584,6 +593,16 @@ impl<'a> Parser<'a> {
584
593
Ok ( Some ( WithCursor :: create_with ( start, self . cursor , if_expr) ) )
585
594
}
586
595
596
+ fn parse_if ( & mut self ) -> ParserResult < Statement > {
597
+ self . expect_token ( & LexerTokenKind :: If ) ?;
598
+
599
+ if let Some ( expr) = self . if_expr ( ) ? {
600
+ Ok ( Statement :: If ( Box :: from ( expr) ) )
601
+ } else {
602
+ Err ( ParserErrorKind :: UnexpectedEnd )
603
+ }
604
+ }
605
+
587
606
fn expect_token ( & mut self , expected : & ' a LexerTokenKind ) -> ParserResult < & LexerToken > {
588
607
self . expect ( & expected) . map_err ( |found| {
589
608
ParserErrorKind :: ExpectedToken ( vec ! [ expected. clone( ) ] , found. map ( |t| t. kind . clone ( ) ) )
@@ -602,6 +621,7 @@ impl<'a> Parser<'a> {
602
621
}
603
622
}
604
623
624
+ // MARK: Comp Error
605
625
impl ComponentErrors for Parser < ' _ > {
606
626
fn fetch_errors ( & self ) -> & ErrorList {
607
627
& self . errors
@@ -613,6 +633,7 @@ impl ComponentErrors for Parser<'_> {
613
633
}
614
634
}
615
635
636
+ // MARK: Comp Iter
616
637
impl < ' a > ComponentIter < ' a , & ' a LexerTokenKind , & ' a LexerToken , Iter < ' a , LexerToken > >
617
638
for Parser < ' a >
618
639
{
0 commit comments