projects/dang: parser/Parser.d annotate

annotate parser/Parser.d @ 126:c3b24e7e8cf8

Carius changes to the parser. Parsing attributes, lexing many keywords(not all yet).

author	Anders Johnsen <skabet@gmail.com>
date	Tue, 27 May 2008 10:32:31 +0200
parents	6a5f745d351c
children	2be29b296081

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

Mercurial > projects > dang

annotate parser/Parser.d @ 126:c3b24e7e8cf8