projects/dang: parser/Parser.d annotate

annotate parser/Parser.d @ 92:771ac63898e2 new_gen

A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot.

author	Anders Johnsen <skabet@gmail.com>
date	Mon, 05 May 2008 18:44:20 +0200
parents	a49bb982a7b0
children	48bb2287c035

rev	line source
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	1 module parser.Parser;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	2
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	3 import lexer.Lexer,
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	4 lexer.Token;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	5
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	6 import parser.Action;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	7
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	8 import basic.Message;
21 0fb2d13dce37 Now working with gdc also (gdc use reverse paremeter validating on function calls) johnsen@johnsen-laptop parents: 12 diff changeset	9
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	10 import basic.SmallArray,
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	11 basic.SourceManager;
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	12
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	13 import tango.io.Stdout,
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	14 Integer = tango.text.convert.Integer;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	15
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	16 class Parser
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	17 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	18 Action action;
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	19 MessageHandler messages;
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	20 alias Object Exp;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	21 alias Object Stmt;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	22 alias Object Decl;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	23
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	24 public:
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	25
a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	26 this(MessageHandler messages)
a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	27 {
a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	28 this.messages = messages;
a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	29 }
a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	30
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	31 Decl[] parse(SourceManager sm, Lexer lexer, Action act)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	32 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	33 this.sm = sm;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	34 this.lexer = lexer;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	35 this.action = act;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	36
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	37 Decl[] declarations;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	38
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	39 while(lexer.peek.type != Tok.EOF)
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	40 declarations ~= parseDecl();
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	41
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	42 return declarations;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	43 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	44
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	45 Decl parseDecl()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	46 {
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	47 Token t = lexer.peek;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	48
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	49 if (t.isBasicType \|\| t.isIdentifier)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	50 {
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	51 Id type;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	52 Id iden;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	53 int len = peekParseType;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	54 if(lexer.peek(len).type == Tok.Identifier && len != 0)
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	55 {
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	56 type = parseType;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	57 parseDeclAfterInvalidType:
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	58 iden = Id(require(Tok.Identifier));
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	59 Token next = lexer.peek();
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	60 if (next.type == Tok.Seperator)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	61 {
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	62 Token sep = lexer.next();
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	63 return action.actOnDeclarator(type, iden, null);
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	64 }
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	65 else if (next.type == Tok.Assign)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	66 {
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	67 Token assign = lexer.next();
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	68 Exp exp = parseExpression();
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	69 require(Tok.Seperator);
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	70 return action.actOnDeclarator(type, iden, exp);
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	71 }
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	72 else if (next.type == Tok.OpenParentheses)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	73 return parseFunc(type, iden);
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	74 else
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	75 messages.report(UnexpectedTok, next.location).arg(next.getType);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	76 }
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	77 t = lexer.peek(len);
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	78 messages.report(InvalidDeclType, t.location)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	79 .arg(sm.getText(t.asRange));
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	80 while(len--)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	81 lexer.next;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	82 while(lexer.peek.type != Tok.Identifier)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	83 lexer.next;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	84 type = Id(lexer.peek);
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	85 goto parseDeclAfterInvalidType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	86 }
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	87 else if (t.type == Tok.Struct)
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	88 {
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	89 Id type = Id(lexer.next);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	90 Id iden = Id(require(Tok.Identifier));
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	91
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	92 return parseStruct(type, iden);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	93 }
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	94 messages.report(UnexpectedTok, t.location)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	95 .arg(t.getType)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	96 .arg(Tok.Identifier)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	97 .fatal(ExitLevel.Parser);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	98 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	99
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	100 /**
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	101 Parse struct
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	102 */
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	103 Decl parseStruct(Id type, Id iden)
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	104 {
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	105 auto decl = action.actOnDeclarator(type, iden, null);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	106
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	107 require(Tok.OpenBrace);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	108
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	109 while(lexer.peek.isBasicType \|\| lexer.peek.isIdentifier)
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	110 {
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	111 Id var_type = Id(lexer.next);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	112 Id var_iden = Id(require(Tok.Identifier));
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	113 Token next = lexer.peek();
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	114 if (next.type == Tok.Seperator)
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	115 {
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	116 Token sep = lexer.next();
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	117 action.actOnStructMember(decl, var_type, var_iden, null);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	118 continue;
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	119 }
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	120 else if (next.type == Tok.Assign)
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	121 {
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	122 Token assign = lexer.next();
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	123 Exp exp = parseExpression();
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	124 require(Tok.Seperator);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	125 action.actOnStructMember(decl, var_type, var_iden, exp);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	126 continue;
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	127 }
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	128 messages.report(UnexpectedTok, next.location).arg(next.getType);
53 da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	129 }
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	130
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	131 require(Tok.CloseBrace);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	132
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	133 return decl;
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	134 }
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	135 /**
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	136 Parse statements.
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	137
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	138 This is the place to attack!
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	139 */
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	140 Stmt parseStatement()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	141 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	142 Token t = lexer.peek;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	143
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	144 switch(t.type)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	145 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	146 case Tok.Return:
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	147 Token ret = lexer.next;
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	148 Exp exp;
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	149 if (lexer.peek.type != Tok.Seperator)
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	150 exp = parseExpression();
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	151 require(Tok.Seperator);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	152 return action.actOnReturnStmt(ret, exp);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	153
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	154 /*
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	155 if (cond)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	156 single statement \| compound statement
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	157 [else
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	158 single statement \| compound statement]
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	159 */
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	160 case Tok.If:
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	161 Token _if = lexer.next();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	162
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	163 require(Tok.OpenParentheses);
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	164 Exp cond = parseExpression();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	165 require(Tok.CloseParentheses);
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	166
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	167 Stmt thenB = parseSingleOrCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	168
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	169 // if there is no else part we use the if as token, to have
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	170 // something than can be passed along
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	171 Token _else = _if;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	172 Stmt elseB;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	173 if (lexer.peek.type == Tok.Else)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	174 {
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	175 _else = lexer.next;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	176 elseB = parseSingleOrCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	177 }
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	178
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	179 return action.actOnIfStmt(_if, cond, thenB, _else, elseB);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	180
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	181 /*
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	182 while (cond)
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	183 single statement \| compound statement
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	184 */
11 642c6a998fd9 Support for while statements and fixed scope for if Anders Halager <halager@gmail.com> parents: 10 diff changeset	185 case Tok.While:
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	186 Token _while = lexer.next;
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	187 require(Tok.OpenParentheses);
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	188 Exp cond = parseExpression();
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	189 require(Tok.CloseParentheses);
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	190 Stmt bodyStmt = parseSingleOrCompoundStatement();
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	191 return action.actOnWhileStmt(_while, cond, bodyStmt);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	192
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	193 /*
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	194 One of four things:
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	195 A declaration of a function/variable `type id ...`
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	196 A direct assignment `id = exp;`
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	197 An indirect assignment `id.id = exp`
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	198 Some sort of free standing expression
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	199
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	200 The assignments should be handled as binary expressions?
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	201 */
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	202 case Tok.Identifier:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	203 Token iden = lexer.peek;
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	204 Token n = lexer.peek(1);
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	205 // Must be an decl, if we start with a basic type, or two
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	206 // identifiers in a row
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	207 if (iden.isBasicType() \|\| iden.isIdentifier())
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	208 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	209 if ( n.type == Tok.Star \|\| n.type == Tok.OpenBracket)
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	210 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	211 int len = peekParseType;
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	212 if(lexer.peek(len).type == Tok.Identifier && len != 0)
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	213 return action.actOnDeclStmt(parseVarDecl());
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	214
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	215 Exp exp = parseExpression();
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	216 require(Tok.Seperator);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	217 return action.actOnExprStmt(exp);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	218 }
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	219
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	220 if ( n.isIdentifier())
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	221 return action.actOnDeclStmt(parseVarDecl());
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	222
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	223 // Expression: a.b, a = b, a(b) etc.
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	224 Exp exp = parseExpression();
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	225 require(Tok.Seperator);
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	226 return action.actOnExprStmt(exp);
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	227 break;
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	228 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	229
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	230 case Tok.Switch:
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	231 messages.report(UnexpectedTok, lexer.peek.location).arg(lexer.next.getType);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	232 return null;
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	233
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	234 default:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	235 if (t.isBasicType())
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	236 goto case Tok.Identifier;
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	237 if (t.type == Tok.Star)
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	238 {
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	239 auto exp = parseExpression();
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	240 require(Tok.Seperator);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	241 return action.actOnExprStmt(exp);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	242 }
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	243 messages.report(UnexpectedBeginStmt, lexer.peek.location).arg(lexer.next.getType);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	244 }
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	245 messages.report(UnexpectedTok, t.location);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	246 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	247 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	248
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	249 Decl parseVarDecl()
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	250 {
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	251 // manually hardcoded to only support "type id [= exp];"
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	252 // as that is the only thing the codegen understands
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	253 Id type = parseType;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	254 Id id = Id(lexer.next);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	255 Exp init;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	256 if (skip(Tok.Assign))
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	257 init = parseExpression();
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	258 require(Tok.Seperator);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	259 Decl d = action.actOnDeclarator(type, id, init);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	260 return d;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	261 }
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	262
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	263 /**
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	264 Parses a function/method given the already parsed return type and name
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	265 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	266 Decl parseFunc(ref Id type, ref Id name)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	267 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	268 Decl func = action.actOnStartOfFunctionDef(type, name);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	269 parseFuncArgs(func);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	270
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	271 if(lexer.peek.type == Tok.Seperator)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	272 {
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	273 lexer.next;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	274 return func;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	275 }
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	276 Stmt stmt = parseCompoundStatement();
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	277
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	278 return action.actOnEndOfFunction(func, stmt);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	279 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	280
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	281 /**
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	282 Parse the function arguments, assumes current token is (.
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	283
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	284 Both the intitial paren and the ending paren is consumed.
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	285 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	286 void parseFuncArgs(Decl func)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	287 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	288 require(Tok.OpenParentheses); // Remove the "(" token.
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	289
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	290 while(lexer.peek.type != Tok.CloseParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	291 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	292 auto t = parseType();
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	293 Id i;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	294 if(lexer.peek.type == Tok.Identifier)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	295 i = parseIdentifier();
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	296 action.addFuncArg(func, t, i);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	297
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	298 if(lexer.peek.type == Tok.Comma)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	299 lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	300 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	301
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	302 require(Tok.CloseParentheses); // Remove the ")"
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	303 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	304
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	305 /**
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	306 Parse either a block, or a single statement as allowed after if, while
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	307 and for.
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	308 */
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	309 Stmt parseSingleOrCompoundStatement()
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	310 {
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	311 if (lexer.peek.type == Tok.OpenBrace)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	312 return parseCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	313 return parseStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	314 }
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	315 /**
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	316 Parses a function-body or similar, expects { to be current token.
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	317
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	318 Will consume both the starting { and ending }
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	319 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	320 Stmt parseCompoundStatement()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	321 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	322 Token lbrace = require(Tok.OpenBrace);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	323 SmallArray!(Stmt, 32) stmts; // Try to use the stack only
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	324 while (lexer.peek.type != Tok.CloseBrace)
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	325 stmts ~= parseStatement();
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	326 Token rbrace = require(Tok.CloseBrace);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	327 return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe());
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	328 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	329
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	330 Id parseIdentifier()
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	331 {
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	332 Token tok = lexer.next;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	333
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	334 if (tok.type is Tok.Identifier)
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	335 return Id(tok);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	336
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	337 messages.report(UnexpectedTokSingle, tok.location)
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	338 .arg(tok.getType)
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	339 .arg(Tok.Identifier);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	340 }
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	341
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	342 /**
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	343 Parse a type - this includes pointer and array(at some point) types.
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	344 */
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	345 Id parseType()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	346 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	347 Token type = lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	348
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	349 Id currentType;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	350
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	351 if ( !(type.isBasicType \|\| type.type == Tok.Identifier) )
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	352 messages.report(InvalidType, type.location);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	353
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	354 currentType = Id(type);
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	355 type = lexer.peek;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	356
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	357 while(type.type == Tok.Star \|\| type.type == Tok.OpenBracket)
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	358 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	359 if(type.type == Tok.Star)
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	360 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	361 currentType = PointerId(currentType);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	362 lexer.next;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	363 }
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	364 else
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	365 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	366 lexer.next;
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	367 if(lexer.peek.type == Tok.Integer)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	368 currentType = ArrayId(currentType, action.actOnNumericConstant(require(Tok.Integer)));
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	369 require(Tok.CloseBracket);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	370
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	371 }
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	372 type = lexer.peek;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	373 }
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	374
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	375 return currentType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	376 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	377
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	378 int peekParseType()
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	379 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	380 int i;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	381 Token type = lexer.peek(i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	382
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	383 Id currentType;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	384
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	385 if ( !(type.isBasicType \|\| type.type == Tok.Identifier) )
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	386 return 0;
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	387
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	388 currentType = Id(type);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	389 type = lexer.peek(++i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	390
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	391 while(type.type == Tok.Star \|\| type.type == Tok.OpenBracket)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	392 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	393 if(type.type == Tok.Star)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	394 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	395 i++;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	396 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	397 else
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	398 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	399 if(lexer.peek(i++).type != Tok.OpenBracket)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	400 return 0;
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	401 if(lexer.peek(i).type == Tok.Integer)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	402 {
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	403 i++;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	404 if(lexer.peek(i++).type != Tok.CloseBracket)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	405 return 0;
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	406 }
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	407 else
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	408 if(lexer.peek(i++).type != Tok.CloseBracket)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	409 return 0;
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	410
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	411 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	412 type = lexer.peek(i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	413 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	414
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	415 return i;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	416 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	417
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	418 private:
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	419 // -- Expression parsing -- //
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	420 Exp parsePostfixExp(Exp target)
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	421 {
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	422 switch(lexer.peek.type)
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	423 {
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	424 case Tok.Dot:
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	425 switch(lexer.peek(1).type)
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	426 {
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	427 case Tok.Identifier:
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	428 Token op = lexer.next;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	429 Id member = Id(lexer.next);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	430 Exp exp = action.actOnMemberReference(target, op.location, member);
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	431 return parsePostfixExp(exp);
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	432 default:
30 3147a52d1247 Ooops.. should have compiled before commit.. now works again Anders Halager <halager@gmail.com> parents: 29 diff changeset	433 Token t = lexer.peek(1);
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	434 messages.report(ExpectedIdAfterDot, t.location);
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	435 }
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	436 case Tok.OpenBracket:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	437 Token open = lexer.next;
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	438 Exp index = parseExpression();
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	439 Token close = require(Tok.CloseBracket);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	440 return action.actOnIndexEpr(target, open, index, close);
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	441 default:
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	442 return target;
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	443 }
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	444 }
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	445
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	446 Exp parseExpression(int p = 0)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	447 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	448 auto exp = P();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	449 Token next = lexer.peek();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	450 BinOp* op = null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	451 while ((op = binary(next.type)) != null && op.prec >= p)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	452 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	453 lexer.next();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	454 int q = op.leftAssoc? 1 + op.prec : op.prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	455 auto exp2 = parseExpression(q);
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	456 exp = action.actOnBinaryOp(next.location, op.operator, exp, exp2);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	457 next = lexer.peek();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	458 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	459
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	460 return exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	461 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	462
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	463 Exp P()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	464 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	465 Token next = lexer.next();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	466 if (auto op = unary(next.type))
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	467 return action.actOnUnaryOp(next, parseExpression(op.prec));
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	468 else if (next.type == Tok.OpenParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	469 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	470 auto e = parseExpression(0);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	471 require(Tok.CloseParentheses);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	472 return e;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	473 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	474 else if (next.type == Tok.Identifier)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	475 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	476 Exp value = action.actOnIdentifierExp(Id(next));
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	477 Exp iden = parsePostfixExp(value);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	478 switch(lexer.peek.type)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	479 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	480 case Tok.OpenParentheses:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	481 Token lp = lexer.next;
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	482 SmallArray!(Exp, 8) args;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	483 while(lexer.peek.type != Tok.CloseParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	484 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	485 if(lexer.peek.type == Tok.Comma)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	486 lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	487 args ~= parseExpression();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	488 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	489
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	490 Token rp = lexer.next();
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	491 return action.actOnCallExpr(iden, lp, args.unsafe(), rp);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	492
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	493 default:
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 22 diff changeset	494 return iden;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	495 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	496 }
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	497 else if (next.type == Tok.Cast)
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	498 return parseCast(next);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	499 else if (next.type == Tok.Integer)
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	500 return action.actOnNumericConstant(next);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	501
92 771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	502 messages.report(ExpectedExp, next.location)
771ac63898e2 A few better parser errors plus renaming most of the sema classes to match that they do now. Some have changes a lot. Anders Johnsen <skabet@gmail.com> parents: 89 diff changeset	503 .fatal(ExitLevel.Parser);
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	504 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	505 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	506
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	507 Exp parseCast(ref Token _cast)
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	508 {
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	509 require(Tok.OpenParentheses);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	510 auto next = lexer.next;
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	511 if(!next.isBasicType && !next.isIdentifier)
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	512 messages.report(ExpectedCastType, next.location);
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	513
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	514 require(Tok.CloseParentheses);
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	515 auto exp = P();
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	516 return action.actOnCastExpr(_cast, Id(next), exp);
68 381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	517 }
381975d76baf A LOT of bug fixing - also implemented implicit casts. If you do a --ast-dump-code on a target with some algebra of differant types, you should now see the type casts being made. Also, Tests are again back with only switches failing... Anders Johnsen <skabet@gmail.com> parents: 62 diff changeset	518
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	519 struct UnOp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	520 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	521 Tok tokenType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	522 int prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	523 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	524
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	525 static const UnOp[] _unary =
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	526 [
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	527 {Tok.Minus, 4},
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	528 {Tok.Star, 4}
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	529 ];
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	530 UnOp* unary(Tok t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	531 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	532 foreach (ref op; _unary)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	533 if (op.tokenType == t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	534 return &op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	535 return null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	536 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	537
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	538 struct BinOp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	539 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	540 Tok tokenType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	541 int prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	542 bool leftAssoc;
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	543 Operator operator;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	544 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	545
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	546 static const BinOp[] _binary =
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	547 [
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	548 {Tok.Assign, 1, false, Operator.Assign},
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	549
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	550 {Tok.Eq, 2, true, Operator.Eq},
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	551 {Tok.Ne, 2, true, Operator.Ne},
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	552
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	553 {Tok.Lt, 2, true, Operator.Lt},
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	554 {Tok.Le, 2, true, Operator.Le},
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	555 {Tok.Gt, 2, true, Operator.Gt},
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	556 {Tok.Ge, 2, true, Operator.Ge},
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	557
74 192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	558 {Tok.Plus, 3, true, Operator.Add},
192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	559 {Tok.Minus, 3, true, Operator.Sub},
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	560
74 192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	561 {Tok.Star, 5, true, Operator.Mul},
192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	562 {Tok.Slash, 5, true, Operator.Div},
192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	563 {Tok.Percent, 5, true, Operator.Mod}
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	564 ];
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	565 BinOp* binary(Tok t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	566 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	567 foreach (ref op; _binary)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	568 if (op.tokenType == t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	569 return &op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	570 return null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	571 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	572
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	573 private:
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	574
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	575 Token require(Tok t)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	576 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	577 if (lexer.peek().type != t)
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	578 messages.report(UnexpectedTokSingle, lexer.peek.location)
29 41d23f2762c3 Merge, and updated Error class Anders Halager <halager@gmail.com> parents: 28 diff changeset	579 .arg(lexer.peek.getType)
89 a49bb982a7b0 Using the new SourceLocation system to handle errors. Also, this is the first push for making the errors don't throw, but continue to check the source. Anders Johnsen <skabet@gmail.com> parents: 88 diff changeset	580 .arg(t);
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	581 return lexer.next();
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	582 }
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	583
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	584 bool skip(Tok t)
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	585 {
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	586 if (lexer.peek().type != t)
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	587 return false;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	588 lexer.next();
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	589 return true;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	590 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	591
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	592 Lexer lexer;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	593 SourceManager sm;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	594 }

Mercurial > projects > dang

annotate parser/Parser.d @ 92:771ac63898e2 new_gen