projects/dang: parser/Parser.d annotate

annotate parser/Parser.d @ 123:6a5f745d351c

Parsing <<, >> and >>>.

author	Anders Johnsen <skabet@gmail.com>
date	Sun, 25 May 2008 21:07:48 +0200
parents	0cd8d6ab3f89
children	c3b24e7e8cf8

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;
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	23 alias Object Module;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	24
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 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	26 {
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 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	28 }
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
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	30 Module parse(SourceManager sm, Lexer lexer, Action act)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	31 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	32 this.sm = sm;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	33 this.lexer = lexer;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	34 this.action = act;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	35
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	36 Module m;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	37 if (lexer.peek.type == Tok.Module)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	38 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	39 Token _module = lexer.next;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	40 ModuleName name = parseModuleName();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	41 m = action.actOnModule(_module, sm.getText(name.asRange()));
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	42 require(Tok.Seperator);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	43 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	44 else
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	45 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	46 SLoc loc = lexer.peek.location;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	47 m = action.actOnImplicitModule(loc, sm.getFile(loc));
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	48 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	49
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	50 while (lexer.peek.type != Tok.EOF)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	51 foreach (d; parseDeclDef())
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	52 action.actOnModuleDecl(m, d);
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	53
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	54 return m;
48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	55 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	56
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	57 private:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	58 Decl[] parseDeclDef()
94 48bb2287c035 Added Modules. Right now it's very simple - will grow with time and need. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	59 {
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	60 Token t = lexer.peek;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	61 if (t.type == Tok.Import)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	62 return parseImports();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	63 else
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	64 return [parseDecl()];
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	65 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	66
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	67 Decl parseDecl()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	68 {
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	69 Token t = lexer.peek;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	70
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	71 if (t.isBasicType \|\| t.isIdentifier)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	72 {
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	73 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	74 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	75 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	76 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	77 {
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	78 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	79 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	80 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	81 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	82 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	83 {
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 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	85 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	86 }
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	87 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	88 {
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	89 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	90 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	91 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	92 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	93 }
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 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	95 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	96 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	97 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	98 }
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	99 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	100 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	101 .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	102 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	103 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	104 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	105 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	106 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	107 goto parseDeclAfterInvalidType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	108 }
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	109 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	110 {
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	111 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	112 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	113
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 return parseStruct(type, iden);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	115 }
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	116 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	117 .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	118 .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	119 .fatal(ExitLevel.Parser);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	120 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	121
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	122 /**
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	123 Parse a series of imports belonging to a single import token.
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	124 */
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	125 Decl[] parseImports()
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	126 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	127 Token _import = require(Tok.Import);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	128 SmallArray!(Decl) res;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	129 void addToRes(Decl d) { res ~= d; }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	130
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	131 bool done = false;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	132 while (!done && !on_a(Tok.Seperator))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	133 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	134 ModuleName mod = parseModuleName();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	135 Token tok = lexer.peek;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	136 switch (tok.type)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	137 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	138 case Tok.Comma:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	139 // import A, B.C;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	140 // parse another module-name
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	141 lexer.next();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	142 res ~= action.actOnImport(_import, mod, null);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	143 break;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	144 case Tok.Assign:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	145 // import B = A.A;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	146 // ^- must be a single identifier
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	147 // renamed import
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	148 if (mod.packages.length != 0)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	149 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	150 SLoc loc = mod.packages[0].tok.location;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	151 messages.report(RenameMustBeSingleIdent, loc);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	152 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	153 //if (isStatic)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	154 // error("Static imports cannot be renamed");
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	155 lexer.next();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	156 Id name = mod.id;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	157 mod = parseModuleName();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	158 // create from mod and rename to `name`
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	159 res ~= action.actOnImport(_import, mod, &name);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	160 break;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	161 case Tok.Colon:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	162 // import A : a;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	163 // selective imports, potentially import A : print = a
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	164 lexer.next();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	165 Decl d = action.actOnImport(_import, mod, null);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	166 // do-while on a comma:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	167 // add explicit symbol
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	168 do
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	169 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	170 Id sym = parseIdentifier();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	171 Id dummy;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	172 Id* name = null;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	173 if (skip(Tok.Assign))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	174 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	175 dummy = sym;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	176 name = &dummy;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	177 sym = parseIdentifier();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	178 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	179 action.addSelectiveImport(d, sym, name);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	180
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	181 } while (skip(Tok.Comma));
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	182 require(Tok.Seperator);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	183 res ~= d;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	184 return res.safe();
100 5f258eaf9517 Loading modules in. Just need to add them to the scope of the "main" Module now. Anders Johnsen <skabet@gmail.com> parents: 99 diff changeset	185 case Tok.Seperator:
5f258eaf9517 Loading modules in. Just need to add them to the scope of the "main" Module now. Anders Johnsen <skabet@gmail.com> parents: 99 diff changeset	186 done = true;
5f258eaf9517 Loading modules in. Just need to add them to the scope of the "main" Module now. Anders Johnsen <skabet@gmail.com> parents: 99 diff changeset	187 break;
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	188 default:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	189 goto Lerror;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	190 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	191 res ~= action.actOnImport(_import, mod, null);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	192 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	193
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	194 require(Tok.Seperator);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	195 return res.safe();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	196 Lerror:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	197 while (!on_a (Tok.Seperator))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	198 lexer.next();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	199 return res.safe();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	200 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	201
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	202 /**
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	203 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	204 */
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	205 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	206 {
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	207 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	208
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	209 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	210
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	211 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	212 {
102 cd066f3b539a Parsing methods in structs - error on semantics though. Anders Johnsen <skabet@gmail.com> parents: 100 diff changeset	213 auto m_decl = parseDecl();
cd066f3b539a Parsing methods in structs - error on semantics though. Anders Johnsen <skabet@gmail.com> parents: 100 diff changeset	214 action.actOnStructMember(decl, m_decl);
cd066f3b539a Parsing methods in structs - error on semantics though. Anders Johnsen <skabet@gmail.com> parents: 100 diff changeset	215 /* Id var_type = Id(lexer.next);
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	216 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	217 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	218 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	219 {
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	220 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	221 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	222 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	223 }
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	224 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	225 {
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	226 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	227 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	228 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	229 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	230 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	231 }
102 cd066f3b539a Parsing methods in structs - error on semantics though. Anders Johnsen <skabet@gmail.com> parents: 100 diff changeset	232 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	233 }
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	234
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	235 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	236
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	237 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	238 }
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	239
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	240 /**
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	241 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	242
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	243 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	244 */
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	245 Stmt parseStatement()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	246 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	247 Token t = lexer.peek;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	248
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	249 switch(t.type)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	250 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	251 case Tok.Return:
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	252 Token ret = lexer.next;
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	253 Exp exp;
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	254 if (lexer.peek.type != Tok.Seperator)
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	255 exp = parseExpression();
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	256 require(Tok.Seperator);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	257 return action.actOnReturnStmt(ret, exp);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	258
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	259 /*
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	260 if (cond)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	261 single statement \| compound statement
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	262 [else
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	263 single statement \| compound statement]
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	264 */
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	265 case Tok.If:
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	266 Token _if = lexer.next();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	267
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	268 require(Tok.OpenParentheses);
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	269 Exp cond = parseExpression();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	270 require(Tok.CloseParentheses);
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	271
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	272 Stmt thenB = parseSingleOrCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	273
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	274 // 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	275 // something than can be passed along
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	276 Token _else = _if;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	277 Stmt elseB;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	278 if (lexer.peek.type == Tok.Else)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	279 {
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	280 _else = lexer.next;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	281 elseB = parseSingleOrCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	282 }
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	283
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	284 return action.actOnIfStmt(_if, cond, thenB, _else, elseB);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	285
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	286 /*
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	287 while (cond)
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	288 single statement \| compound statement
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	289 */
11 642c6a998fd9 Support for while statements and fixed scope for if Anders Halager <halager@gmail.com> parents: 10 diff changeset	290 case Tok.While:
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	291 Token _while = lexer.next;
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	292 require(Tok.OpenParentheses);
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	293 Exp cond = parseExpression();
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	294 require(Tok.CloseParentheses);
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	295 Stmt bodyStmt = parseSingleOrCompoundStatement();
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	296 return action.actOnWhileStmt(_while, cond, bodyStmt);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	297
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	298 /*
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	299 One of four things:
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	300 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	301 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	302 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	303 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	304
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	305 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	306 */
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	307 case Tok.Identifier:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	308 Token iden = lexer.peek;
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	309 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	310 // 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	311 // identifiers in a row
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	312 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	313 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	314 if ( n.type == Tok.Star \|\| n.type == Tok.OpenBracket)
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	315 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	316 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	317 if(lexer.peek(len).type == Tok.Identifier && len != 0)
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	318 return action.actOnDeclStmt(parseVarDecl());
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	319
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	320 Exp exp = parseExpression();
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	321 require(Tok.Seperator);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	322 return action.actOnExprStmt(exp);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	323 }
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	324
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	325 if (n.isIdentifier())
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	326 return action.actOnDeclStmt(parseVarDecl());
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	327
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	328 // 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	329 Exp exp = parseExpression();
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	330 require(Tok.Seperator);
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	331 return action.actOnExprStmt(exp);
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	332 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	333
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	334 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	335 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	336 return null;
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	337
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	338 default:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	339 if (t.isBasicType())
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	340 goto case Tok.Identifier;
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	341 if (t.type == Tok.Star)
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	342 {
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	343 auto exp = parseExpression();
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	344 require(Tok.Seperator);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	345 return action.actOnExprStmt(exp);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	346 }
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	347 messages.report(UnexpectedBeginStmt, lexer.peek.location).arg(lexer.next.getType);
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	348 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	349 }
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	350 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	351 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	352 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	353
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	354 Decl parseVarDecl()
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	355 {
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	356 // manually hardcoded to only support "type id [= exp];"
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	357 // 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	358 Id type = parseType;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	359 Id id = Id(lexer.next);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	360 Exp init;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	361 if (skip(Tok.Assign))
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	362 init = parseExpression();
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	363 require(Tok.Seperator);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	364 Decl d = action.actOnDeclarator(type, id, init);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	365 return d;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	366 }
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	367
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	368 /**
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	369 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	370 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	371 Decl parseFunc(ref Id type, ref Id name)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	372 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	373 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	374 parseFuncArgs(func);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	375
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	376 if(lexer.peek.type == Tok.Seperator)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	377 {
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	378 lexer.next;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	379 return func;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	380 }
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	381 Stmt stmt = parseCompoundStatement();
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	382
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	383 return action.actOnEndOfFunction(func, stmt);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	384 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	385
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	386 /**
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	387 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	388
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	389 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	390 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	391 void parseFuncArgs(Decl func)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	392 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	393 require(Tok.OpenParentheses); // Remove the "(" token.
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	394
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	395 while(lexer.peek.type != Tok.CloseParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	396 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	397 auto t = parseType();
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	398 Id i;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	399 if(lexer.peek.type == Tok.Identifier)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	400 i = parseIdentifier();
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	401 action.addFuncArg(func, t, i);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	402
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	403 if(lexer.peek.type == Tok.Comma)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	404 lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	405 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	406
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	407 require(Tok.CloseParentheses); // Remove the ")"
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	408 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	409
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	410 /**
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	411 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	412 and for.
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	413 */
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	414 Stmt parseSingleOrCompoundStatement()
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	415 {
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	416 if (lexer.peek.type == Tok.OpenBrace)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	417 return parseCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	418 return parseStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	419 }
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	420
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	421 /**
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	422 Parses a function-body or similar, expects an opening brace to be the
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	423 current token.
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	424
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	425 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	426 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	427 Stmt parseCompoundStatement()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	428 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	429 Token lbrace = require(Tok.OpenBrace);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	430 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	431 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	432 stmts ~= parseStatement();
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	433 Token rbrace = require(Tok.CloseBrace);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	434 return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe());
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	435 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	436
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	437 Id parseIdentifier()
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	438 {
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	439 Token tok = lexer.next;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	440
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	441 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	442 return Id(tok);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	443
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	444 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	445 .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	446 .arg(Tok.Identifier);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	447 }
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	448
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	449 ModuleName parseModuleName()
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	450 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	451 auto id = parseIdentifier();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	452 ModuleName mod;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	453 while (skip(Tok.Dot))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	454 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	455 mod.packages ~= id;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	456 if (lexer.peek.type != Tok.Identifier) {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	457 messages.report(ExpectedIdAfterPackage, lexer.peek.location);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	458 goto Lerror;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	459 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	460 id = parseIdentifier();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	461 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	462 mod.id = id;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	463 return mod;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	464 Lerror:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	465 while (!skip(Tok.Seperator))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	466 lexer.next();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	467 return mod;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	468 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	469
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	470
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	471 /**
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	472 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	473 */
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	474 Id parseType()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	475 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	476 Token type = lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	477
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	478 Id currentType;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	479
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	480 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	481 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	482
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	483 currentType = Id(type);
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	484 type = lexer.peek;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	485
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	486 while(type.type == Tok.Star \|\| type.type == Tok.OpenBracket)
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	487 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	488 if(type.type == Tok.Star)
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	489 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	490 currentType = PointerId(currentType);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	491 lexer.next;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	492 }
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	493 else
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	494 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	495 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	496 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	497 currentType = ArrayId(currentType, action.actOnNumericConstant(require(Tok.Integer)));
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	498 require(Tok.CloseBracket);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	499
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	500 }
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	501 type = lexer.peek;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	502 }
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	503
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	504 return currentType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	505 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	506
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	507 int peekParseType()
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	508 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	509 int i;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	510 Token type = lexer.peek(i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	511
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	512 Id currentType;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	513
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	514 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	515 return 0;
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	516
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	517 currentType = Id(type);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	518 type = lexer.peek(++i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	519
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	520 while(type.type == Tok.Star \|\| type.type == Tok.OpenBracket)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	521 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	522 if(type.type == Tok.Star)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	523 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	524 i++;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	525 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	526 else
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	527 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	528 if(lexer.peek(i++).type != Tok.OpenBracket)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	529 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	530 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	531 {
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	532 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	533 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	534 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	535 }
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	536 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	537 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	538 return 0;
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	539
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	540 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	541 type = lexer.peek(i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	542 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	543
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	544 return i;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	545 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	546
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	547 private:
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	548 // -- Expression parsing -- //
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	549 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	550 {
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	551 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	552 {
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	553 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	554 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	555 {
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	556 case Tok.Identifier:
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	557 Token op = lexer.next;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	558 Id member = Id(lexer.next);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	559 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	560 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	561 default:
30 3147a52d1247 Ooops.. should have compiled before commit.. now works again Anders Halager <halager@gmail.com> parents: 29 diff changeset	562 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	563 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	564 }
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	565 case Tok.OpenBracket:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	566 Token open = lexer.next;
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	567 Exp index = parseExpression();
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	568 Token close = require(Tok.CloseBracket);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	569 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	570 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	571 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	572 }
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	573 }
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	574
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	575 Exp parseExpression(int p = 0)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	576 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	577 auto exp = P();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	578 Token next = lexer.peek();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	579 BinOp* op = null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	580 while ((op = binary(next.type)) != null && op.prec >= p)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	581 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	582 lexer.next();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	583 int q = op.leftAssoc? 1 + op.prec : op.prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	584 auto exp2 = parseExpression(q);
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	585 exp = action.actOnBinaryOp(next.location, op.operator, exp, exp2);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	586 next = lexer.peek();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	587 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	588
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	589 return exp;
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 Exp P()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	593 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	594 Token next = lexer.next();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	595 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	596 return action.actOnUnaryOp(next, parseExpression(op.prec));
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	597 else if (next.type == Tok.OpenParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	598 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	599 auto e = parseExpression(0);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	600 require(Tok.CloseParentheses);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	601 return e;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	602 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	603 else if (next.type == Tok.Identifier)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	604 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	605 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	606 Exp iden = parsePostfixExp(value);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	607 switch(lexer.peek.type)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	608 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	609 case Tok.OpenParentheses:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	610 Token lp = lexer.next;
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	611 SmallArray!(Exp, 8) args;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	612 while(lexer.peek.type != Tok.CloseParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	613 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	614 if(lexer.peek.type == Tok.Comma)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	615 lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	616 args ~= parseExpression();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	617 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	618
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	619 Token rp = lexer.next();
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	620 return action.actOnCallExpr(iden, lp, args.unsafe(), rp);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	621
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	622 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	623 return iden;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	624 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	625 }
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	626 else if (next.type == Tok.Cast)
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	627 return parseCast(next);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	628 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	629 return action.actOnNumericConstant(next);
104 7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 102 diff changeset	630 else if (next.type == Tok.String)
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 102 diff changeset	631 return action.actOnStringExp(next);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	632
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	633 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	634 .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	635 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	636 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	637
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	638 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	639 {
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	640 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	641 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	642 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	643 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	644
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	645 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	646 auto exp = P();
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	647 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	648 }
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	649
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	650 struct UnOp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	651 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	652 Tok tokenType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	653 int prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	654 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	655
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	656 static const UnOp[] _unary =
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	657 [
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	658 {Tok.Minus, 4},
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	659 {Tok.Star, 4}
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	660 ];
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	661 UnOp* unary(Tok t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	662 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	663 foreach (ref op; _unary)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	664 if (op.tokenType == t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	665 return &op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	666 return null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	667 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	668
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	669 struct BinOp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	670 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	671 Tok tokenType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	672 int prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	673 bool leftAssoc;
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	674 Operator operator;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	675 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	676
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	677 static const BinOp[] _binary =
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	678 [
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	679 {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	680
116 0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	681 // =, += etc. 1
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	682 // (need special-case for the ternary operator at this level)
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	683 // \|\|, 2
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	684 // &&, 3
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	685 // \|, 4
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	686 // &, 5
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	687 // ^, 6
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	688 // ==, !=, is, !is, 7
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	689 // <, <= etc, 7
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	690 // in, 7
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	691 // <<, >>, >>>, 8
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	692 // +, -, ~, 9
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	693 // *, /, %, 10
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	694 // unary operators here
0cd8d6ab3f89 Add in the types for float and co. Anders Halager <halager@gmail.com> parents: 104 diff changeset	695
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	696 {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	697 {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	698
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	699 {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	700 {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	701 {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	702 {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	703
74 192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	704 {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	705 {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	706
74 192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	707 {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	708 {Tok.Slash, 5, true, Operator.Div},
123 6a5f745d351c Parsing <<, >> and >>>. Anders Johnsen <skabet@gmail.com> parents: 116 diff changeset	709 {Tok.Percent, 5, true, Operator.Mod},
6a5f745d351c Parsing <<, >> and >>>. Anders Johnsen <skabet@gmail.com> parents: 116 diff changeset	710
6a5f745d351c Parsing <<, >> and >>>. Anders Johnsen <skabet@gmail.com> parents: 116 diff changeset	711 {Tok.LeftShift, 8, true, Operator.LeftShift},
6a5f745d351c Parsing <<, >> and >>>. Anders Johnsen <skabet@gmail.com> parents: 116 diff changeset	712 {Tok.RightShift, 8, true, Operator.RightShift},
6a5f745d351c Parsing <<, >> and >>>. Anders Johnsen <skabet@gmail.com> parents: 116 diff changeset	713 {Tok.UnsignedRightShift, 8, true, Operator.UnsignedRightShift}
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	714 ];
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	715 BinOp* binary(Tok t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	716 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	717 foreach (ref op; _binary)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	718 if (op.tokenType == t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	719 return &op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	720 return null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	721 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	722
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	723 private:
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	724
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	725 Token require(Tok t)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	726 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	727 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	728 messages.report(UnexpectedTokSingle, lexer.peek.location)
29 41d23f2762c3 Merge, and updated Error class Anders Halager <halager@gmail.com> parents: 28 diff changeset	729 .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	730 .arg(t);
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	731 return lexer.next();
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	732 }
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	733
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	734 bool skip(Tok t)
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	735 {
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	736 if (lexer.peek().type != t)
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	737 return false;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	738 lexer.next();
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	739 return true;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	740 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	741
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	742 bool on_a(Tok t)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	743 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	744 return lexer.peek.type == t;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	745 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	746
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	747 Lexer lexer;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	748 SourceManager sm;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	749 }
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	750

Mercurial > projects > dang

annotate parser/Parser.d @ 123:6a5f745d351c