remove old `float` type entirely

compiler/jsgen.v

@@ -110,7 +110,7 @@ string res = tos2("");
 
 fn is_js_prim(typ string) bool {
 	return typ == 'int' || typ == 'string' ||
-	typ == 'bool' || typ == 'float' || typ == 'f32' || typ == 'f64' ||
+	typ == 'bool' || typ == 'f32' || typ == 'f64' ||
 	typ == 'i8' || typ == 'i16' || typ == 'i32' || typ == 'i64'
 }
 

compiler/main.v

@@ -73,7 +73,7 @@ mut:
 	is_so      bool
 	is_live    bool // for hot code reloading
 	is_prof    bool // benchmark every function
-	translated bool // `v translated doom.v` are we running V code translated from C? allow globals, ++ expressions, etc
+	translated bool // `v translate doom.v` are we running V code translated from C? allow globals, ++ expressions, etc
 	obfuscate  bool // `v -obf program.v`, renames functions to "f_XXX"
 	lang_dir   string // "~/code/v"
 	is_verbose bool // print extra information with `v.log()`

compiler/parser.v

@@ -1924,23 +1924,16 @@ fn (p mut Parser) factor() string {
 	tok := p.tok
 	switch tok {
 	case INT:
-		p.gen(p.lit)
-		p.fgen(p.lit)
 		typ = 'int'
 		// typ = 'number'
 		if p.lit.starts_with('u') {
 			typ = 'long'
 		}
 		if p.lit.contains('.') || p.lit.contains('e') {
-			// typ = 'f64'
+			typ = 'f32'
-			typ = 'float'
+			// typ = 'f64' // TODO 
 		}
-	case FLOAT:
+		p.gen(p.lit)
-		// TODO remove float 
-		typ = 'float'
-		// typ = 'f64'
-		// p.gen('(f64)$p.lit')
-		p.gen('$p.lit')
 		p.fgen(p.lit)
 	case MINUS:
 		p.gen('-')
@@ -2101,8 +2094,7 @@ fn (p mut Parser) typ_to_fmt(typ string) string {
 	case 'byte': return '%d'
 	case 'bool': return '%d'
 	case 'u32': return '%d'
-	case 'float': return '%f'
+	case 'double', 'f64', 'f32': return '%f'
-	case 'double', 'f64': return '%f'
 	case 'i64': return '%lld'
 	case 'byte*': return '%s'
 		// case 'array_string': return '%s'
@@ -3133,30 +3125,34 @@ fn is_compile_time_const(s string) bool {
 
 // fmt helpers
 fn (scanner mut Scanner) fgen(s string) {
+/* 
 	if scanner.fmt_line_empty {
 		s = repeat_char(`\t`, scanner.fmt_indent) + s
 	}
 	scanner.fmt_out.write(s)
 	scanner.fmt_line_empty = false
+*/ 
 }
 
 fn (scanner mut Scanner) fgenln(s string) {
+/* 
 	if scanner.fmt_line_empty {
 		s = repeat_char(`\t`, scanner.fmt_indent) + s
 	}
 	scanner.fmt_out.writeln(s)
 	scanner.fmt_line_empty = true
+*/ 
 }
 
 fn (p mut Parser) fgen(s string) {
-	p.scanner.fgen(s)
+	//p.scanner.fgen(s)
 }
 
 fn (p mut Parser) fspace() {
-	p.fgen(' ')
+	//p.fgen(' ')
 }
 
 fn (p mut Parser) fgenln(s string) {
-	p.scanner.fgenln(s)
+	//p.scanner.fgenln(s)
 }
 

compiler/table.v

@@ -97,8 +97,8 @@ fn (f Fn) str() string {
 // fn (types array_Type) print_to_file(f string)  {
 // }
 const (
-	NUMBER_TYPES = ['number', 'int', 'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'byte', 'i64', 'u64', 'long', 'double', 'float', 'f32', 'f64']
+	NUMBER_TYPES = ['number', 'int', 'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'byte', 'i64', 'u64', 'long', 'double', 'f32', 'f64']
-	FLOAT_TYPES  = ['double', 'float', 'f32', 'f64']
+	FLOAT_TYPES  = ['double', 'f32', 'f64']
 )
 
 fn is_number_type(typ string) bool {
@@ -130,7 +130,6 @@ fn new_table(obfuscate bool) *Table {
 	t.register_type('byteptr')
 	t.register_type('intptr')
 	t.register_type('double')// TODO remove
-	t.register_type('float')// TODO remove
 	t.register_type('f32')
 	t.register_type('f64')
 	t.register_type('rune')
@@ -421,16 +420,16 @@ fn (p mut Parser) _check_types(got, expected string, throw bool) bool {
 		return true
 	}
 	// Allow ints to be used as floats
-	if got.eq('int') && expected.eq('float') {
+	if got == 'int' && expected == 'f32' {
 		return true
 	}
-	if got.eq('int') && expected.eq('f64') {
+	if got == 'int' && expected == 'f64' {
 		return true
 	}
-	if got == 'f64' && expected == 'float' {
+	if got == 'f64' && expected == 'f32' {
 		return true
 	}
-	if got == 'float' && expected == 'f64' {
+	if got == 'f32' && expected == 'f64' {
 		return true
 	}
 	// Allow ints to be used as longs

compiler/token.v

@@ -10,7 +10,6 @@ enum Token {
 	INT
 	STRING
 	CHAR
-	FLOAT
 	PLUS
 	MINUS
 	MUL
@@ -129,7 +128,6 @@ fn build_token_str() []string {
 	s[INT] = 'INT'
 	s[STRING] = 'STR'
 	s[CHAR] = 'CHAR'
-	s[FLOAT] = 'FLOAT'
 	s[PLUS] = '+'
 	s[MINUS] = '-'
 	s[MUL] = '*'

gg/gg.v

@@ -148,7 +148,7 @@ pub fn new_context(cfg Cfg) *GG {
 	return ctx
 }
 
-pub fn (ctx &GG) draw_triangle(x1, y1, x2, y2, x3, y3 float, c gx.Color) {
+pub fn (ctx &GG) draw_triangle(x1, y1, x2, y2, x3, y3 f32, c gx.Color) {
 	// println('draw_triangle $x1,$y1 $x2,$y2 $x3,$y3')
 	ctx.shader.use()
 	ctx.shader.set_color('color', c)
@@ -173,7 +173,7 @@ pub fn (ctx &GG) draw_triangle(x1, y1, x2, y2, x3, y3 float, c gx.Color) {
 	gl.draw_arrays(GL_TRIANGLES, 0, 3)
 }
 
-pub fn (ctx &GG) draw_triangle_tex(x1, y1, x2, y2, x3, y3 float, c gx.Color) {
+pub fn (ctx &GG) draw_triangle_tex(x1, y1, x2, y2, x3, y3 f32, c gx.Color) {
 	ctx.shader.use()
 	ctx.shader.set_color('color', c)
 	ctx.shader.set_int('has_texture', 1)
@@ -198,7 +198,7 @@ pub fn (ctx &GG) draw_triangle_tex(x1, y1, x2, y2, x3, y3 float, c gx.Color) {
 	gl.draw_elements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0)
 }
 
-fn (ctx &GG) draw_rect(x, y, w, h float, c gx.Color) {
+fn (ctx &GG) draw_rect(x, y, w, h f32, c gx.Color) {
 	// println('gg.draw_rect($x,$y,$w,$h)')
 	// wrong order
 	// // ctx.draw_triangle(x, y, x + w, y, x + w, y + h, c)
@@ -231,7 +231,7 @@ fn (ctx mut GG) init_rect_vao() {
 	gl.set_ebo(ebo, indices, GL_STATIC_DRAW)
 } 
 */
-fn (ctx &GG) draw_rect2(x, y, w, h float, c gx.Color) {
+fn (ctx &GG) draw_rect2(x, y, w, h f32, c gx.Color) {
 	C.glDeleteBuffers(1, &ctx.VAO)
 	C.glDeleteBuffers(1, &ctx.VBO)
 	ctx.shader.use()
@@ -396,10 +396,10 @@ fn new_context_text(cfg Cfg, scale int) *GG {
 	VBO := gl.gen_buffer()
 	gl.bind_vao(VAO)
 	gl.bind_buffer(GL_ARRAY_BUFFER, VBO)
-	// # glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6 * 4, NULL, GL_DYNAMIC_DRAW);
+	// # glBufferData(GL_ARRAY_BUFFER, sizeof(GLf32) * 6 * 4, NULL, GL_DYNAMIC_DRAW);
 	gl.enable_vertex_attrib_array(0)
 	gl.vertex_attrib_pointer(0, 4, GL_FLOAT, false, 4, 0)
-	// # glVertexAttribPointer(0, 4, GL_FLOAT,false, 4 * sizeof(GLfloat), 0);
+	// # glVertexAttribPointer(0, 4, GL_FLOAT,false, 4 * sizeof(GLf32), 0);
 	// gl.bind_buffer(GL_ARRAY_BUFFER, uint(0))
 	// # glBindVertexArray(0);
 	mut ctx := &GG {
@@ -432,7 +432,7 @@ fn (ctx mut GG) init_utf8_runes() {
 	}
 }
 
-// fn (ctx &GG) render_text(text string, x, y, scale float, color gx.Color) {
+// fn (ctx &GG) render_text(text string, x, y, scale f32, color gx.Color) {
 pub fn (ctx &GG) draw_text(_x, _y int, text string, cfg gx.TextCfg) {
 	// dont draw non ascii for now
 	/* 
@@ -477,11 +477,11 @@ fn (ctx &GG) _draw_text(_x, _y int, utext ustring, cfg gx.TextCfg) {
 		width := utext.len * 7
 		_x -= width + 10
 	}
-	x := float(_x) * ctx.scale// float(2)
+	x := f32(_x) * ctx.scale// f32(2)
 	// println('y=$_y height=$ctx.height')
 	// _y = _y * int(ctx.scale) //+ 26
 	_y = _y * int(ctx.scale) + ((cfg.size * ctx.scale) / 2) + 5 * ctx.scale
-	y := float(ctx.height - _y)
+	y := f32(ctx.height - _y)
 	color := cfg.color
 	// Activate corresponding render state
 	ctx.shader.use()
@@ -521,10 +521,10 @@ fn (ctx &GG) _draw_text(_x, _y int, utext ustring, cfg gx.TextCfg) {
 		// s := 'A'
 		// c := int(s[0])
 		// ch := ctx.chars[c]
-		xpos := x + float(ch.bearing.x) * 1
+		xpos := x + f32(ch.bearing.x) * 1
-		ypos := y - float(ch.size.y - ch.bearing.y) * 1
+		ypos := y - f32(ch.size.y - ch.bearing.y) * 1
-		w := float(ch.size.x) * 1
+		w := f32(ch.size.x) * 1
-		h := float(ch.size.y) * 1
+		h := f32(ch.size.y) * 1
 		// Update VBO for each character
 		# GLfloat vertices[6][4] = {
 		# { xpos,     ypos + h,   0.0, 0.0 },
@@ -656,7 +656,7 @@ pub fn (ctx &GG) draw_line_c(x, y, x2, y2 int, color gx.Color) {
 	C.glDeleteBuffers(1, &ctx.VBO)
 	ctx.shader.use()
 	ctx.shader.set_color('color', color)
-	vertices := [float(x), float(y), float(x2), float(y2)] !
+	vertices := [f32(x), f32(y), f32(x2), f32(y2)] !
 	gl.bind_vao(ctx.VAO)
 	gl.set_vbo(ctx.VBO, vertices, GL_STATIC_DRAW)
 	gl.vertex_attrib_pointer(0, 2, GL_FLOAT, false, 2, 0)
@@ -673,8 +673,8 @@ pub fn (c &GG) draw_vertical(x, y, height int) {
 	c.draw_line(x, y, x, y + height)
 }
 
-// fn (ctx &GG) draw_image(x, y, w, h float, img stbi.Image) {
+// fn (ctx &GG) draw_image(x, y, w, h f32, img stbi.Image) {
-pub fn (ctx &GG) draw_image(x, y, w, h float, tex_id u32) {
+pub fn (ctx &GG) draw_image(x, y, w, h f32, tex_id u32) {
 	// println('DRAW IMAGE $x $y $w $h $tex_id')
 	ctx.shader.use()
 	// ctx.shader.set_color('color', c)

gl/1shader.v

@@ -166,7 +166,7 @@ pub fn (s Shader) uni_location(key string) int {
 	return C.glGetUniformLocation(s.program_id, key.str)
 }
 
-// fn (s Shader) set_mat4(str string, f *float) {
+// fn (s Shader) set_mat4(str string, f *f32) {
 pub fn (s Shader) set_mat4(str string, m glm.Mat4) {
 	// TODO cache uniform location
 	C.glUniformMatrix4fv(s.uni_location(str), 1, false, m.data)
@@ -177,6 +177,6 @@ pub fn (s Shader) set_int(str string, n int) {
 }
 
 pub fn (s Shader) set_color(str string, c gx.Color) {
-	C.glUniform3f(s.uni_location(str), float(c.r) / 255.0, float(c.g) / 255.0, float(c.b) / 255.0)
+	C.glUniform3f(s.uni_location(str), f32(c.r) / 255.0, f32(c.g) / 255.0, f32(c.b) / 255.0)
 }
 

gl/gl.v

@@ -33,7 +33,7 @@ pub fn viewport(a int, b int, c int, d int) {
 }
 
 pub fn clear_color(r, g, b, a int) {
-	# glClearColor(((float)r)/255.0,((float)g)/255.0,b/255.0, a/255.0);
+	# glClearColor(((f32)r)/255.0,((f32)g)/255.0,b/255.0, a/255.0);
 }
 
 pub fn clear() {
@@ -132,14 +132,14 @@ pub fn buffer_data_int(typ int, vertices[]int, draw_typ int) {
 	C.glBufferData(typ, size, vertices.data, draw_typ)
 }
 
-pub fn buffer_data_float(typ int, vertices[]float, draw_typ int) {
+pub fn buffer_data_f32(typ int, vertices[]f32, draw_typ int) {
-	size := sizeof(float) * vertices.len
+	size := sizeof(f32) * vertices.len
 	C.glBufferData(typ, size, vertices.data, draw_typ)
 }
 
-pub fn set_vbo(vbo u32, vertices[]float, draw_typ int) {
+pub fn set_vbo(vbo u32, vertices[]f32, draw_typ int) {
 	gl.bind_buffer(GL_ARRAY_BUFFER, vbo)
-	gl.buffer_data_float(GL_ARRAY_BUFFER, vertices, draw_typ)
+	gl.buffer_data_f32(GL_ARRAY_BUFFER, vertices, draw_typ)
 }
 
 pub fn set_ebo(ebo u32, indices[]int, draw_typ int) {
@@ -182,8 +182,8 @@ pub fn gen_buffer() u32 {
 
 pub fn vertex_attrib_pointer(index, size int, typ int, normalized bool, stride int, ptr int) {
 	if typ == GL_FLOAT {
-		stride *= sizeof(float)
+		stride *= sizeof(f32)
-		ptr *= sizeof(float)
+		ptr *= sizeof(f32)
 	}
 	C.glVertexAttribPointer(index, size, typ, normalized, stride, ptr)
 }

glm/glm.v

@@ -8,32 +8,32 @@ import math
 
 /* 
 #flag -lmyglm
-# float* myglm_ortho(float, float, float, float);
+# f32* myglm_ortho(f32, f32, f32, f32);
-# float* myglm_translate(float, float, float);
+# f32* myglm_translate(f32, f32, f32);
 */
-// # float* myglm_rotate(float *m, float angle, float, float, float);
+// # f32* myglm_rotate(f32 *m, f32 angle, f32, f32, f32);
-// # float* myglm_perspective(float, float, float, float);
+// # f32* myglm_perspective(f32, f32, f32, f32);
-// # float* myglm_look_at(glm__Vec3, glm__Vec3, glm__Vec3);
+// # f32* myglm_look_at(glm__Vec3, glm__Vec3, glm__Vec3);
 // # glm__Vec3 myglm_mult(glm__Vec3, glm__Vec3);
 // # glm__Vec3 myglm_cross(glm__Vec3, glm__Vec3);
 // # glm__Vec3 myglm_normalize(glm__Vec3);
 struct Mat4 {
 pub:
-	data *float
+	data *f32
 }
 
 struct Vec2 {
-	x float
+	x f32
-	y float
+	y f32
 }
 
 struct Vec3 {
-	x float
+	x f32
-	y float
+	y f32
-	z float
+	z f32
 }
 
-fn vec3(x, y, z float) Vec3 {
+fn vec3(x, y, z f32) Vec3 {
 	res := Vec3 {
 		x: x,
 		y: y,
@@ -42,7 +42,7 @@ fn vec3(x, y, z float) Vec3 {
 	return res
 }
 
-fn mat4(f *float) Mat4 {
+fn mat4(f *f32) Mat4 {
 	res := Mat4 {
 		data: f
 	}
@@ -104,7 +104,7 @@ fn (a Vec3) sub(b Vec3) Vec3 {
 // fn (a Vec3) mult(b Vec3) Vec3 {
 // # return myglm_mult(a,b);
 // }
-fn (a Vec3) mult_scalar(b float) Vec3 {
+fn (a Vec3) mult_scalar(b f32) Vec3 {
 	res := Vec3 {
 		x: a.x * b,
 		y: a.y * b,
@@ -122,7 +122,7 @@ fn (a Vec3) print() {
 }
 
 /* 
-fn rotate(m Mat4, angle float, vec Vec3) Mat4 {
+fn rotate(m Mat4, angle f32, vec Vec3) Mat4 {
 	// # t_mat4 m;
 	// println('rotate done')
 	# return glm__mat4( myglm_rotate(m.data, angle, vec.x,vec.y,vec.z) );
@@ -130,14 +130,14 @@ fn rotate(m Mat4, angle float, vec Vec3) Mat4 {
 }
 */
 
-fn float_calloc(n int) *float {
+fn f32_calloc(n int) *f32 {
-	return *float(calloc(n * sizeof(float)))
+	return *f32(calloc(n * sizeof(f32)))
 }
-// fn translate(vec Vec3) *float {
+// fn translate(vec Vec3) *f32 {
 fn translate(m Mat4, v Vec3) Mat4 {
 	// # return glm__mat4(myglm_translate(vec.x,vec.y,vec.z)  );
 	a := m.data
-	mut out := float_calloc(16)
+	mut out := f32_calloc(16)
 	x := v.x
 	y := v.y
 	z := v.z
@@ -161,11 +161,11 @@ fn normalize(vec Vec3) Vec3 {
 }
 */
 // https://github.com/g-truc/glm/blob/0ceb2b755fb155d593854aefe3e45d416ce153a4/glm/ext/matrix_clip_space.inl
-fn ortho(left, right, bottom, top float) Mat4 {
+fn ortho(left, right, bottom, top f32) Mat4 {
 	println('glm ortho($left, $right, $bottom, $top)')
 	// mat<4, 4, T, defaultp> Result(static_cast<T>(1));
 	n := 16
-	mut res := float_calloc(n)
+	mut res := f32_calloc(n)
 	# res[0] = 2 / (right - left) ;
 	# res[5] = 2.0 / (top - bottom);
 	# res[10] =  (1);
@@ -175,10 +175,10 @@ fn ortho(left, right, bottom, top float) Mat4 {
 	return mat4(res)
 }
 
-// fn scale(a *float, v Vec3) *float {
+// fn scale(a *f32, v Vec3) *f32 {
 fn scale(m Mat4, v Vec3) Mat4 {
 	a := m.data
-	mut out := float_calloc(16)
+	mut out := f32_calloc(16)
 	x := v.x
 	y := v.y
 	z := v.z
@@ -201,10 +201,10 @@ fn scale(m Mat4, v Vec3) Mat4 {
 	return mat4(out)
 }
 
-// fn rotate_z(a *float, rad float) *float {
+// fn rotate_z(a *f32, rad f32) *f32 {
-fn rotate_z(m Mat4, rad float) Mat4 {
+fn rotate_z(m Mat4, rad f32) Mat4 {
 	a := m.data
-	mut out := float_calloc(16)
+	mut out := f32_calloc(16)
 	s := math.sin(rad)
 	c := math.cos(rad)
 	a00 := a[0]
@@ -241,7 +241,7 @@ fn identity() Mat4 {
 	// 0 0 1 0
 	// 0 0 0 1
 	n := 16
-	mut res := float_calloc(sizeof(float) * n)
+	mut res := f32_calloc(sizeof(f32) * n)
 	res[0] = 1
 	res[5] = 1
 	res[10] = 1
@@ -249,19 +249,19 @@ fn identity() Mat4 {
 	return mat4(res)
 }
 
-// returns *float without allocation
+// returns *f32 without allocation
-fn identity2(res *float) {
+fn identity2(res *f32) {
 	res[0] = 1
 	res[5] = 1
 	res[10] = 1
 	res[15] = 1
-	// # float f[16]={0};// for (int i =0;i<16;i++)
+	// # f32 f[16]={0};// for (int i =0;i<16;i++)
 	// # printf("!!%d\n", f[0]);
 	// # glm__identity2(&f);
 	// # gl__Shader_set_mat4(shader, tos2("projection"), f) ;
 }
 
-fn identity3() []float {
+fn identity3() []f32 {
 	res := [1.0, 0, 0, 0,
 	0, 1, 0, 0,
 	0, 0, 1, 0,
@@ -271,13 +271,13 @@ fn identity3() []float {
 }
 
 // https://github.com/toji/gl-matrix/blob/1549cf21dfa14a2bc845993485343d519cf064fe/src/gl-matrix/mat4.js
-fn ortho_js(left, right, bottom, top float) *float {
+fn ortho_js(left, right, bottom, top f32) *f32 {
 	mynear := 1
 	myfar := 1
 	lr := 1.0 / (left - right)
 	bt := 1.0 / (bottom - top)
 	nf := 1.0 / 1.0// (mynear -myfar)
-	# float* out = malloc (sizeof(float) * 16);
+	# f32* out = malloc (sizeof(f32) * 16);
 	# out[0] = -2 * lr;
 	# out[1] = 0;
 	# out[2] = 0;
@@ -299,7 +299,7 @@ fn ortho_js(left, right, bottom, top float) *float {
 	return &f
 }
 
-// fn ortho_old(a, b, c, d float) *float {
+// fn ortho_old(a, b, c, d f32) *f32 {
 // # return myglm_ortho(a,b,c,d);
 // }
 fn cross(a, b Vec3) Vec3 {
@@ -308,7 +308,7 @@ fn cross(a, b Vec3) Vec3 {
 }
 
 /* 
-fn perspective(degrees float, ratio float, a, b float) Mat4 {
+fn perspective(degrees f32, ratio f32, a, b f32) Mat4 {
 	// println('lang per degrees=$degrees ratio=$ratio a=$a b=$b')
 	// # printf("lang pers degrees=%f ratio=%f a=%f b=%f\n", degrees, ratio, a,b);
 	# return glm__mat4( myglm_perspective(degrees, ratio, a,b)  ) ;

json/json_primitives.v

@@ -13,7 +13,7 @@ module json
 #include "cJSON.h"
 struct C.cJSON {
 	valueint    int
-	valuedouble float
+	valuedouble f32 
 	valuestring byteptr
 }
 
@@ -54,13 +54,6 @@ fn jsdecode_i64(root *C.cJSON) i64 {
 	return i64(root.valuedouble) //i64 is double in C
 }
 
-fn jsdecode_float(root *C.cJSON) float {
-	if isnil(root) {
-		return 0
-	}
-	return root.valuedouble
-}
-
 fn jsdecode_f32(root *C.cJSON) f32 {
 	if isnil(root) {
 		return f32(0)
@@ -116,10 +109,6 @@ fn jsencode_i64(val i64) *C.cJSON {
 	return C.cJSON_CreateNumber(val)
 }
 
-fn jsencode_float(val float) *C.cJSON {
-	return C.cJSON_CreateNumber(val)
-}
-
 fn jsencode_f32(val f32) *C.cJSON {
 	return C.cJSON_CreateNumber(val)
 }