[types] Float type.

CiParser.cs

@@ -39,6 +39,7 @@ public CiParser()
 		globals.Add(CiBoolType.Value);
 		globals.Add(CiByteType.Value);
 		globals.Add(CiIntType.Value);
+        globals.Add(CiFloatType.Value);
 		globals.Add(CiStringPtrType.Value);
 		globals.Add(new CiConst { Name = "true", Value = true, Type = CiBoolType.Value });
 		globals.Add(new CiConst { Name = "false", Value = false, Type = CiBoolType.Value });

CiResolver.cs

@@ -172,6 +172,12 @@ CiMaybeAssign Coerce(CiMaybeAssign expr, CiType expected)
 				return new CiConstExpr((object) (byte) (int) konst.Value);
 			return new CiCoercion { ResultType = expected, Inner = expr };
 		}
+		if (expected == CiFloatType.Value && got == CiIntType.Value) {
+			return new CiCoercion { ResultType = expected, Inner = expr };
+		}
+		if (expected == CiFloatType.Value && got == CiByteType.Value) {
+			return new CiCoercion { ResultType = expected, Inner = expr };
+		}
 		if (expected == CiStringPtrType.Value && (got == CiType.Null || got is CiStringType))
 			return expr;
 		if (expected is CiStringStorageType && got is CiStringType)
@@ -535,7 +541,12 @@ CiExpr ICiExprVisitor.Visit(CiUnaryExpr expr)
 			resolved = ResolveLValue(expr.Inner);
 		else
 			resolved = Resolve(expr.Inner);
-		expr.Inner = Coerce(resolved, CiIntType.Value);
+		if (resolved.Type is CiFloatType) {
+			expr.Inner = Coerce(resolved, CiFloatType.Value);
+		}
+		else {
+			expr.Inner = Coerce(resolved, CiIntType.Value);
+		}
 		if (expr.Op == CiToken.Minus && expr.Inner is CiConstExpr)
 			return new CiConstExpr(-GetConstInt(expr.Inner));
 		return expr;
@@ -564,6 +575,14 @@ CiExpr ICiExprVisitor.Visit(CiBinaryExpr expr)
 			string b = GetConstString(right);
 			return new CiConstExpr(a + b);
 		}
+		if ((expr.Op == CiToken.Plus || expr.Op == CiToken.Minus
+			|| expr.Op == CiToken.Asterisk || expr.Op == CiToken.Slash)
+			&& left.Type is CiFloatType || right.Type is CiFloatType) {
+			expr.Left = Coerce(left, CiFloatType.Value);
+			expr.Right = Coerce(right, CiFloatType.Value);
+			expr.ResultType = CiFloatType.Value;
+			return expr;
+		}
 		left = Coerce(left, CiIntType.Value);
 		right = Coerce(right, CiIntType.Value);
 		if (right is CiConstExpr) {
@@ -635,6 +654,9 @@ CiExpr ICiExprVisitor.Visit(CiBoolBinaryExpr expr)
 			type = CiIntType.Value;
 			break;
 		}
+		if (left.Type == CiFloatType.Value || right.Type == CiFloatType.Value) {
+			type = CiFloatType.Value;
+		}
 		expr.Left = Coerce(left, type);
 		expr.Right = Coerce(right, type);
 		CiConstExpr cleft = expr.Left as CiConstExpr;
@@ -809,7 +831,7 @@ void ICiStatementVisitor.Visit(CiAssign statement)
 		CiType type = statement.Target.Type;
 		CheckCopyPtr(type, source);
 		statement.Source = Coerce(source, type);
-		if (statement.Op != CiToken.Assign && type != CiIntType.Value && type != CiByteType.Value) {
+		if (statement.Op != CiToken.Assign && type != CiIntType.Value && type != CiByteType.Value && type != CiFloatType.Value) {
 			if (statement.Op == CiToken.AddAssign && type is CiStringStorageType && statement.Source.Type is CiStringType)
 				{} // OK
 			else

CiTree.cs

@@ -169,6 +169,20 @@ public override CiSymbol LookupMember(string name)
 	}
 }
 
+public class CiFloatType : CiType
+{
+	private CiFloatType() { }
+	public static readonly CiFloatType Value = new CiFloatType { Name = "float" };
+	public override Type DotNetType { get { return typeof(float); } }
+	public override CiSymbol LookupMember(string name)
+	{
+		switch (name) {
+			default: throw new ParseException("No member {0} in float", name);
+		}
+	}
+}
+
+
 public abstract class CiStringType : CiType
 {
 	public override Type DotNetType { get { return typeof(string); } }
@@ -605,7 +619,8 @@ public class CiBinaryExpr : CiExpr
 	public CiExpr Left;
 	public CiToken Op;
 	public CiExpr Right;
-	public override CiType Type { get { return CiIntType.Value; } }
+	public CiType ResultType = CiIntType.Value;
+	public override CiType Type { get { return ResultType; } }
 	public override bool HasSideEffect { get { return this.Left.HasSideEffect || this.Right.HasSideEffect; } }
 	public override CiExpr Accept(ICiExprVisitor v) { return v.Visit(this); }
 }

GenAs.cs

@@ -106,12 +106,14 @@ void Write(CiType type)
 			Write("Boolean");
 		else if (type == CiByteType.Value || type is CiEnum)
 			Write("int");
+		else if (type == CiFloatType.Value)
+			Write("Number");
 		else if (type is CiArrayType)
-			Write(((CiArrayType) type).ElementType == CiByteType.Value ? "ByteArray" : "Array");
+			Write(((CiArrayType)type).ElementType == CiByteType.Value ? "ByteArray" : "Array");
 		else if (type is CiDelegate)
 			Write("Function");
 		else
-			Write(type.Name);
+		Write(type.Name);
 	}
 
 	bool WriteInit(CiType type)
@@ -311,7 +313,7 @@ protected override void Write(CiMethodCall expr)
 
 	protected override void Write(CiBinaryExpr expr)
 	{
-		if (expr.Op == CiToken.Slash) {
+		if (expr.Op == CiToken.Slash && expr.Type != CiFloatType.Value) {
 			Write("int(");
 			WriteChild(CiPriority.Multiplicative, expr.Left);
 			Write(" / ");

GenJs.cs

@@ -254,7 +254,7 @@ protected override void Write(CiMethodCall expr)
 
 	protected override void Write(CiBinaryExpr expr)
 	{
-		if (expr.Op == CiToken.Slash) {
+		if (expr.Op == CiToken.Slash && expr.Type != CiFloatType.Value) {
 			Write("Math.floor(");
 			WriteChild(CiPriority.Multiplicative, expr.Left);
 			Write(" / ");

GenJsWithTypedArrays.cs

@@ -46,6 +46,17 @@ protected override void WriteNew(CiType type)
 				Write("))");
 				return;
 			}
+			if (arrayType.ElementType == CiFloatType.Value) {
+				Write("new Float32Array(new ArrayBuffer(");
+				if (arrayType.LengthExpr != null) {
+					WriteChild(CiPriority.Shift, arrayType.LengthExpr);
+					Write(" << 2");
+				}
+				else
+					Write(arrayType.Length << 2);
+				Write("))");
+				return;
+			}
 		}
 		base.WriteNew(type);
 	}