projects/dang: ast/Exp.d annotate

annotate ast/Exp.d @ 92:771ac63898e2 new_gen

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

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

rev	line source
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	1 module ast.Exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	2
67 3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 65 diff changeset	3 import tango.text.Util;
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	4 import tango.io.Stdout;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	5
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	6 import ast.Decl,
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	7 ast.Stmt;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	8
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	9 import lexer.Token;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	10
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: 88 diff changeset	11 import sema.Scope,
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	12 sema.DType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	13
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	14 enum ExpType
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	15 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	16 Binary,
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	17 Negate,
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	18 Deref,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	19 IntegerLit,
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 48 diff changeset	20 MemberReference,
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	21 Index,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	22 Identifier,
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	23 ArrayIdentifier,
77 13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	24 PointerIdentifier,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	25 AssignExp,
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	26 CallExp,
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: 67 diff changeset	27 CastExp,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	28 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	29
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	30 class Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	31 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	32 this(ExpType expType, SLoc loc)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	33 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	34 this.expType = expType;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	35 this.loc = loc;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	36 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	37
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	38 /// Get the type of the expression
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	39 DType type() { return null; }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	40
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	41 /// Indicates which type the expression is - to avoid a lot of casts
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	42 ExpType expType;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	43
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	44 /// The environment of the expression
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	45 Scope env;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	46
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	47 int stmtIndex;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	48
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	49 /**
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	50 The "main" location of the expression.
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	51 What exactly this represents varies but for most things its the start
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	52 while for a binary expression its the operator.
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	53 **/
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	54 SourceLocation loc;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	55
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	56 /// Return the starting location of this expression
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	57 SourceLocation startLoc() { return loc; }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	58
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	59 /// Get the full extents of the expression
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	60 SourceRange sourceRange() { return SourceRange(loc, loc + 1); }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	61
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	62 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	63 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	64 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	65 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	66 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	67
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	68 class CallExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	69 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	70 this(Exp exp, Exp[] args)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	71 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	72 super(ExpType.CallExp, exp.loc);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	73 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	74 this.args = args;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	75 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	76
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	77 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	78 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	79 DFunction f = cast(DFunction)exp.type();
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	80 assert(f !is null, "Can only call functions");
63 9f8131676242 Now Decl's have a DType type(), and should use varType and returnType to get the old type id Anders Halager <halager@gmail.com> parents: 60 diff changeset	81 return f.returnType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	82 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	83
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	84 Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	85 Exp[] args;
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	86 bool sret = false;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	87
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	88 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	89 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	90 SourceRange res = exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	91 if (args.length > 0)
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	92 res = res + args[$ - 1].sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	93 return res;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	94 }
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	95
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	96 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	97 {
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	98 if(auto t = type.asStruct)
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	99 {
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	100 DFunction func_t = cast(DFunction)exp.type();
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	101 assert(func_t !is null, "Calling on something that isn't a function");
63 9f8131676242 Now Decl's have a DType type(), and should use varType and returnType to get the old type id Anders Halager <halager@gmail.com> parents: 60 diff changeset	102 if (cast(DStruct)func_t.returnType is null)
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	103 return this;
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	104
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	105 auto call = cast(Identifier)exp;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	106 FuncDecl f = env.parentFunction;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	107 auto i = new Identifier("temp.var");
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	108 i.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	109 f.env.add(i);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	110 f.env.find(i).type = t;
62 78a6808b2e0f Added support for "%" - modulus / reminder Anders Johnsen <skabet@gmail.com> parents: 60 diff changeset	111 auto ty = new Identifier(t.name);
78a6808b2e0f Added support for "%" - modulus / reminder Anders Johnsen <skabet@gmail.com> parents: 60 diff changeset	112 auto var = new VarDecl(ty, i, null);
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	113 Exp[] args;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	114 args ~= i;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	115 args ~= this.args;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	116 auto callExp = new CallExp(exp, args);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	117 callExp.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	118 var.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	119 auto stmtVar = new DeclStmt(var);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	120 auto stmtCall = new ExpStmt(callExp);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	121 Stmt[] stmts;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	122 foreach( index, s ; f.statements)
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	123 {
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	124 if(stmtIndex == index)
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	125 {
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	126 stmts ~= stmtVar;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	127 stmts ~= stmtCall;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	128 }
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	129 stmts ~= s;
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	130 }
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	131 f.statements = stmts;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	132 callExp.sret = true;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	133
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	134 return i;
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	135 }
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	136 return this;
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	137 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	138 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	139
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	140 class AssignExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	141 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	142 this(SLoc op, Exp identifier, Exp exp)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	143 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	144 super(ExpType.AssignExp, op);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	145 this.identifier = identifier;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	146 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	147 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	148
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	149 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	150 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	151 identifier = identifier.simplify;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	152 exp = exp.simplify;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	153
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	154 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	155 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	156
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	157 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	158 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	159 return identifier.sourceRange + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	160 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	161
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	162 override DType type() { return identifier.type(); }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	163
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	164 Exp identifier;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	165 Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	166 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	167
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	168 class BinaryExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	169 {
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	170 public enum Operator
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	171 {
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 44 diff changeset	172 Assign,
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 44 diff changeset	173
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	174 Eq, Ne,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	175
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	176 Lt, Le,
2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	177 Gt, Ge,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	178
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	179 Add, Sub,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	180 Mul, Div, Mod,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	181 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	182
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: 67 diff changeset	183 char[][] getOp = ["=","==","!=","<","<=",">",">=","+","-","*","/","%"];
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: 67 diff changeset	184
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	185 this(SLoc op_loc, Operator op, Exp left, Exp right)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	186 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	187 super(ExpType.Binary, op_loc);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	188 this.op = op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	189 this.left = left;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	190 this.right = right;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	191 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	192
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	193 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	194 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	195 if (myType)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	196 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	197
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: 67 diff changeset	198 if (op == Operator.Eq \|\|
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: 67 diff changeset	199 op == Operator.Ne \|\|
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: 67 diff changeset	200 op == Operator.Lt \|\|
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: 67 diff changeset	201 op == Operator.Le \|\|
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: 67 diff changeset	202 op == Operator.Gt \|\|
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: 67 diff changeset	203 op == Operator.Ge)
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: 67 diff changeset	204 {
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: 67 diff changeset	205 myType = DType.Bool;
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: 67 diff changeset	206 return myType;
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: 67 diff changeset	207 }
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: 67 diff changeset	208
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	209 DType l = left.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	210 DType r = right.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	211 if (l is r)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	212 myType = l;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	213 else if (l.hasImplicitConversionTo(r))
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	214 myType = r;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	215 else if (r.hasImplicitConversionTo(l))
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	216 myType = l;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	217 else
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	218 return null;
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: 67 diff changeset	219 return myType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	220 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	221
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	222 override SLoc startLoc() { return left.startLoc(); }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	223
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	224 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	225 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	226 return left.sourceRange + right.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	227 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	228
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	229 char[] resultType()
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	230 {
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	231 if (op >= Operator.Eq && op <= Operator.Ge)
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	232 return "bool";
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	233 return null;
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	234 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	235
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	236 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	237 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	238 left = left.simplify;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	239 right = right.simplify;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	240 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	241 }
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	242
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	243 Operator op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	244 Exp left, right;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	245 private DType myType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	246 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	247
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	248 class NegateExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	249 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	250 this(SLoc op, Exp exp)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	251 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	252 super(ExpType.Negate, op);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	253 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	254 }
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	255
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	256 Exp simplify()
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	257 {
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	258 exp = exp.simplify;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	259 return this;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	260 }
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	261
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	262 override DType type() { return exp.type(); }
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	263
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	264 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	265 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	266 return SourceRange(loc) + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	267 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	268
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	269 public Exp exp;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	270 }
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	271
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	272 class DerefExp : Exp
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	273 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	274 this(SLoc op, Exp exp)
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	275 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	276 super(ExpType.Deref, op);
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	277 this.exp = exp;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	278 }
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	279
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	280 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	281 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	282 exp = exp.simplify;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	283 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	284 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	285
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	286 override DType type()
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	287 {
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	288 return exp.type().asPointer.pointerOf;
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	289 }
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	290
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	291 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	292 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	293 return SourceRange(loc) + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	294 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	295
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	296 public Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	297 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	298
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	299 class IntegerLit : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	300 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	301 this(SLoc loc, char[] t)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	302 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	303 super(ExpType.IntegerLit, loc);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	304 range = SourceRange(loc, loc + t.length);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	305 this.name = substitute(t, "_", "");
67 3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 65 diff changeset	306 }
3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 65 diff changeset	307
3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 65 diff changeset	308 char[] get()
3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 65 diff changeset	309 {
3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 65 diff changeset	310 return name;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	311 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	312
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	313 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	314 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	315 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	316 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	317
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	318 override DType type() { return DType.Int; }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	319
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	320 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	321 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	322 return range;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	323 }
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: 67 diff changeset	324
67 3fdf20b08a81 Been working on the floating point parsing. Still a bit of work to do here. Anders Johnsen <skabet@gmail.com> parents: 65 diff changeset	325 char[] name;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	326 private SourceRange range;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	327 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	328
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 48 diff changeset	329 class MemberReference : Exp
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	330 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	331 this(SLoc dot, Exp target, Identifier child)
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	332 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	333 super(ExpType.MemberReference, dot);
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	334 this.target = target;
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	335 this.child = child;
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	336 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	337
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	338 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	339 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	340 target = target.simplify;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	341 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	342 }
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	343
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	344 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	345 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	346 if (myType)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	347 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	348
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	349 DStruct st = cast(DStruct)target.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	350 assert(st, "Only structs have members");
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	351 if (auto t = st.typeOf(child.name))
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	352 myType = t;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	353 // no error reporting here
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	354 else assert(0, "Referencing non-existant member");
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: 67 diff changeset	355
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: 67 diff changeset	356 return myType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	357 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	358
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	359 override SLoc startLoc() { return target.startLoc(); }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	360
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	361 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	362 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	363 return target.sourceRange + child.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	364 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	365
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	366 Identifier child;
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	367 Exp target;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	368 private DType myType;
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	369 }
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	370
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	371 class IndexExp : Exp
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	372 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	373 this(Exp target, SLoc left_bracket, Exp index, SLoc right_bracket)
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	374 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	375 super(ExpType.Index, target.startLoc);
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	376 this.target = target;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	377 this.left_bracket = left_bracket;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	378 this.index = index;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	379 this.right_bracket = right_bracket;
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	380 }
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	381
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	382 override DType type()
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	383 {
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	384 DType type = target.type();
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	385 if (type.isArray())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	386 return type.asArray().arrayOf;
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	387 else if (type.isPointer())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	388 return type.asPointer().pointerOf;
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	389 else assert(0, "Can only index pointers and arrays");
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	390 }
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	391
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	392 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	393 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	394 return target.sourceRange + SourceRange(right_bracket);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	395 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	396
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	397 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	398 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	399 target = target.simplify;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	400 index = index.simplify;
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	401 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	402 }
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	403
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	404 Exp target;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	405 Exp index;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	406 SLoc left_bracket, right_bracket;
28 69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	407 }
69464d465284 Now supporting structs - both read and write. Still a few errors though, so watch out. Anders Johnsen <skabet@gmail.com> parents: 10 diff changeset	408
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: 67 diff changeset	409 class CastExp : Exp
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: 67 diff changeset	410 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	411 this(SLoc loc, Identifier castType, Exp 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: 67 diff changeset	412 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	413 super(ExpType.CastExp, loc);
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: 67 diff changeset	414 this.castType = castType;
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: 67 diff changeset	415 this.exp = exp;
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: 67 diff changeset	416 }
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: 67 diff changeset	417
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: 67 diff changeset	418 override DType type()
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: 67 diff changeset	419 {
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: 67 diff changeset	420 return env.findType(this.castType);
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: 67 diff changeset	421 }
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: 67 diff changeset	422
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: 67 diff changeset	423 Exp simplify()
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: 67 diff changeset	424 {
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: 67 diff changeset	425 castType.simplify;
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: 67 diff changeset	426 exp.simplify;
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: 67 diff changeset	427 return this;
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: 67 diff changeset	428 }
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: 67 diff changeset	429
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	430 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	431 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	432 return SourceRange(loc) + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	433 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	434
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: 67 diff changeset	435 Identifier castType;
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: 67 diff changeset	436 Exp exp;
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: 67 diff changeset	437 }
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: 67 diff changeset	438
77 13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	439 class PointerIdentifier : Identifier
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	440 {
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	441 this(Identifier pointerOf)
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	442 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	443 super(ExpType.PointerIdentifier, pointerOf.loc);
77 13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	444 this.pointerOf = pointerOf;
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	445 this.name = pointerOf.name;
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	446 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	447
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	448 override DType type()
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	449 {
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	450 return pointerOf.type.getPointerTo();
77 13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	451 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	452
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	453 Identifier pointerOf;
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	454 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	455
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	456 class ArrayIdentifier : Identifier
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	457 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	458 this(Identifier arrayOf, IntegerLit size)
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	459 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	460 super(ExpType.ArrayIdentifier, arrayOf.loc);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	461 this.arrayOf = arrayOf;
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	462 this.size = Integer.parse(size.get);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	463 this.name = arrayOf.name;
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	464 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	465
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	466 override DType type()
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	467 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	468 return arrayOf.type.getAsArray(size);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	469 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	470
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	471 Identifier arrayOf;
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	472 int size;
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	473
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	474 private DType myType;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	475 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	476
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	477 class Identifier : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	478 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	479 this(SLoc loc, char[] name)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	480 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	481 super(ExpType.Identifier, loc);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	482 this.name = name;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	483 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	484
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	485 protected this(ExpType t, SLoc loc)
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	486 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	487 super(t, loc);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	488 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	489
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	490 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	491 {
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	492 if (myType !is null)
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	493 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	494 myType = env.find(this).type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	495 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	496 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	497
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	498 this(char[] name)
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	499 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	500 super(ExpType.Identifier, SLoc.Invalid);
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	501 this.name = name;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	502 }
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	503
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	504 char[] get()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	505 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	506 return name;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	507 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	508
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	509 hash_t toHash()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	510 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	511 return jhash(name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	512 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	513
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	514 int opCmp(Object o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	515 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	516 if (auto id = cast(Identifier)o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	517 return typeid(char[]).compare(&name, &id.name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	518 return 0;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	519 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	520
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	521 int opEquals(Object o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	522 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	523 if (auto id = cast(Identifier)o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	524 return typeid(char[]).equals(&name, &id.name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	525 return 0;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	526 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	527
56 4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	528 Exp simplify()
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	529 {
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	530 return this;
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	531 }
4ae365eff712 Now return types works for structs... Also, simplyfing in AST have been startet - but still messy. This update is a little messy... Anders Johnsen <skabet@gmail.com> parents: 55 diff changeset	532
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	533 char[] name;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	534 private DType myType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	535 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	536

Mercurial > projects > dang

annotate ast/Exp.d @ 92:771ac63898e2 new_gen