projects/dang: ast/Exp.d annotate

annotate ast/Exp.d @ 72:628cb46ab13b new_gen

First update on the way to Arrays! :) Lexer and ast/Exp now have the types needed. All that needs to be updated now is the Parser. I suggest two options: 1) Making the Id a class that we can make a ArrayId and PointerId for at some point. 2) Use a struct as now, but adding some bools / ints to give a more abstract description of the type 2) is messy and 1) is slower... :/

author	Anders Johnsen <skabet@gmail.com>
date	Thu, 01 May 2008 23:08:41 +0200
parents	381975d76baf
children	13eea2c4e60d ad956143dcdc

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
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	11 import sema.SymbolTable,
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,
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	18 IntegerLit,
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 48 diff changeset	19 MemberReference,
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	20 ArrayReference,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	21 Identifier,
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	22 ArrayIdentifier,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	23 AssignExp,
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	24 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	25 CastExp,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	26 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	27
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	28 class Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	29 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	30 this(ExpType expType)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	31 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	32 this.expType = expType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	33 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	34
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	35 DType type() { return null; }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	36
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	37 ExpType expType;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	38 Scope env;
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	39 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	40
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	41 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	42 {
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	43 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	44 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	45 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	46
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	47 class CallExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	48 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	49 this(Exp exp, Exp[] args)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	50 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	51 super(ExpType.CallExp);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	52 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	53 this.args = args;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	54 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	55
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	56 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	57 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	58 DFunction f = cast(DFunction)exp.type();
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	59 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	60 return f.returnType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	61 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	62
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	63 Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	64 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	65 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	66
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	67
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	68 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	69 {
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	70 if(auto t = cast(DStruct)type)
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	71 {
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	72 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	73 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	74 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	75 return this;
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	76
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	77 auto call = cast(Identifier)exp;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	78 FuncDecl f = env.parentFunction;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	79 auto i = new Identifier("temp.var");
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	80 i.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	81 f.env.add(i);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	82 f.env.find(i).type = t;
62 78a6808b2e0f Added support for "%" - modulus / reminder Anders Johnsen <skabet@gmail.com> parents: 60 diff changeset	83 auto ty = new Identifier(t.name);
78a6808b2e0f Added support for "%" - modulus / reminder Anders Johnsen <skabet@gmail.com> parents: 60 diff changeset	84 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	85 Exp[] args;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	86 args ~= i;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	87 args ~= this.args;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	88 auto callExp = new CallExp(exp, args);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	89 callExp.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	90 var.env = f.env;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	91 auto stmtVar = new DeclStmt(var);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	92 auto stmtCall = new ExpStmt(callExp);
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	93 Stmt[] stmts;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	94 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	95 {
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	96 if(stmtIndex == index)
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	97 {
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	98 stmts ~= stmtVar;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	99 stmts ~= stmtCall;
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 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	102 }
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	103 f.statements = stmts;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	104 callExp.sret = true;
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	105
2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	106 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	107 }
60 2451f0904bf6 Dumping Ast with AstPrinter is now possible again! :) Anders Johnsen <skabet@gmail.com> parents: 59 diff changeset	108 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	109 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	110 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	111
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	112 class AssignExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	113 {
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	114 this(Exp identifier, Exp exp)
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	115 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	116 super(ExpType.AssignExp);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	117 this.identifier = identifier;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	118 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	119 }
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	120 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	121 {
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	122 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	123 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	124
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	125 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	126 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	127
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	128 override DType type() { return identifier.type(); }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	129
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	130 Exp identifier;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	131 Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	132 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	133
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	134 class BinaryExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	135 {
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	136 public enum Operator
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	137 {
48 b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 44 diff changeset	138 Assign,
b6c1dc30ca4b Only tests that dont pass now are structs and switches Anders Halager <halager@gmail.com> parents: 44 diff changeset	139
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	140 Eq, Ne,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	141
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	142 Lt, Le,
2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	143 Gt, Ge,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	144
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	145 Add, Sub,
44 495188f9078e Big update - Moving towards a better, more seperated parser Anders Halager <halager@gmail.com> parents: 28 diff changeset	146 Mul, Div, Mod,
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	147 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	148
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	149 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	150
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	151 this(Operator op, Exp left, Exp right)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	152 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	153 super(ExpType.Binary);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	154 this.op = op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	155 this.left = left;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	156 this.right = right;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	157 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	158
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	159 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	160 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	161 if (myType)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	162 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	163
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	164 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	165 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	166 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	167 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	168 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	169 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	170 {
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	171 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	172 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	173 }
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	174
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	175 DType l = left.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	176 DType r = right.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	177 if (l is r)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	178 myType = l;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	179 else if (l.hasImplicitConversionTo(r))
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	180 myType = r;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	181 else if (r.hasImplicitConversionTo(l))
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	182 myType = l;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	183 else
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	184 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	185 return myType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	186 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	187
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	188 char[] resultType()
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	189 {
10 2f493057cf17 Some support for the rest of the boolean operators Anders Halager <halager@gmail.com> parents: 7 diff changeset	190 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	191 return "bool";
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	192 return null;
2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	193 }
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	194 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	195 {
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	196 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	197 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	198 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	199 }
7 2ce5209f1954 Starting to work on bool support, for now == works Anders Halager <halager@gmail.com> parents: 1 diff changeset	200
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	201 Operator op;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	202 Exp left, right;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	203 private DType myType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	204 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	205
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	206 class NegateExp : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	207 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	208 this(Exp exp)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	209 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	210 super(ExpType.Negate);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	211 this.exp = exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	212 }
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	213 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	214 {
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	215 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	216 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	217 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	218
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	219 override DType type() { return exp.type(); }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	220
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	221 public Exp exp;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	222 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	223
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	224 class IntegerLit : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	225 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	226 this(Token t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	227 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	228 super(ExpType.IntegerLit);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	229 this.token = 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	230 this.name = substitute(t.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	231 }
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	232
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	233 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	234 {
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	235 return name;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: 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 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	240 }
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	241
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	242 override DType type() { return DType.Int; }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	243
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	244
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	245
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	246 Token token;
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	247 char[] name;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	248 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	249
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 48 diff changeset	250 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	251 {
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	252 this(Exp target, 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	253 {
55 79cb0afafabe Now structs are somewhat useable to use. Anders Johnsen <skabet@gmail.com> parents: 48 diff changeset	254 super(ExpType.MemberReference);
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	255 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	256 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	257 }
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	258 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	259 {
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	260 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	261 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	262 }
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	263
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	264 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	265 {
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	266 if (myType)
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	267 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	268
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	269 DStruct st = cast(DStruct)target.type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	270 assert(st, "Only structs have members");
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	271 if (auto t = st.typeOf(child.token.get))
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	272 myType = t;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	273 // no error reporting here
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	274 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	275
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	276 return myType;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	277 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	278
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	279 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	280 Exp target;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	281 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	282 }
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	283
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	284 class ArrayReference : 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	285 {
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	286 this(Exp target, IntegerLit pos)
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	287 {
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	288 super(ExpType.ArrayReference);
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	289 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	290 this.pos = pos;
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	291 }
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	292
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	293 override DType type() { return target.type(); }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	294
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	295 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	296 {
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	297 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	298 pos.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	299 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	300 }
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	301
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	302 Exp 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	303 IntegerLit pos;
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	304 }
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	305
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	306 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	307 {
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	308 this(Identifier castType, 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	309 {
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	310 super(ExpType.CastExp);
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	311 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	312 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	313 }
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	314
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	315 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	316 {
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	317 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	318 }
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	319
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	320 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	321 {
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	322 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	323 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	324 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	325 }
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	326
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	327 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	328 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	329 }
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	330
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	331 class ArrayIdentifier : Identifier
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	332 {
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	333 this(Identifier arrayOf)
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	334 {
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	335 super(ExpType.ArrayIdentifier);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	336 this.arrayOf = arrayOf;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	337 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	338
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	339 override DType type()
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	340 {
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	341 if (myType !is null)
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	342 return myType;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	343 myType = new DArray(arrayOf.type);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	344 return myType;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	345 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	346
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	347 Identifier arrayOf;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	348
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	349 private DType myType;
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	350 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	351
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	352 class Identifier : Exp
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	353 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	354 this(Token t)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	355 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	356 super(ExpType.Identifier);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	357 this.token = t;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	358 name = t.get;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	359 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	360
72 628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	361 protected this(ExpType t)
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	362 {
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	363 super(t);
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	364 }
628cb46ab13b First update on the way to Arrays! :) Anders Johnsen <skabet@gmail.com> parents: 68 diff changeset	365
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	366 override DType type()
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	367 {
59 1d6f4ad38a91 Make most of the tests pass again Anders Halager <halager@gmail.com> parents: 58 diff changeset	368 if (myType !is null)
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	369 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	370 myType = env.find(this).type;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	371 return myType;
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	372 }
fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	373
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	374 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	375 {
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	376 super(ExpType.Identifier);
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	377 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	378 }
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	379
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	380 char[] get()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	381 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	382 return name;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	383 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	384
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	385 hash_t toHash()
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	386 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	387 return jhash(name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	388 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	389
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	390 int opCmp(Object o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	391 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	392 if (auto id = cast(Identifier)o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	393 return typeid(char[]).compare(&name, &id.name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	394 return 0;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	395 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	396
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	397 int opEquals(Object o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	398 {
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	399 if (auto id = cast(Identifier)o)
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	400 return typeid(char[]).equals(&name, &id.name);
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	401 return 0;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	402 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	403
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	404 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	405 {
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	406 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	407 }
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	408
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	409 Token token;
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	410 char[] name;
58 fc62c5296a1c Add types to our Exp Anders Halager <halager@gmail.com> parents: 56 diff changeset	411 private DType myType;
1 2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	412 }
2168f4cb73f1 First push johnsen@johnsen-desktop parents: diff changeset	413

Mercurial > projects > dang

annotate ast/Exp.d @ 72:628cb46ab13b new_gen