ezjs/
ast.rs

1use crate::token::*;
2
3/* ast stuff */
4#[allow(non_camel_case_types)]
5#[derive(Clone, Copy, Debug, PartialEq)]
6pub enum AstType {
7	AST_NULL = -1,
8
9    AST_LIST = 0,
10	AST_FUNDEC,
11	AST_IDENTIFIER,
12
13	EXP_IDENTIFIER,
14	EXP_NUMBER,
15	EXP_STRING,
16
17	/* literals */
18	EXP_UNDEF, /* for array elisions */
19	EXP_NULL,
20	EXP_TRUE,
21	EXP_FALSE,
22	EXP_THIS,
23
24	EXP_ARRAY,
25	EXP_OBJECT,
26	EXP_PROP_VAL,
27	EXP_PROP_GET,
28	EXP_PROP_SET,
29
30	EXP_FUN,
31
32	/* expressions */
33	EXP_INDEX,
34	EXP_MEMBER,
35	EXP_CALL,
36	EXP_NEW,
37
38	EXP_POSTINC,
39	EXP_POSTDEC,
40
41	EXP_DELETE,
42	EXP_VOID,
43	EXP_TYPEOF,
44	EXP_PREINC,
45	EXP_PREDEC,
46	EXP_POS,
47	EXP_NEG,
48	EXP_BITNOT,
49	EXP_LOGNOT,
50
51	EXP_MOD,
52	EXP_DIV,
53	EXP_MUL,
54	EXP_SUB,
55	EXP_ADD,
56	EXP_USHR,
57	EXP_SHR,
58	EXP_SHL,
59	EXP_IN,
60	EXP_INSTANCEOF,
61	EXP_GE,
62	EXP_LE,
63	EXP_GT,
64	EXP_LT,
65	EXP_STRICTNE,
66	EXP_STRICTEQ,
67	EXP_NE,
68	EXP_EQ,
69	EXP_BITAND,
70	EXP_BITXOR,
71	EXP_BITOR,
72	EXP_LOGAND,
73	EXP_LOGOR,
74
75	EXP_COND,
76
77	EXP_ASS,
78	EXP_ASS_MUL,
79	EXP_ASS_DIV,
80	EXP_ASS_MOD,
81	EXP_ASS_ADD,
82	EXP_ASS_SUB,
83	EXP_ASS_SHL,
84	EXP_ASS_SHR,
85	EXP_ASS_USHR,
86	EXP_ASS_BITAND,
87	EXP_ASS_BITXOR,
88	EXP_ASS_BITOR,
89
90	EXP_COMMA,
91
92	EXP_VAR, /* var initializer */
93
94	/* statements */
95	STM_BLOCK,
96	STM_EMPTY,
97	STM_VAR,
98	STM_IF,
99	STM_DO,
100	STM_WHILE,
101	STM_FOR,
102	STM_FOR_VAR,
103	STM_FOR_IN,
104	STM_FOR_IN_VAR,
105	STM_CONTINUE,
106	STM_BREAK,
107	STM_RETURN,
108	STM_SWITCH,
109	STM_THROW,
110	STM_TRY,
111
112	STM_LABEL,
113	STM_CASE,
114	STM_DEFAULT,
115
116	STM_DEBUG,
117}
118
119#[derive(Debug, Clone)]
120pub struct AstNode {
121    pub ast_type:   AstType,
122    pub src_line:   u32,
123    pub num_value:  Option<f64>,
124	pub str_value:  Option<String>,
125
126    pub a:      Option<Box<AstNode>>,
127    pub b:      Option<Box<AstNode>>,
128    pub c:      Option<Box<AstNode>>,
129    pub d:      Option<Box<AstNode>>,
130}
131
132/* Local help function */
133impl AstNode {
134    pub fn null() -> Self {
135        AstNode {
136            ast_type:  AstType::AST_NULL,
137            src_line:  0,
138            num_value: None,
139            str_value: None,
140            a: None,
141            b: None,
142            c: None,
143            d: None
144        }
145    }
146
147    fn new(ntype: AstType, line: u32) -> Self {
148        AstNode {
149            ast_type:  ntype,
150            src_line:  line,
151            num_value: None,
152            str_value: None,
153            a: None,
154            b: None,
155            c: None,
156            d: None
157        }
158    }
159
160    fn new_number(ntype: AstType, line: u32, num: f64) -> Self {
161        AstNode {
162            ast_type: ntype,
163            src_line: line,
164            num_value: Some(num),
165            str_value: None,
166            a: None,
167            b: None,
168            c: None,
169            d: None
170        }
171    }
172
173    fn new_string(ntype: AstType, line: u32, string: &str) -> Self {
174        AstNode {
175            ast_type: ntype,
176            src_line: line,
177            num_value: None,
178            str_value: Some(String::from(string)),
179            a: None,
180            b: None,
181            c: None,
182            d: None
183        }
184    }
185
186    fn new_a(ntype: AstType, line: u32, a: Self) -> Self {
187        AstNode {
188            ast_type: ntype,
189            src_line: line,
190            num_value: None,
191            str_value: None,
192            a: Some(Box::new(a)),
193            b: None,
194            c: None,
195            d: None
196        }
197    }
198
199    fn new_a_b(ntype: AstType, line: u32, a: Self, b: Self) -> Self {
200        AstNode {
201            ast_type: ntype,
202            src_line: line,
203            num_value: None,
204            str_value: None,
205            a: Some(Box::new(a)),
206            b: Some(Box::new(b)),
207            c: None,
208            d: None
209        }
210    }
211
212    fn new_a_b_c(ntype: AstType, line: u32, a: Self, b: Self, c: Self) -> Self {
213        AstNode {
214            ast_type: ntype,
215            src_line: line,
216            num_value: None,
217            str_value: None,
218            a: Some(Box::new(a)),
219            b: Some(Box::new(b)),
220            c: Some(Box::new(c)),
221            d: None
222        }
223    }
224
225    fn new_a_b_c_d(ntype: AstType, line: u32, a: Self, b: Self, c: Self, d: Self) -> Self {
226        AstNode {
227            ast_type: ntype,
228            src_line: line,
229            num_value: None,
230            str_value: None,
231            a: Some(Box::new(a)),
232            b: Some(Box::new(b)),
233            c: Some(Box::new(c)),
234            d: Some(Box::new(d)),
235        }
236    }
237
238    // linked list
239    fn new_list(anode: AstNode) -> Self {
240        let mut new_list_item = AstNode::new(AstType::AST_LIST, anode.src_line);
241        new_list_item.a = Some(Box::new(anode));
242        return new_list_item;
243    }
244    fn list_tail_push(&mut self, anode: AstNode) {
245        assert!(self.ast_type == AstType::AST_LIST);
246        assert!(self.b.is_none());
247        let mut new_list_item = AstNode::new(AstType::AST_LIST, anode.src_line);
248        new_list_item.a = Some(Box::new(anode));
249        self.b = Some(Box::new( new_list_item ));
250    }
251}
252
253fn tk_accept(tkr: &mut Tokenlizer, tkt: TokenType) -> Result<bool, String> {
254    let ntk = tkr.forward()?;
255    if ntk.tk_type != tkt {
256        return Ok(false);
257    }
258    tkr.next()?;
259    return Ok(true);
260}
261
262fn tk_expect(tkr: &mut Tokenlizer, tkt: TokenType) -> Result<Token, String> {
263    let ntk = tkr.next()?;
264    if ntk.tk_type != tkt {
265        return Err(format!("AST error: except {:?} but got {:?} @ {}", tkt, ntk.tk_type, tkr.line()));
266    }
267    return Ok(ntk);
268}
269
270fn tk_lookahead(tkr: &mut Tokenlizer, tkt: TokenType) -> Result<bool, String> {
271    let fwd = tkr.forward()?;
272    if fwd.tk_type == tkt {
273        return Ok(true);
274    }
275    return Ok(false);
276}
277
278fn ast_identifier(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
279    let id = tk_expect(tkr, TokenType::TK_IDENTIFIER)?;
280    let node = AstNode::new_string(AstType::AST_IDENTIFIER, tkr.line(), &id.tk_value.unwrap());
281    return Ok(node);
282}
283
284fn ast_identifier_opt(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
285    let ntk = tkr.forward()?;
286    if ntk.tk_type == TokenType::TK_IDENTIFIER {
287        tkr.next()?;
288        let node = AstNode::new_string(AstType::AST_IDENTIFIER, tkr.line(), &ntk.tk_value.unwrap());
289        return Ok(node);
290    } else {
291        return Ok( AstNode::new(AstType::AST_NULL, tkr.line()));
292    }
293}
294
295
296fn ast_propname(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
297    let lookahead = tkr.forward()?;
298    if tk_accept(tkr, TokenType::TK_NUMBER)? {
299        let value = lookahead.to_number();
300        let a = AstNode::new_number(AstType::EXP_NUMBER, tkr.line(), value);
301        return Ok(a);
302    }
303    if tk_accept(tkr, TokenType::TK_STRING)? {
304        let a = AstNode::new_string(AstType::EXP_STRING, tkr.line(), &lookahead.tk_value.unwrap());
305        return Ok(a);
306    }
307    return ast_identifier(tkr);
308}
309
310fn ast_propassign(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
311    let name = ast_propname(tkr)?;
312    let lookahead = tkr.forward()?;
313
314    if lookahead.tk_type != TokenType::TK_COLON && name.ast_type == AstType::AST_IDENTIFIER {
315        if name.str_value.as_ref().unwrap() == "get" {
316            let null = AstNode::new(AstType::AST_NULL, tkr.line());
317            let name = ast_propname(tkr)?;
318            tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
319            tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
320            let body = ast_funbody(tkr)?;
321            let exp = AstNode::new_a_b_c(AstType::EXP_PROP_GET, tkr.line(), name, null, body);
322            return Ok(exp);
323        }
324        if name.str_value.as_ref().unwrap() == "set" {
325            let name = ast_propname(tkr)?;
326            tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
327            let arg = ast_identifier(tkr)?;
328            tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
329            let body = ast_funbody(tkr)?;
330            let exp = AstNode::new_a_b_c(AstType::EXP_PROP_SET, tkr.line(), name, arg, body);
331            return Ok(exp);
332        }
333    }
334    tk_expect(tkr, TokenType::TK_COLON)?;
335    let value = ast_assignment(tkr)?;
336    let exp = AstNode::new_a_b(AstType::EXP_PROP_VAL, tkr.line(), name, value);
337    return Ok(exp);
338}
339
340fn ast_objectliteral(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
341    if tkr.forward()?.tk_type == TokenType::TK_BRACE_RIGHT {
342        let null = AstNode::new(AstType::AST_NULL, tkr.line());
343        return Ok(null);
344    }
345
346    let node = ast_propassign(tkr)?;
347    let mut head = AstNode::new_list( node );
348    let mut tail: &mut AstNode = &mut head;
349
350    while tk_accept(tkr, TokenType::TK_COMMA)? {
351        if tkr.forward()?.tk_type == TokenType::TK_BRACE_RIGHT {
352            break;
353        }
354        AstNode::list_tail_push(tail, ast_propassign(tkr)?);
355        tail = tail.b.as_mut().unwrap();
356    }
357    return Ok(head);
358}
359
360fn ast_arrayelement(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
361    if tkr.forward()?.tk_type == TokenType::TK_COMMA {
362        return Ok(AstNode::new(AstType::EXP_UNDEF, tkr.line()));
363    }
364    return ast_assignment(tkr);
365}
366
367fn ast_arrayliteral(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
368    let node = ast_arrayelement(tkr)?;
369    let mut head = AstNode::new_list( node );
370    let mut tail: &mut AstNode = &mut head;
371
372    while tk_accept(tkr, TokenType::TK_COMMA)? {
373        AstNode::list_tail_push(tail, ast_arrayelement(tkr)?);
374        tail = tail.b.as_mut().unwrap();
375    }
376
377    return Ok(head);
378}
379
380fn ast_primary(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
381    let lookahead = tkr.forward()?;
382    if tk_accept(tkr, TokenType::TK_IDENTIFIER)? {
383        let a = AstNode::new_string(AstType::EXP_IDENTIFIER, tkr.line(), &lookahead.tk_value.unwrap());
384        return Ok(a);
385    }
386    if tk_accept(tkr, TokenType::TK_STRING)? {
387        let a = AstNode::new_string(AstType::EXP_STRING, tkr.line(), &lookahead.tk_value.unwrap());
388        return Ok(a);
389    }
390    if tk_accept(tkr, TokenType::TK_NUMBER)? {
391        let value = lookahead.to_number();
392        let a = AstNode::new_number(AstType::EXP_NUMBER, tkr.line(), value);
393        return Ok(a);
394    }
395    if tk_accept(tkr, TokenType::TK_THIS)? {
396        let a = AstNode::new(AstType::EXP_THIS, tkr.line());
397        return Ok(a);
398    }
399    if tk_accept(tkr, TokenType::TK_NULL)? {
400        let a = AstNode::new(AstType::EXP_NULL, tkr.line());
401        return Ok(a);
402    }
403    if tk_accept(tkr, TokenType::TK_UNDEF)? {
404        let a = AstNode::new(AstType::EXP_UNDEF, tkr.line());
405        return Ok(a);
406    }
407    if tk_accept(tkr, TokenType::TK_TRUE)? {
408        let a = AstNode::new(AstType::EXP_TRUE, tkr.line());
409        return Ok(a);
410    }
411    if tk_accept(tkr, TokenType::TK_FALSE)? {
412        let a = AstNode::new(AstType::EXP_FALSE, tkr.line());
413        return Ok(a);
414    }
415    if tk_accept(tkr, TokenType::TK_BRACE_LEFT)? {
416        let a = ast_objectliteral(tkr)?;
417        tk_expect(tkr, TokenType::TK_BRACE_RIGHT)?;
418        let obj = AstNode::new_a(AstType::EXP_OBJECT, tkr.line(), a);
419        return Ok(obj);
420    }
421    if tk_accept(tkr, TokenType::TK_BRACKET_LEFT)? {
422        let a = if tkr.forward()?.tk_type == TokenType::TK_BRACKET_RIGHT {
423            AstNode::new(AstType::AST_NULL, tkr.line())
424        } else {
425            ast_arrayliteral(tkr)?
426        };
427
428        tk_expect(tkr, TokenType::TK_BRACKET_RIGHT)?;
429        let array = AstNode::new_a(AstType::EXP_ARRAY, tkr.line(), a);
430        return Ok(array);
431    }
432    if tk_accept(tkr, TokenType::TK_PAREN_LEFT)? {
433        let a = ast_expression(tkr)?;
434        tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
435        return Ok(a);
436    }
437
438    panic!(format!("unexpected token in expression: {:?} @ {}", lookahead, tkr.line()));
439}
440
441fn ast_arguments(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
442    if tkr.forward()?.tk_type == TokenType::TK_PAREN_RIGHT {
443        return Ok(AstNode::new(AstType::AST_NULL, tkr.line()));
444    }
445    let node = ast_assignment(tkr)?;
446    let mut head = AstNode::new_list( node );
447    let mut tail: &mut AstNode = &mut head;
448
449    while tk_accept(tkr, TokenType::TK_COMMA)? {
450        AstNode::list_tail_push(tail, ast_assignment(tkr)?);
451        tail = tail.b.as_mut().unwrap();
452    }
453
454    return Ok(head);
455}
456
457fn ast_formula_funexp(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
458    let a = ast_identifier_opt(tkr)?;
459    tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
460    let b = ast_parameters(tkr)?;
461    tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
462    let c = ast_funbody(tkr)?;
463    let node = AstNode::new_a_b_c(AstType::EXP_FUN, tkr.line(), a, b, c);
464    return Ok(node);
465}
466
467fn ast_formula_memberexp(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
468    let mut a = ast_formula_newexp(tkr)?;
469
470    loop {
471        if tk_accept(tkr, TokenType::TK_POINT)? {
472            let b = ast_identifier(tkr)?;
473            a = AstNode::new_a_b(AstType::EXP_MEMBER, tkr.line(), a, b);
474            continue;
475        }
476        if tk_accept(tkr, TokenType::TK_BRACKET_LEFT)? {
477            let b = ast_expression(tkr)?;
478            tk_expect(tkr, TokenType::TK_BRACKET_RIGHT)?;
479            a = AstNode::new_a_b(AstType::EXP_INDEX, tkr.line(), a, b);
480            continue;
481        }
482        break;
483    }
484    return Ok(a);
485}
486
487fn ast_formula_newexp(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
488    if tk_accept(tkr, TokenType::TK_NEW)? {
489        let a = ast_formula_memberexp(tkr)?;
490        if tk_accept(tkr, TokenType::TK_PAREN_LEFT)? {
491            let b = ast_arguments(tkr)?;
492            tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
493            return Ok(AstNode::new_a_b(AstType::EXP_NEW, tkr.line(), a, b));
494        }
495        return Ok(AstNode::new_a(AstType::EXP_NEW, tkr.line(), a));
496    }
497
498    if tk_accept(tkr, TokenType::TK_FUNCTION)? {
499        return ast_formula_funexp(tkr);
500    }
501    return ast_primary(tkr);
502}
503
504fn ast_formula_callexp(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
505    let mut a = ast_formula_newexp(tkr)?;
506    loop {
507        if tk_accept(tkr, TokenType::TK_POINT)? {
508            let b = ast_identifier(tkr)?;
509            a = AstNode::new_a_b(AstType::EXP_MEMBER, tkr.line(), a, b);
510            continue;
511        }
512        if tk_accept(tkr, TokenType::TK_BRACKET_LEFT)? {
513            let b = ast_expression(tkr)?;
514            tk_expect(tkr, TokenType::TK_BRACKET_RIGHT)?;
515            a = AstNode::new_a_b(AstType::EXP_INDEX, tkr.line(), a, b);
516            continue;
517        }
518        if tk_accept(tkr, TokenType::TK_PAREN_LEFT)? {
519            let b = ast_arguments(tkr)?;
520            tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
521            a = AstNode::new_a_b(AstType::EXP_CALL, tkr.line(), a, b);
522            continue;
523        }
524        break;
525    }
526    return Ok(a);
527}
528
529fn ast_formula_postfix(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
530    let a = ast_formula_callexp(tkr)?;
531    if tkr.new_line()? == false {
532        if tk_accept(tkr, TokenType::TK_INC)? {
533            let node = AstNode::new_a(AstType::EXP_POSTINC, tkr.line(), a);
534            return Ok(node);
535        }
536        if tk_accept(tkr, TokenType::TK_DEC)? {
537            let node = AstNode::new_a(AstType::EXP_POSTDEC, tkr.line(), a);
538            return Ok(node);
539        }
540    }
541    return Ok(a);
542}
543
544fn ast_formula_unary(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
545    if tk_accept(tkr, TokenType::TK_DELETE)? {
546        let a = ast_formula_unary(tkr)?;
547        let stm = AstNode::new_a(AstType::EXP_DELETE, tkr.line(), a);
548        return Ok(stm);
549    }
550    if tk_accept(tkr, TokenType::TK_VOID)? {
551        let a = ast_formula_unary(tkr)?;
552        let stm = AstNode::new_a(AstType::EXP_VOID, tkr.line(), a);
553        return Ok(stm);
554    }
555    if tk_accept(tkr, TokenType::TK_TYPEOF)? {
556        let a = ast_formula_unary(tkr)?;
557        let stm = AstNode::new_a(AstType::EXP_TYPEOF, tkr.line(), a);
558        return Ok(stm);
559    }
560    if tk_accept(tkr, TokenType::TK_INC)? {
561        let a = ast_formula_unary(tkr)?;
562        let stm = AstNode::new_a(AstType::EXP_PREINC, tkr.line(), a);
563        return Ok(stm);
564    }
565    if tk_accept(tkr, TokenType::TK_DEC)? {
566        let a = ast_formula_unary(tkr)?;
567        let stm = AstNode::new_a(AstType::EXP_PREDEC, tkr.line(), a);
568        return Ok(stm);
569    }
570    if tk_accept(tkr, TokenType::TK_BITNOT)? {
571        let a = ast_formula_unary(tkr)?;
572        let stm = AstNode::new_a(AstType::EXP_BITNOT, tkr.line(), a);
573        return Ok(stm);
574    }
575    if tk_accept(tkr, TokenType::TK_NOT)? {
576        let a = ast_formula_unary(tkr)?;
577        let stm = AstNode::new_a(AstType::EXP_LOGNOT, tkr.line(), a);
578        return Ok(stm);
579    }
580    if tk_accept(tkr, TokenType::TK_SUB)? {
581        let a = ast_formula_unary(tkr)?;
582        let stm = AstNode::new_a(AstType::EXP_NEG, tkr.line(), a);
583        return Ok(stm);
584    }
585    if tk_accept(tkr, TokenType::TK_ADD)? {
586        let a = ast_formula_unary(tkr)?;
587        let stm = AstNode::new_a(AstType::EXP_POS, tkr.line(), a);
588        return Ok(stm);
589    }
590    return ast_formula_postfix(tkr);
591}
592
593fn ast_formula_multiplicative(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
594    let mut a = ast_formula_unary(tkr)?;
595
596    loop {
597        if tk_accept(tkr, TokenType::TK_MUL)? {
598            let b = ast_formula_unary(tkr)?;
599            a = AstNode::new_a_b(AstType::EXP_MUL, tkr.line(), a, b);
600            continue;
601        }
602        if tk_accept(tkr, TokenType::TK_DIV)? {
603            let b = ast_formula_unary(tkr)?;
604            a = AstNode::new_a_b(AstType::EXP_DIV, tkr.line(), a, b);
605            continue;
606        }
607        if tk_accept(tkr, TokenType::TK_MOD)? {
608            let b = ast_formula_unary(tkr)?;
609            a = AstNode::new_a_b(AstType::EXP_MOD, tkr.line(), a, b);
610            continue;
611        }
612        break;
613    }
614    return Ok(a);
615}
616
617fn ast_formula_additive(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
618    let mut a = ast_formula_multiplicative(tkr)?;
619
620    loop {
621        if tk_accept(tkr, TokenType::TK_ADD)? {
622            let b = ast_formula_multiplicative(tkr)?;
623            a = AstNode::new_a_b(AstType::EXP_ADD, tkr.line(), a, b);
624            continue;
625        }
626        if tk_accept(tkr, TokenType::TK_SUB)? {
627            let b = ast_formula_multiplicative(tkr)?;
628            a = AstNode::new_a_b(AstType::EXP_SUB, tkr.line(), a, b);
629            continue;
630        }
631        break;
632    }
633    return Ok(a);
634}
635
636fn ast_formula_shift(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
637    let mut a = ast_formula_additive(tkr)?;
638
639    loop {
640        if tk_accept(tkr, TokenType::TK_SHL)? {
641            let b = ast_formula_additive(tkr)?;
642            a = AstNode::new_a_b(AstType::EXP_SHL, tkr.line(), a, b);
643            continue;
644        }
645        if tk_accept(tkr, TokenType::TK_SHR)? {
646            let b = ast_formula_additive(tkr)?;
647            a = AstNode::new_a_b(AstType::EXP_SHR, tkr.line(), a, b);
648            continue;
649        }
650        if tk_accept(tkr, TokenType::TK_USHR)? {
651            let b = ast_formula_additive(tkr)?;
652            a = AstNode::new_a_b(AstType::EXP_USHR, tkr.line(), a, b);
653            continue;
654        }
655        break;
656    }
657    return Ok(a);
658}
659
660fn ast_formula_relational(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
661    let mut a = ast_formula_shift(tkr)?;
662
663    loop {
664        if tk_accept(tkr, TokenType::TK_LT)? {
665            let b = ast_formula_shift(tkr)?;
666            a = AstNode::new_a_b(AstType::EXP_LT, tkr.line(), a, b);
667            continue;
668        }
669        if tk_accept(tkr, TokenType::TK_GT)? {
670            let b = ast_formula_shift(tkr)?;
671            a = AstNode::new_a_b(AstType::EXP_GT, tkr.line(), a, b);
672            continue;
673        }
674        if tk_accept(tkr, TokenType::TK_LE)? {
675            let b = ast_formula_shift(tkr)?;
676            a = AstNode::new_a_b(AstType::EXP_LE, tkr.line(), a, b);
677            continue;
678        }
679        if tk_accept(tkr, TokenType::TK_GE)? {
680            let b = ast_formula_shift(tkr)?;
681            a = AstNode::new_a_b(AstType::EXP_GE, tkr.line(), a, b);
682            continue;
683        }
684        if tk_accept(tkr, TokenType::TK_INSTANCEOF)? {
685            let b = ast_formula_shift(tkr)?;
686            a = AstNode::new_a_b(AstType::EXP_INSTANCEOF, tkr.line(), a, b);
687            continue;
688        }
689        if !tkr.notin {
690            if tk_accept(tkr, TokenType::TK_IN)? {
691                let b = ast_formula_shift(tkr)?;
692                a = AstNode::new_a_b(AstType::EXP_IN, tkr.line(), a, b);
693                continue;
694            }
695        } 
696        break;
697    }
698    return Ok(a);
699}
700
701fn ast_formula_eq(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
702    let mut a = ast_formula_relational(tkr)?;
703
704    loop {
705        if tk_accept(tkr, TokenType::TK_EQ)? {
706            let b = ast_formula_relational(tkr)?;
707            a = AstNode::new_a_b(AstType::EXP_EQ, tkr.line(), a, b);
708            continue;
709        }
710        if tk_accept(tkr, TokenType::TK_NE)? {
711            let b = ast_formula_relational(tkr)?;
712            a = AstNode::new_a_b(AstType::EXP_NE, tkr.line(), a, b);
713            continue;
714        }
715        if tk_accept(tkr, TokenType::TK_STRICTEQ)? {
716            let b = ast_formula_relational(tkr)?;
717            a = AstNode::new_a_b(AstType::EXP_STRICTEQ, tkr.line(), a, b);
718            continue;
719        }
720        if tk_accept(tkr, TokenType::TK_STRICTNE)? {
721            let b = ast_formula_relational(tkr)?;
722            a = AstNode::new_a_b(AstType::EXP_STRICTNE, tkr.line(), a, b);
723            continue;
724        }
725        break;
726    }
727    return Ok(a);
728}
729
730fn ast_formula_bitand(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
731    let mut a = ast_formula_eq(tkr)?;
732    while tk_accept(tkr, TokenType::TK_AND)? {
733        let b = ast_formula_eq(tkr)?;
734        a = AstNode::new_a_b(AstType::EXP_BITAND, tkr.line(), a, b);
735    }
736    return Ok(a);
737}
738
739fn ast_formula_bitxor(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
740    let mut a = ast_formula_bitand(tkr)?;
741    while tk_accept(tkr, TokenType::TK_XOR)? {
742        let b = ast_formula_bitand(tkr)?;
743        a = AstNode::new_a_b(AstType::EXP_BITXOR, tkr.line(), a, b);
744    }
745    return Ok(a);
746}
747
748fn ast_formula_bitor(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
749    let mut a = ast_formula_bitxor(tkr)?;
750    while tk_accept(tkr, TokenType::TK_OR)? {
751        let b = ast_formula_bitxor(tkr)?;
752        a = AstNode::new_a_b(AstType::EXP_BITOR, tkr.line(), a, b);
753    }
754    return Ok(a);
755}
756
757fn ast_formula_and(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
758    let mut a = ast_formula_bitor(tkr)?;
759    while tk_accept(tkr, TokenType::TK_AND_AND)? {
760        let b = ast_formula_bitor(tkr)?;
761        a = AstNode::new_a_b(AstType::EXP_LOGAND, tkr.line(), a, b);
762    }
763    return Ok(a);
764}
765
766fn ast_formula_or(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
767    let mut a = ast_formula_and(tkr)?;
768    while tk_accept(tkr, TokenType::TK_OR_OR)? {
769        let b = ast_formula_and(tkr)?;
770        a = AstNode::new_a_b(AstType::EXP_LOGOR, tkr.line(), a, b);
771    }
772    return Ok(a);
773}
774
775fn ast_formula(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
776    let mut a = ast_formula_or(tkr)?;
777    if tk_accept(tkr, TokenType::TK_QUEST)? {
778        let b = ast_assignment(tkr)?;
779        tk_expect(tkr, TokenType::TK_COLON)?;
780        let c = ast_assignment(tkr)?;
781        a = AstNode::new_a_b_c(AstType::EXP_COND, tkr.line(), a, b, c);
782    }
783    return Ok(a);
784}
785
786fn ast_assignment(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
787    let a = ast_formula(tkr)?;
788
789    if tk_accept(tkr, TokenType::TK_ASS)? {
790        let b = ast_assignment(tkr)?;
791        let node = AstNode::new_a_b(AstType::EXP_ASS, tkr.line(), a, b);
792        return Ok(node);
793    } else if tk_accept(tkr, TokenType::TK_MUL_ASS)? {
794        let b = ast_assignment(tkr)?;
795        let node = AstNode::new_a_b(AstType::EXP_ASS_MUL, tkr.line(), a, b);
796        return Ok(node);
797    }  else if tk_accept(tkr, TokenType::TK_DIV_ASS)? {
798        let b = ast_assignment(tkr)?;
799        let node = AstNode::new_a_b(AstType::EXP_ASS_DIV, tkr.line(), a, b);
800        return Ok(node);
801    } else if tk_accept(tkr, TokenType::TK_MOD_ASS)? {
802        let b = ast_assignment(tkr)?;
803        let node = AstNode::new_a_b(AstType::EXP_ASS_MOD, tkr.line(), a, b);
804        return Ok(node);
805    } else if tk_accept(tkr, TokenType::TK_ADD_ASS)? {
806        let b = ast_assignment(tkr)?;
807        let node = AstNode::new_a_b(AstType::EXP_ASS_ADD, tkr.line(), a, b);
808        return Ok(node);
809    } else if tk_accept(tkr, TokenType::TK_SUB_ASS)? {
810        let b = ast_assignment(tkr)?;
811        let node = AstNode::new_a_b(AstType::EXP_ASS_SUB, tkr.line(), a, b);
812        return Ok(node);
813    } else if tk_accept(tkr, TokenType::TK_SHL_ASS)? {
814        let b = ast_assignment(tkr)?;
815        let node = AstNode::new_a_b(AstType::EXP_ASS_SHL, tkr.line(), a, b);
816        return Ok(node);
817    } else if tk_accept(tkr, TokenType::TK_SHR_ASS)? {
818        let b = ast_assignment(tkr)?;
819        let node = AstNode::new_a_b(AstType::EXP_ASS_SHR, tkr.line(), a, b);
820        return Ok(node);
821    } else if tk_accept(tkr, TokenType::TK_USHR_ASS)? {
822        let b = ast_assignment(tkr)?;
823        let node = AstNode::new_a_b(AstType::EXP_ASS_USHR, tkr.line(), a, b);
824        return Ok(node);
825    } else if tk_accept(tkr, TokenType::TK_AND_ASS)? {
826        let b = ast_assignment(tkr)?;
827        let node = AstNode::new_a_b(AstType::EXP_ASS_BITAND, tkr.line(), a, b);
828        return Ok(node);
829    } else if tk_accept(tkr, TokenType::TK_XOR_ASS)? {
830        let b = ast_assignment(tkr)?;
831        let node = AstNode::new_a_b(AstType::EXP_ASS_BITXOR, tkr.line(), a, b);
832        return Ok(node);
833    } else if tk_accept(tkr, TokenType::TK_OR_ASS)? {
834        let b = ast_assignment(tkr)?;
835        let node = AstNode::new_a_b(AstType::EXP_ASS_BITOR, tkr.line(), a, b);
836        return Ok(node);
837    }
838    return Ok(a);
839}
840
841fn ast_expression(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
842    let mut a = ast_assignment(tkr)?;
843    while tk_accept(tkr, TokenType::TK_COMMA)? {
844        let b = ast_assignment(tkr)?;
845        a = AstNode::new_a_b(AstType::EXP_COMMA, tkr.line(), a, b);
846    }
847    return Ok(a);
848}
849
850fn ast_vardec(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
851    let a = ast_identifier(tkr)?;
852    if tk_accept(tkr, TokenType::TK_ASS)? {
853        let b = ast_assignment(tkr)?;
854        let exp = AstNode::new_a_b(AstType::EXP_VAR, tkr.line(), a, b);
855        return Ok(exp);
856    }
857    let exp = AstNode::new_a(AstType::EXP_VAR, tkr.line(), a);
858    return Ok(exp);
859}
860
861fn ast_vardeclist(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
862    let node = ast_vardec(tkr)?;
863    let mut head = AstNode::new_list( node );
864    let mut tail: &mut AstNode = &mut head;
865    while tk_accept(tkr, TokenType::TK_COMMA)? {
866        AstNode::list_tail_push(tail, ast_vardec(tkr)?);
867        tail = tail.b.as_mut().unwrap();
868    }
869    return Ok(head);
870}
871
872fn ast_parameters(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
873    let n = tkr.forward()?;
874    if n.tk_type == TokenType::TK_PAREN_RIGHT {
875        return Ok(AstNode::new(AstType::AST_NULL, tkr.line()));
876    }
877
878    let node = ast_identifier(tkr)?;
879
880    let mut head = AstNode::new_list( node );
881    let mut tail: &mut AstNode = &mut head;
882    while tk_accept(tkr, TokenType::TK_COMMA)?  {
883        AstNode::list_tail_push(tail, ast_identifier(tkr)?);
884        tail = tail.b.as_mut().unwrap();
885    }
886
887    return Ok(head);
888}
889
890fn ast_caseclause(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
891    if tk_accept(tkr, TokenType::TK_CASE)? {
892        let a = ast_expression(tkr)?;
893        tk_expect(tkr, TokenType::TK_COLON)?;
894        let b = ast_statement_list(tkr)?;
895        let stm = AstNode::new_a_b(AstType::STM_CASE, tkr.line(), a, b);
896        return Ok(stm);
897    }
898    if tk_accept(tkr, TokenType::TK_DEFAULT)? {
899        tk_expect(tkr, TokenType::TK_COLON)?;
900        let a = ast_statement_list(tkr)?;
901        let stm = AstNode::new_a(AstType::STM_DEFAULT, tkr.line(), a);
902        return Ok(stm);
903    }
904
905    return Err(format!("AST error: unexpected token in switch: {:?} @ {}  (expected 'case' or 'default')", tkr.forward(), tkr.line()));
906}
907
908fn ast_semicolon(tkr: &mut Tokenlizer) -> Result<(), String> {
909    if tkr.new_line()? {
910        return Ok(());
911    }
912
913    let lookahead = tkr.forward()?;
914    if lookahead.tk_type == TokenType::TK_SEMICOLON {
915        tkr.next()?;
916        return Ok(());
917    }
918
919    if lookahead.tk_type == TokenType::TK_BRACE_RIGHT {
920        return Ok(());
921    }
922
923    if lookahead.tk_type == TokenType::TK_EOF {
924        return Ok(());
925    }
926
927    return Err(format!("unexpected token: {:?} (expected ';')", lookahead));
928}
929
930fn ast_forexpression(tkr: &mut Tokenlizer, stop: TokenType) -> Result<AstNode, String> {
931    if tkr.forward()?.tk_type == stop {
932        tk_expect(tkr, stop)?;
933        return Ok(AstNode::new(AstType::AST_NULL, tkr.line()));
934    }
935    let a = ast_expression(tkr)?;
936    tk_expect(tkr, stop)?;
937    return Ok(a);
938}
939
940fn ast_forstatement(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
941    tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
942
943    if tk_accept(tkr, TokenType::TK_VAR)? {
944        let a = ast_vardeclist(tkr)?;
945        if tk_accept(tkr, TokenType::TK_SEMICOLON)? {
946            let b = ast_forexpression(tkr, TokenType::TK_SEMICOLON)?;
947            let c = ast_forexpression(tkr, TokenType::TK_PAREN_RIGHT)?;
948            let d = ast_statement(tkr)?;
949
950            let stm = AstNode::new_a_b_c_d(AstType::STM_FOR_VAR, tkr.line(), a, b, c, d);
951            return Ok(stm);
952        }
953        if tk_accept(tkr, TokenType::TK_IN)? {
954            let b = ast_expression(tkr)?;
955            tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
956            let c = ast_statement(tkr)?;
957
958            let stm = AstNode::new_a_b_c(AstType::STM_FOR_IN_VAR, tkr.line(), a, b, c);
959            return Ok(stm);
960        }
961        return Err(format!("unexpected token in for-var-statement: {:?}", tkr.forward()));
962    }
963
964    let mut a = AstNode::new(AstType::AST_NULL, tkr.line());
965    if tkr.forward()?.tk_type != TokenType::TK_SEMICOLON {
966        // inside this expression, we don't accept in operator.
967        let old = tkr.notin;
968        tkr.notin = true;
969        a = ast_expression(tkr)?;
970        tkr.notin = old;
971    }
972    if tk_accept(tkr, TokenType::TK_SEMICOLON)? {
973        let b = ast_forexpression(tkr, TokenType::TK_SEMICOLON)?;
974        let c = ast_forexpression(tkr, TokenType::TK_PAREN_RIGHT)?;
975        let d = ast_statement(tkr)?;
976        let stm = AstNode::new_a_b_c_d(AstType::STM_FOR, tkr.line(), a, b, c, d);
977        return Ok(stm);
978
979    }
980    if tk_accept(tkr, TokenType::TK_IN)? {
981        let b = ast_expression(tkr)?;
982        tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
983        let c = ast_statement(tkr)?;
984
985        let stm = AstNode::new_a_b_c(AstType::STM_FOR_IN, tkr.line(), a, b, c);
986        return Ok(stm);
987    }
988
989    return Err(format!("unexpected token in for-statement: {:?}", tkr.forward()));
990}
991
992fn ast_caselist(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
993    let node = ast_caseclause(tkr)?;
994
995    let mut head = AstNode::new_list( node );
996    let mut tail: &mut AstNode = &mut head;
997    while tkr.forward()?.tk_type != TokenType::TK_BRACE_RIGHT  {
998        AstNode::list_tail_push(tail, ast_caseclause(tkr)?);
999        tail = tail.b.as_mut().unwrap();
1000    }
1001    return Ok(head);
1002}
1003
1004fn ast_statement_list(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
1005    let tk = tkr.forward()?;
1006    if tk.tk_type == TokenType::TK_BRACE_RIGHT || tk.tk_type == TokenType::TK_CASE || tk.tk_type == TokenType::TK_DEFAULT {
1007        return Ok(AstNode::new(AstType::AST_NULL, tkr.line()));
1008    }
1009    let mut head = AstNode::new_list( ast_statement(tkr)?);
1010
1011    let mut tail: &mut AstNode = &mut head;
1012    loop {
1013        let tk = tkr.forward()?;
1014        if tk.tk_type == TokenType::TK_BRACE_RIGHT || tk.tk_type == TokenType::TK_CASE || tk.tk_type == TokenType::TK_DEFAULT {
1015            break;
1016        }
1017        AstNode::list_tail_push(tail, ast_statement(tkr)?);
1018        tail = tail.b.as_mut().unwrap();
1019    }
1020
1021    return Ok(head);
1022}
1023
1024fn ast_block(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
1025    let _leftbrace = tk_expect(tkr, TokenType::TK_BRACE_LEFT)?;
1026    let a = ast_statement_list(tkr)?;
1027    tk_expect(tkr, TokenType::TK_BRACE_RIGHT)?;
1028    return Ok( AstNode::new_a(AstType::STM_BLOCK, tkr.line(), a) );
1029}
1030
1031fn ast_statement(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
1032    if tkr.forward()?.tk_type == TokenType::TK_BRACE_LEFT {
1033        return ast_block(tkr);
1034
1035    } else if tk_accept(tkr, TokenType::TK_VAR)? {
1036        let a = ast_vardeclist(tkr)?;
1037        ast_semicolon(tkr)?;
1038        let stm = AstNode::new_a(AstType::STM_VAR, tkr.line(), a);
1039        return Ok(stm);
1040
1041    } else if tk_accept(tkr, TokenType::TK_SEMICOLON)? {
1042        return Ok( AstNode::new(AstType::STM_EMPTY, tkr.line()) );
1043
1044    } else if tk_accept(tkr, TokenType::TK_IF)? {
1045        tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
1046        let a = ast_expression(tkr)?;
1047        tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
1048        let b = ast_statement(tkr)?;
1049        if tk_accept(tkr, TokenType::TK_ELSE)? {
1050            let c = ast_statement(tkr)?;
1051            return Ok(AstNode::new_a_b_c(AstType::STM_IF, tkr.line(), a, b, c));
1052        }
1053        return Ok(AstNode::new_a_b(AstType::STM_IF, tkr.line(), a, b));
1054
1055    } else if tk_accept(tkr, TokenType::TK_DO)? {
1056        let a = ast_statement(tkr)?;
1057        tk_expect(tkr, TokenType::TK_WHILE)?;
1058        tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
1059        let b = ast_expression(tkr)?;
1060        tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
1061        ast_semicolon(tkr)?;
1062
1063        let stm = AstNode::new_a_b(AstType::STM_DO, tkr.line(), a, b);
1064        return Ok(stm);
1065
1066    } else if tk_accept(tkr, TokenType::TK_WHILE)? {
1067        tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
1068        let a = ast_expression(tkr)?;
1069        tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
1070        let b = ast_statement(tkr)?;
1071
1072        let stm = AstNode::new_a_b(AstType::STM_WHILE, tkr.line(), a, b);
1073        return Ok(stm);
1074
1075    } else if tk_accept(tkr, TokenType::TK_FOR)? {
1076        let stm = ast_forstatement(tkr)?;
1077        return Ok(stm);
1078
1079    } else if tk_accept(tkr, TokenType::TK_CONTINUE)? {
1080        let id_opt = ast_identifier_opt(tkr)?;
1081        ast_semicolon(tkr)?;
1082        let stm = AstNode::new_a(AstType::STM_CONTINUE, tkr.line(), id_opt);
1083        return Ok(stm);
1084
1085    } else if tk_accept(tkr, TokenType::TK_BREAK)? {
1086        let id_opt = ast_identifier_opt(tkr)?;
1087        ast_semicolon(tkr)?;
1088        let stm = AstNode::new_a(AstType::STM_BREAK, tkr.line(), id_opt);
1089        return Ok(stm);
1090
1091    } else if tk_accept(tkr, TokenType::TK_RETURN)? {
1092
1093        let ntk = tkr.forward()?;
1094        if ntk.tk_type != TokenType::TK_SEMICOLON && ntk.tk_type != TokenType::TK_BRACE_RIGHT {            
1095            let a = ast_expression(tkr)?;
1096            let stm = AstNode::new_a(AstType::STM_RETURN, tkr.line(), a);
1097            return Ok(stm);
1098        }
1099
1100        ast_semicolon(tkr)?;
1101        let a = AstNode::new(AstType::AST_NULL, tkr.line());
1102        let stm = AstNode::new_a(AstType::STM_RETURN, tkr.line(), a);
1103
1104        return Ok(stm);
1105        
1106    } else if tk_accept(tkr, TokenType::TK_SWITCH)? {
1107        tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
1108        let a = ast_expression(tkr)?;
1109        tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
1110        tk_expect(tkr, TokenType::TK_BRACE_LEFT)?;
1111        if tk_accept(tkr, TokenType::TK_BRACE_RIGHT)? {
1112            let stm = AstNode::new_a(AstType::STM_SWITCH, tkr.line(), a);
1113            return Ok(stm);
1114        }
1115        let b = ast_caselist(tkr)?;
1116        tk_expect(tkr, TokenType::TK_BRACE_RIGHT)?;
1117        let stm = AstNode::new_a_b(AstType::STM_SWITCH, tkr.line(), a, b);
1118        return Ok(stm);
1119
1120    } else if tk_accept(tkr, TokenType::TK_THROW)? {
1121        let a = ast_expression(tkr)?;
1122        ast_semicolon(tkr)?;
1123
1124        let stm = AstNode::new_a(AstType::STM_THROW, tkr.line(), a);
1125        return Ok(stm);
1126
1127    } else if tk_accept(tkr, TokenType::TK_TRY)? {
1128        let a = ast_block(tkr)?;
1129        if tk_accept(tkr, TokenType::TK_CATCH)? {
1130            tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
1131            let b = ast_identifier(tkr)?;
1132            tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
1133            let c = ast_block(tkr)?;
1134
1135            if tk_accept(tkr, TokenType::TK_FINALLY)? {
1136                let d = ast_block(tkr)?;
1137                let stm = AstNode::new_a_b_c_d(AstType::STM_TRY, tkr.line(), a, b, c, d);
1138                return Ok(stm);
1139            }
1140            let stm = AstNode::new_a_b_c(AstType::STM_TRY, tkr.line(), a, b, c);
1141            return Ok(stm);
1142        }
1143        if tk_accept(tkr, TokenType::TK_FINALLY)? {
1144            let b = ast_block(tkr)?;
1145            let stm = AstNode::new_a_b(AstType::STM_TRY, tkr.line(), a, b);
1146            return Ok(stm);
1147        }
1148        return Err(format!("unexpected token in try: {:?} (expected 'catch' or 'finally')", tkr.forward()? ));
1149
1150    } else if tk_accept(tkr, TokenType::TK_FUNCTION)? {
1151        let a = ast_identifier(tkr)?;
1152        tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
1153        let b = ast_parameters(tkr)?;
1154        tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
1155        let c = ast_funbody(tkr)?;
1156
1157        /* rewrite function statement as "var X = function X() {}" */
1158        let aa = a.clone();
1159        let fun = AstNode::new_a_b_c(AstType::EXP_FUN, tkr.line(), a, b, c);
1160        let var = AstNode::new_a_b(AstType::EXP_VAR, tkr.line(), aa, fun);
1161        let lst = AstNode::new_list(var);
1162        let stm = AstNode::new_a(AstType::STM_VAR, tkr.line(), lst);
1163        return Ok(stm);
1164
1165    } else if tk_accept(tkr, TokenType::TK_DEBUG)? {
1166        let a = AstNode::new(AstType::STM_DEBUG, tkr.line());
1167        ast_semicolon(tkr)?;
1168        return Ok(a);
1169                
1170    } else if tk_lookahead(tkr, TokenType::TK_IDENTIFIER)? {
1171        let mut a = ast_expression(tkr)?;
1172        if a.ast_type == AstType::EXP_IDENTIFIER {
1173            if tk_accept(tkr, TokenType::TK_COLON)? {
1174                a.ast_type = AstType::AST_IDENTIFIER;
1175                let b = ast_statement(tkr)?;
1176                let stm = AstNode::new_a_b(AstType::STM_LABEL, tkr.line(), a, b);
1177                return Ok(stm);
1178            }
1179        }
1180        ast_semicolon(tkr)?;
1181        return Ok(a);     
1182    }
1183
1184    let stm = ast_expression(tkr)?;
1185    ast_semicolon(tkr)?;
1186    return Ok(stm);
1187}
1188
1189fn ast_funbody(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
1190    tk_expect(tkr, TokenType::TK_BRACE_LEFT)?;
1191    
1192    if tk_accept(tkr, TokenType::TK_BRACE_RIGHT)? == true {
1193        let empty = AstNode::new( AstType::AST_NULL, 0);
1194        return Ok(empty);
1195    }
1196    
1197    let mut head = AstNode::new_list( ast_element(tkr)?);
1198
1199    let mut tail: &mut AstNode = &mut head;
1200    while tk_accept(tkr, TokenType::TK_BRACE_RIGHT)? == false {
1201        AstNode::list_tail_push(tail, ast_element(tkr)?);
1202        tail = tail.b.as_mut().unwrap();
1203    }
1204
1205    return Ok(head);
1206}
1207
1208fn ast_fundec(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
1209    let a = ast_identifier(tkr)?;
1210    tk_expect(tkr, TokenType::TK_PAREN_LEFT)?;
1211    let b = ast_parameters(tkr)?;
1212    tk_expect(tkr, TokenType::TK_PAREN_RIGHT)?;
1213    let c = ast_funbody(tkr)?;
1214
1215    let func = AstNode::new_a_b_c(AstType::AST_FUNDEC, tkr.line(), a, b, c);
1216    return Ok(func);
1217}
1218
1219fn ast_element(tkr: &mut Tokenlizer) -> Result<AstNode, String> {
1220    if tk_accept(tkr, TokenType::TK_FUNCTION)? {
1221        return ast_fundec(tkr);
1222    }
1223    return ast_statement(tkr);
1224}
1225
1226pub fn build_ast_from_script(script: &str) -> Result<AstNode, String> {
1227    let mut tkr = Tokenlizer::new(script);
1228
1229    if tk_accept(&mut tkr, TokenType::TK_EOF)? {
1230        let empty = AstNode::new( AstType::AST_NULL, 0);
1231        return Ok(empty);
1232    }
1233
1234    let mut head = AstNode::new_list( ast_element(&mut tkr)?);
1235
1236    let mut tail: &mut AstNode = &mut head;
1237    while tk_accept(&mut tkr, TokenType::TK_EOF)? == false {
1238        AstNode::list_tail_push(tail, ast_element(&mut tkr)?);
1239        tail = tail.b.as_mut().unwrap();
1240    }
1241
1242    return Ok(head);
1243}
1244
ezjs/ast.rs

ezjs/
ast.rs
