projects/dang: parser/Parser.d annotate

annotate parser/Parser.d @ 99:857f0d530789 new_gen

Imports and improved module statement Allow "module a.b.c" Supports most forms of D's import. import A, B; import A, B = C; import A, B : a = b, c;

author	Anders Halager <halager@gmail.com>
date	Tue, 06 May 2008 21:59:22 +0200
parents	48bb2287c035
children	5f258eaf9517

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();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	185 default:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	186 goto Lerror;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	187 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	188 res ~= action.actOnImport(_import, mod, null);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	189 }
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 require(Tok.Seperator);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	192 return res.safe();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	193 Lerror:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	194 while (!on_a (Tok.Seperator))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	195 lexer.next();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	196 return res.safe();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	197 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	198
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	199 /**
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	200 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	201 */
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	202 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	203 {
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 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	205
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 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	207
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 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	209 {
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 Id var_type = Id(lexer.next);
da551f90e03f Added struct decl and forward ref. A note on structs: they need to make a new scope when declared. Otherwise you could access struct members as globals Anders Johnsen <skabet@gmail.com> parents: 51 diff changeset	211 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	212 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	213 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	214 {
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	215 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	216 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	217 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	218 }
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 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	220 {
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 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	222 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	223 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	224 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	225 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	226 }
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	227 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	228 }
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
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 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	231
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	232 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	233 }
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	234
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	235 /**
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	236 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	237
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	238 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	239 */
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	240 Stmt parseStatement()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	241 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	242 Token t = lexer.peek;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	243
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	244 switch(t.type)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	245 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	246 case Tok.Return:
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	247 Token ret = lexer.next;
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	248 Exp exp;
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	249 if (lexer.peek.type != Tok.Seperator)
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	250 exp = parseExpression();
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	251 require(Tok.Seperator);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	252 return action.actOnReturnStmt(ret, exp);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	253
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	254 /*
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	255 if (cond)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	256 single statement \| compound statement
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	257 [else
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	258 single statement \| compound statement]
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	259 */
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	260 case Tok.If:
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	261 Token _if = lexer.next();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	262
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	263 require(Tok.OpenParentheses);
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	264 Exp cond = parseExpression();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	265 require(Tok.CloseParentheses);
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	266
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	267 Stmt thenB = parseSingleOrCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	268
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	269 // 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	270 // something than can be passed along
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	271 Token _else = _if;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	272 Stmt elseB;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	273 if (lexer.peek.type == Tok.Else)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	274 {
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	275 _else = lexer.next;
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	276 elseB = parseSingleOrCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	277 }
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	278
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	279 return action.actOnIfStmt(_if, cond, thenB, _else, elseB);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	280
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	281 /*
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	282 while (cond)
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	283 single statement \| compound statement
b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	284 */
11 642c6a998fd9 Support for while statements and fixed scope for if Anders Halager <halager@gmail.com> parents: 10 diff changeset	285 case Tok.While:
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	286 Token _while = lexer.next;
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	287 require(Tok.OpenParentheses);
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	288 Exp cond = parseExpression();
47 b0a691727a0c Stricter while - the () was optional before Anders Halager <halager@gmail.com> parents: 46 diff changeset	289 require(Tok.CloseParentheses);
46 90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	290 Stmt bodyStmt = parseSingleOrCompoundStatement();
90fb4fdfefdd While is back Anders Halager <halager@gmail.com> parents: 45 diff changeset	291 return action.actOnWhileStmt(_while, cond, bodyStmt);
5 2c5a8f4c254a Added very simple if support. Anders Halager <halager@gmail.com> parents: 1 diff changeset	292
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	293 /*
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	294 One of four things:
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	295 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	296 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	297 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	298 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	299
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	300 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	301 */
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	302 case Tok.Identifier:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	303 Token iden = lexer.peek;
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	304 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	305 // 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	306 // identifiers in a row
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	307 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	308 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	309 if ( n.type == Tok.Star \|\| n.type == Tok.OpenBracket)
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	310 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	311 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	312 if(lexer.peek(len).type == Tok.Identifier && len != 0)
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	313 return action.actOnDeclStmt(parseVarDecl());
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	314
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	315 Exp exp = parseExpression();
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	316 require(Tok.Seperator);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	317 return action.actOnExprStmt(exp);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	318 }
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	319
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	320 if (n.isIdentifier())
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	321 return action.actOnDeclStmt(parseVarDecl());
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	322
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	323 // 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	324 Exp exp = parseExpression();
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	325 require(Tok.Seperator);
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	326 return action.actOnExprStmt(exp);
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	327 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	328
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	329 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	330 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	331 return null;
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	332
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	333 default:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	334 if (t.isBasicType())
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	335 goto case Tok.Identifier;
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	336 if (t.type == Tok.Star)
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	337 {
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	338 auto exp = parseExpression();
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	339 require(Tok.Seperator);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	340 return action.actOnExprStmt(exp);
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 78 diff changeset	341 }
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	342 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	343 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	344 }
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	345 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	346 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	347 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	348
76 9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	349 Decl parseVarDecl()
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	350 {
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	351 // manually hardcoded to only support "type id [= exp];"
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	352 // 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	353 Id type = parseType;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	354 Id id = Id(lexer.next);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	355 Exp init;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	356 if (skip(Tok.Assign))
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	357 init = parseExpression();
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	358 require(Tok.Seperator);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	359 Decl d = action.actOnDeclarator(type, id, init);
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	360 return d;
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	361 }
9171f04dd9ee Now parsing varDecls a lot nicer! Anders Johnsen <skabet@gmail.com> parents: 75 diff changeset	362
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	363 /**
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	364 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	365 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	366 Decl parseFunc(ref Id type, ref Id name)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	367 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	368 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	369 parseFuncArgs(func);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	370
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	371 if(lexer.peek.type == Tok.Seperator)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	372 {
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	373 lexer.next;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	374 return func;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	375 }
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	376 Stmt stmt = parseCompoundStatement();
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	377
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	378 return action.actOnEndOfFunction(func, stmt);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	379 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	380
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	381 /**
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	382 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	383
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	384 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	385 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	386 void parseFuncArgs(Decl func)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	387 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	388 require(Tok.OpenParentheses); // Remove the "(" token.
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	389
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	390 while(lexer.peek.type != Tok.CloseParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	391 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	392 auto t = parseType();
82 06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	393 Id i;
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	394 if(lexer.peek.type == Tok.Identifier)
06dda301ea61 Can declare outside functions and call c-functions Anders Johnsen <skabet@gmail.com> parents: 81 diff changeset	395 i = parseIdentifier();
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	396 action.addFuncArg(func, t, i);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	397
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	398 if(lexer.peek.type == Tok.Comma)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	399 lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	400 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	401
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	402 require(Tok.CloseParentheses); // Remove the ")"
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	403 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	404
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	405 /**
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	406 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	407 and for.
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	408 */
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	409 Stmt parseSingleOrCompoundStatement()
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	410 {
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	411 if (lexer.peek.type == Tok.OpenBrace)
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	412 return parseCompoundStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	413 return parseStatement();
9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	414 }
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	415
45 9bc660cbdbec If statements are back Anders Halager <halager@gmail.com> parents: 44 diff changeset	416 /**
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	417 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	418 current token.
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	419
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	420 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	421 */
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	422 Stmt parseCompoundStatement()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	423 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	424 Token lbrace = require(Tok.OpenBrace);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	425 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	426 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	427 stmts ~= parseStatement();
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	428 Token rbrace = require(Tok.CloseBrace);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	429 return action.actOnCompoundStmt(lbrace, rbrace, stmts.unsafe());
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	430 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	431
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	432 Id parseIdentifier()
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	433 {
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	434 Token tok = lexer.next;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	435
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	436 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	437 return Id(tok);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	438
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	439 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	440 .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	441 .arg(Tok.Identifier);
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	442 }
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	443
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	444 ModuleName parseModuleName()
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	445 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	446 auto id = parseIdentifier();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	447 ModuleName mod;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	448 while (skip(Tok.Dot))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	449 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	450 mod.packages ~= id;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	451 if (lexer.peek.type != Tok.Identifier) {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	452 messages.report(ExpectedIdAfterPackage, lexer.peek.location);
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	453 goto Lerror;
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 id = parseIdentifier();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	456 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	457 mod.id = id;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	458 return mod;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	459 Lerror:
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	460 while (!skip(Tok.Seperator))
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	461 lexer.next();
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	462 return mod;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	463 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	464
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	465
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	466 /**
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	467 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	468 */
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	469 Id parseType()
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	470 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	471 Token type = lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	472
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	473 Id currentType;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	474
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	475 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	476 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	477
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	478 currentType = Id(type);
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	479 type = lexer.peek;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	480
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	481 while(type.type == Tok.Star \|\| type.type == Tok.OpenBracket)
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	482 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	483 if(type.type == Tok.Star)
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	484 {
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	485 currentType = PointerId(currentType);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	486 lexer.next;
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	487 }
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	488 else
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 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	491 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	492 currentType = ArrayId(currentType, action.actOnNumericConstant(require(Tok.Integer)));
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	493 require(Tok.CloseBracket);
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 }
75 86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	496 type = lexer.peek;
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	497 }
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	498
86aec2160221 Parsing "int* x" Anders Johnsen <skabet@gmail.com> parents: 74 diff changeset	499 return currentType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	500 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	501
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	502 int peekParseType()
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	503 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	504 int i;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	505 Token type = lexer.peek(i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	506
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	507 Id currentType;
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 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	510 return 0;
84 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 currentType = Id(type);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	513 type = lexer.peek(++i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	514
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	515 while(type.type == Tok.Star \|\| type.type == Tok.OpenBracket)
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 if(type.type == Tok.Star)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	518 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	519 i++;
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	520 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	521 else
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	522 {
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	523 if(lexer.peek(i++).type != Tok.OpenBracket)
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	524 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	525 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	526 {
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	527 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	528 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	529 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	530 }
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 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	532 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	533 return 0;
84 cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	534
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	535 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	536 type = lexer.peek(i);
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	537 }
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	538
cc05c041e6a3 Assign stuff to arrays. Anders Johnsen <skabet@gmail.com> parents: 83 diff changeset	539 return i;
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
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	542 private:
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	543 // -- Expression parsing -- //
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	544 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	545 {
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	546 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	547 {
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	548 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	549 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	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 case Tok.Identifier:
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	552 Token op = lexer.next;
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	553 Id member = Id(lexer.next);
495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	554 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	555 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	556 default:
30 3147a52d1247 Ooops.. should have compiled before commit.. now works again Anders Halager <halager@gmail.com> parents: 29 diff changeset	557 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	558 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	559 }
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	560 case Tok.OpenBracket:
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	561 Token open = lexer.next;
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	562 Exp index = parseExpression();
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	563 Token close = require(Tok.CloseBracket);
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 82 diff changeset	564 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	565 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	566 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	567 }
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	568 }
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	569
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	570 Exp parseExpression(int p = 0)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	571 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	572 auto exp = P();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	573 Token next = lexer.peek();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	574 BinOp* op = null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	575 while ((op = binary(next.type)) != null && op.prec >= p)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	576 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	577 lexer.next();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	578 int q = op.leftAssoc? 1 + op.prec : op.prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	579 auto exp2 = parseExpression(q);
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	580 exp = action.actOnBinaryOp(next.location, op.operator, exp, exp2);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	581 next = lexer.peek();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	582 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	583
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	584 return exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	585 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	586
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	587 Exp P()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	588 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	589 Token next = lexer.next();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	590 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	591 return action.actOnUnaryOp(next, parseExpression(op.prec));
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	592 else if (next.type == Tok.OpenParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	593 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	594 auto e = parseExpression(0);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	595 require(Tok.CloseParentheses);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	596 return e;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	597 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	598 else if (next.type == Tok.Identifier)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	599 {
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	600 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	601 Exp iden = parsePostfixExp(value);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	602 switch(lexer.peek.type)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	603 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	604 case Tok.OpenParentheses:
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	605 Token lp = lexer.next;
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	606 SmallArray!(Exp, 8) args;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	607 while(lexer.peek.type != Tok.CloseParentheses)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	608 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	609 if(lexer.peek.type == Tok.Comma)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	610 lexer.next;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	611 args ~= parseExpression();
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	612 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	613
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	614 Token rp = lexer.next();
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	615 return action.actOnCallExpr(iden, lp, args.unsafe(), rp);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	616
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	617 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	618 return iden;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	619 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	620 }
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	621 else if (next.type == Tok.Cast)
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	622 return parseCast(next);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	623 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	624 return action.actOnNumericConstant(next);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	625
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	626 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	627 .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	628 return null;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	629 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	630
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	631 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	632 {
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	633 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	634 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	635 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	636 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	637
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	638 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	639 auto exp = P();
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	640 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	641 }
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
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	643 struct UnOp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	644 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	645 Tok tokenType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	646 int prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	647 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	648
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	649 static const UnOp[] _unary =
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	650 [
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	651 {Tok.Minus, 4},
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	652 {Tok.Star, 4}
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 76 diff changeset	653 ];
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	654 UnOp* unary(Tok t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	655 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	656 foreach (ref op; _unary)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	657 if (op.tokenType == t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	658 return &op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	659 return null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	660 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	661
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	662 struct BinOp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	663 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	664 Tok tokenType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	665 int prec;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	666 bool leftAssoc;
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	667 Operator operator;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	668 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	669
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	670 static const BinOp[] _binary =
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	671 [
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 47 diff changeset	672 {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	673
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	674 {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	675 {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	676
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 37 diff changeset	677 {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	678 {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	679 {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	680 {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	681
74 192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	682 {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	683 {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	684
74 192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	685 {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	686 {Tok.Slash, 5, true, Operator.Div},
192da4976daa Renamed Add, Sub, Mul, Div and Mod in lexer to what they are (Plus, Minus....) johnsen@johnsen-laptop parents: 71 diff changeset	687 {Tok.Percent, 5, true, Operator.Mod}
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	688 ];
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	689 BinOp* binary(Tok t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	690 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	691 foreach (ref op; _binary)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	692 if (op.tokenType == t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	693 return &op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	694 return null;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	695 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	696
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	697 private:
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	698
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	699 Token require(Tok t)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	700 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	701 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	702 messages.report(UnexpectedTokSingle, lexer.peek.location)
29 41d23f2762c3 Merge, and updated Error class Anders Halager <halager@gmail.com> parents: 28 diff changeset	703 .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	704 .arg(t);
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	705 return lexer.next();
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	706 }
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	707
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	708 bool skip(Tok t)
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	709 {
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	710 if (lexer.peek().type != t)
ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	711 return false;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	712 lexer.next();
36 ce17bea8e9bd Switch statements support Anders Halager <halager@gmail.com> parents: 33 diff changeset	713 return true;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	714 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	715
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	716 bool on_a(Tok t)
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	717 {
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	718 return lexer.peek.type == t;
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	719 }
857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	720
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	721 Lexer lexer;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 84 diff changeset	722 SourceManager sm;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	723 }
99 857f0d530789 Imports and improved module statement Anders Halager <halager@gmail.com> parents: 94 diff changeset	724

Mercurial > projects > dang

annotate parser/Parser.d @ 99:857f0d530789 new_gen