projects/dang: ast/Exp.d annotate

annotate ast/Exp.d @ 104:7ff4bc2accf2 new_gen

Lexing more types of strings. Now all's left is to parse the string in the AST.

author	Anders Johnsen <skabet@gmail.com>
date	Wed, 21 May 2008 21:05:23 +0200
parents	7f9240d4ddc1
children	d1f68bfb58ae

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,
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: 98 diff changeset	28 StringExp,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	29 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	30
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	31 class Exp
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: 86 diff changeset	33 this(ExpType expType, SLoc loc)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	34 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	35 this.expType = expType;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	36 this.loc = loc;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	37 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	38
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	39 /// Get the type of the expression
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	40 DType type() { return null; }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	41
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	42 /// Indicates which type the expression is - to avoid a lot of casts
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	43 ExpType expType;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	44
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	45 /// The environment of the expression
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	46 Scope env;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	47
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	48 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	49
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	50 /**
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	51 The "main" location of the expression.
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	52 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	53 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	54 **/
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	55 SourceLocation loc;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	56
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	57 /// Return the starting location of this expression
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	58 SourceLocation startLoc() { return loc; }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	59
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	60 /// Get the full extents of the expression
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	61 SourceRange sourceRange() { return SourceRange(loc, loc + 1); }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	62
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	63 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	64 {
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 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	66 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	67 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	68
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	69 class CallExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	70 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	71 this(Exp exp, Exp[] args)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	72 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	73 super(ExpType.CallExp, exp.loc);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	74 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	75 this.args = args;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	76 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	77
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	78 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	79 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	80 DFunction f = cast(DFunction)exp.type();
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	81 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	82 return f.returnType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	83 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	84
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	85 Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	86 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	87 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	88
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	89 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	90 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	91 SourceRange res = exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	92 if (args.length > 0)
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	93 res = res + args[$ - 1].sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	94 return res;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	95 }
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	96
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 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	98 {
86 29f486ccc203 Fixed a bug that made arrays as params fail big time Anders Johnsen <skabet@gmail.com> parents: 85 diff changeset	99 if(auto t = type.asStruct)
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	100 {
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	101 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	102 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	103 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	104 return this;
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	105
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	106 auto call = cast(Identifier)exp;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	107 FuncDecl f = env.parentFunction;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	108 auto i = new Identifier("temp.var");
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	109 i.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	110 f.env.add(i);
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	111 f.env.find(i).setType(t);
62 78a6808b2e0f Added support for "%" - modulus / reminder Anders Johnsen <skabet@gmail.com> parents: 60 diff changeset	112 auto ty = new Identifier(t.name);
78a6808b2e0f Added support for "%" - modulus / reminder Anders Johnsen <skabet@gmail.com> parents: 60 diff changeset	113 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	114 Exp[] args;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	115 args ~= i;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	116 args ~= this.args;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	117 auto callExp = new CallExp(exp, args);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	118 callExp.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	119 var.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	120 auto stmtVar = new DeclStmt(var);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	121 auto stmtCall = new ExpStmt(callExp);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	122 Stmt[] stmts;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	123 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	124 {
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	125 if(stmtIndex == index)
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	126 {
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	127 stmts ~= stmtVar;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	128 stmts ~= stmtCall;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	129 }
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	130 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	131 }
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	132 f.statements = stmts;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	133 callExp.sret = true;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	134
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	135 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	136 }
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	137 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	138 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	139 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	140
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	141 class AssignExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	142 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	143 this(SLoc op, Exp identifier, Exp exp)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	144 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	145 super(ExpType.AssignExp, op);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	146 this.identifier = identifier;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	147 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	148 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	149
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	150 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	151 {
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 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	153 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	154
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 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	156 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	157
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	158 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	159 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	160 return identifier.sourceRange + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	161 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	162
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	163 override DType type() { return identifier.type(); }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	164
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	165 Exp identifier;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	166 Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	167 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	168
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	169 class BinaryExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	170 {
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	171 public enum Operator
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	172 {
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 44 diff changeset	173 Assign,
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 44 diff changeset	174
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	175 Eq, Ne,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	176
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	177 Lt, Le,
2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	178 Gt, Ge,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	179
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	180 Add, Sub,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	181 Mul, Div, Mod,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	182 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	183
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	184 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	185
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	186 this(SLoc op_loc, Operator op, Exp left, Exp right)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	187 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	188 super(ExpType.Binary, op_loc);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	189 this.op = op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	190 this.left = left;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	191 this.right = right;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	192 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	193
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	194 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	195 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	196 if (myType)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	197 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	198
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	199 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	200 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	201 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	202 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	203 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	204 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	205 {
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 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	207 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	208 }
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	209
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	210 DType l = left.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	211 DType r = right.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	212 if (l is r)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	213 myType = l;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	214 else if (l.hasImplicitConversionTo(r))
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	215 myType = r;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	216 else if (r.hasImplicitConversionTo(l))
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	217 myType = l;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	218 else
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	219 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	220 return myType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	221 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	222
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	223 override SLoc startLoc() { return left.startLoc(); }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	224
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	225 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	226 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	227 return left.sourceRange + right.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	228 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	229
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	230 char[] resultType()
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	231 {
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	232 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	233 return "bool";
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	234 return null;
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	235 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	236
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	237 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	238 {
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 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	240 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	241 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	242 }
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	243
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	244 Operator op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	245 Exp left, right;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	246 private DType myType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	247 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	248
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	249 class NegateExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	250 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	251 this(SLoc op, Exp exp)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	252 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	253 super(ExpType.Negate, op);
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	254 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	255 }
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	256
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	257 Exp simplify()
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	258 {
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	259 exp = exp.simplify;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	260 return this;
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
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	263 override DType type() { return exp.type(); }
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	264
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	265 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	266 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	267 return SourceRange(loc) + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	268 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	269
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	270 public Exp exp;
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
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	273 class DerefExp : Exp
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	274 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	275 this(SLoc op, Exp exp)
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	276 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	277 super(ExpType.Deref, op);
78 ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	278 this.exp = exp;
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	279 }
ad956143dcdc Parse and gen for dereferences Anders Halager <halager@gmail.com> parents: 72 diff changeset	280
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	281 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	282 {
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 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	284 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	285 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	286
80 682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	287 override DType type()
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	288 {
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	289 return exp.type().asPointer.pointerOf;
682e20aa224f Pointers working now - big YAY Anders Johnsen <skabet@gmail.com> parents: 79 diff changeset	290 }
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	291
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	292 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	293 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	294 return SourceRange(loc) + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	295 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	296
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	297 public Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	298 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	299
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	300 class IntegerLit : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	301 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	302 this(SLoc loc, char[] t)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	303 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	304 super(ExpType.IntegerLit, loc);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	305 range = SourceRange(loc, loc + t.length);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	306 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	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
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 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	310 {
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	311 return name;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	312 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	313
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	314 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	315 {
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 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	317 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	318
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	319 override DType type() { return DType.Int; }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	320
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	321 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	322 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	323 return range;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	324 }
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	325
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	326 char[] name;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	327 private SourceRange range;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	328 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	329
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 48 diff changeset	330 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	331 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	332 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	333 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	334 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	335 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	336 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	337 }
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	338
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	339 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	340 {
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 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	342 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	343 }
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	344
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	345 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	346 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	347 if (myType)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	348 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	349
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	350 DStruct st = cast(DStruct)target.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	351 assert(st, "Only structs have members");
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	352 if (auto t = st.typeOf(child.name))
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	353 myType = t;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	354 // no error reporting here
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	355 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	356
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	357 return myType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	358 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	359
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	360 override SLoc startLoc() { return target.startLoc(); }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	361
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	362 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	363 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	364 return target.sourceRange + child.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	365 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	366
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	367 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	368 Exp target;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	369 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	370 }
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	371
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	372 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	373 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	374 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	375 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	376 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	377 this.target = target;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	378 this.left_bracket = left_bracket;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	379 this.index = index;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	380 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	381 }
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	382
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	383 override DType type()
9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	384 {
85 9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	385 DType type = target.type();
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	386 if (type.isArray())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	387 return type.asArray().arrayOf;
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	388 else if (type.isPointer())
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	389 return type.asPointer().pointerOf;
9375bd975730 Allow indexing of pointers also Anders Halager <halager@gmail.com> parents: 83 diff changeset	390 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	391 }
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	392
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	393 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	394 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	395 return target.sourceRange + SourceRange(right_bracket);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	396 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	397
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	398 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	399 {
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	400 target = target.simplify;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	401 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	402 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	403 }
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	404
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	405 Exp target;
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	406 Exp index;
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	407 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	408 }
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	409
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	410 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	411 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	412 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	413 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	414 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	415 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	416 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	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
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 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	420 {
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 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	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
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 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	425 {
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 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	427 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	428 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	429 }
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	430
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	431 override SourceRange sourceRange()
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	432 {
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	433 return SourceRange(loc) + exp.sourceRange;
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	434 }
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	435
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	436 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	437 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	438 }
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	439
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: 98 diff changeset	440 class StringExp : Exp
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	441 {
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	442 this(SLoc loc, char[] str)
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	443 {
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	444 super(ExpType.StringExp, loc);
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	445 this.str = str;
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	446 }
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	447
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	448 char[] str;
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	449 }
7ff4bc2accf2 Lexing more types of strings. Now all's left is to parse the string in the AST. Anders Johnsen <skabet@gmail.com> parents: 98 diff changeset	450
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 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	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 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	454 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	455 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	456 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	457 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	458 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	459
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	460 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	461 {
83 9e90694f5da0 Parse array indexing, and allow reading from arrays Anders Halager <halager@gmail.com> parents: 81 diff changeset	462 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	463 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	464
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	465 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	466 }
13eea2c4e60d Now able of --ast-dump-code with Pointer types and also codeGen int* x; Anders Johnsen <skabet@gmail.com> parents: 72 diff changeset	467
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	468 class ArrayIdentifier : Identifier
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	469 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	470 this(Identifier arrayOf, IntegerLit size)
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	471 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	472 super(ExpType.ArrayIdentifier, arrayOf.loc);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	473 this.arrayOf = arrayOf;
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	474 this.size = Integer.parse(size.get);
110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	475 this.name = arrayOf.name;
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	476 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	477
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	478 override DType type()
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	479 {
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	480 return arrayOf.type.getAsArray(size);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	481 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	482
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	483 Identifier arrayOf;
81 110c7e1c4ca2 Now you can declare array Anders Johnsen <skabet@gmail.com> parents: 80 diff changeset	484 int size;
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	485
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	486 private DType myType;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	487 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	488
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	489 class Identifier : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	490 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	491 this(SLoc loc, char[] name)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	492 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	493 super(ExpType.Identifier, loc);
eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	494 this.name = name;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	495 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	496
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	497 protected this(ExpType t, SLoc loc)
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	498 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	499 super(t, loc);
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	500 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	501
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	502 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	503 {
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	504 if (myType !is null)
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	505 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	506 myType = env.find(this).type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	507 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	508 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	509
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	510 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	511 {
88 eb5b2c719a39 Major change to locations, tokens and expressions. Anders Halager <halager@gmail.com> parents: 86 diff changeset	512 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	513 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	514 }
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	515
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	516 char[] get()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	517 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	518 return name;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	519 }
96 438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	520
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	521 char[] getMangled()
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	522 {
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	523 DType t = type;
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	524
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	525 if(name == "main")
98 7f9240d4ddc1 Fixed tests - forgot some stuff in codegen. Anders Johnsen <skabet@gmail.com> parents: 96 diff changeset	526 return "main";
96 438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	527
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	528 return "_D"~name~t.mangle;
438e6ed4cda1 Now D-Mangling the function types. Still need to mangle "scopes" - by that i mean structs, classes and modules. Anders Johnsen <skabet@gmail.com> parents: 93 diff changeset	529 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	530
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	531 hash_t toHash()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	532 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	533 return jhash(name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	534 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	535
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	536 int opCmp(Object o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	537 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	538 if (auto id = cast(Identifier)o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	539 return typeid(char[]).compare(&name, &id.name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	540 return 0;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	541 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	542
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	543 int opEquals(Object o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	544 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	545 if (auto id = cast(Identifier)o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	546 return typeid(char[]).equals(&name, &id.name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	547 return 0;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	548 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	549
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	550 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	551 {
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	552 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	553 }
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	554
93 621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	555 void setType(DType myType)
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	556 {
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	557 this.myType = myType;
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	558 }
621cedba53ea Removed the Symbol from semantics - it was not needed anymore. From now on you set the type by doing a setType on an Identifier. Anders Johnsen <skabet@gmail.com> parents: 92 diff changeset	559
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	560 char[] name;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	561 private DType myType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	562 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	563

Mercurial > projects > dang

annotate ast/Exp.d @ 104:7ff4bc2accf2 new_gen