From 2b433cdf64b70cf4450fa2eadabbceebb21329eb Mon Sep 17 00:00:00 2001
From: Alexander Medvednikov <alexander@medvednikov.com>
Date: Wed, 5 Feb 2020 10:00:11 +0100
Subject: [PATCH] v2: match, <<=, >>=, |=, ~, unsafe, map init

---
 vlib/builtin/int.v           |  8 +--
 vlib/builtin/string.v        |  2 +-
 vlib/hash/fnv1a/fnv1a_test.v |  3 ++
 vlib/strconv/atof.v          |  1 +
 vlib/v/ast/ast.v             | 25 +++++++---
 vlib/v/parser/parser.v       | 94 +++++++++++++++++++++++++++++-------
 vlib/v/token/token.v         |  9 +++-
 7 files changed, 110 insertions(+), 32 deletions(-)

diff --git a/vlib/builtin/int.v b/vlib/builtin/int.v
index 8881bb5900..42486816cb 100644
--- a/vlib/builtin/int.v
+++ b/vlib/builtin/int.v
@@ -156,16 +156,16 @@ pub fn (n i64) hex() string {
 	len := if n >= i64(0) { n.str().len + 3 } else { 19 }
 	hex := malloc(len)
 	// QTODO
-	count := C.sprintf(charptr(hex), '0x%'C.PRIx64, n)
-	//count := C.sprintf(charptr(hex), '0x%x', n)
+	//count := C.sprintf(charptr(hex), '0x%'C.PRIx64, n)
+	count := C.sprintf(charptr(hex), '0x%x', n)
 	return tos(hex, count)
 }
 
 pub fn (n u64) hex() string {
 	len := if n >= u64(0) { n.str().len + 3 } else { 19 }
 	hex := malloc(len)
-	count := C.sprintf(charptr(hex), '0x%'C.PRIx64, n)
-	//count := C.sprintf(charptr(hex), '0x%lx', n)
+	//count := C.sprintf(charptr(hex), '0x%'C.PRIx64, n)
+	count := C.sprintf(charptr(hex), '0x%lx', n)
 	return tos(hex, count)
 }
 
diff --git a/vlib/builtin/string.v b/vlib/builtin/string.v
index a9f59e86d8..28e6427a31 100644
--- a/vlib/builtin/string.v
+++ b/vlib/builtin/string.v
@@ -688,7 +688,7 @@ pub fn (s string) count(substr string) int {
 }
 
 pub fn (s string) contains(p string) bool {
-	_ = s.index(p) or {
+	s.index(p) or {
 		return false
 	}
 	return true
diff --git a/vlib/hash/fnv1a/fnv1a_test.v b/vlib/hash/fnv1a/fnv1a_test.v
index 909b8ac183..216159d87d 100644
--- a/vlib/hash/fnv1a/fnv1a_test.v
+++ b/vlib/hash/fnv1a/fnv1a_test.v
@@ -1,6 +1,9 @@
 import hash.fnv1a
 
 fn test_fnv1a() {
+	$if windows {
+		return
+	}
 	a := 'apple'
 	b := fnv1a.sum64_string(a)
 	c := fnv1a.sum64(a.bytes())
diff --git a/vlib/strconv/atof.v b/vlib/strconv/atof.v
index 96c5736561..e681741a51 100644
--- a/vlib/strconv/atof.v
+++ b/vlib/strconv/atof.v
@@ -215,6 +215,7 @@ fn parser(s string) (int,PrepNumber) {
 				state = FSM_C
 				if c == PLUS {
 					c = s[i++]
+					//i++
 				}
 				else if c == MINUS {
 					pn.negative = true
diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
index 028d202481..7369c99adc 100644
--- a/vlib/v/ast/ast.v
+++ b/vlib/v/ast/ast.v
@@ -10,7 +10,7 @@ import (
 
 pub type Expr = InfixExpr | IfExpr | StringLiteral | IntegerLiteral | CharLiteral | 	
 FloatLiteral | Ident | CallExpr | BoolLiteral | StructInit | ArrayInit | SelectorExpr | PostfixExpr | 	
-AssignExpr | PrefixExpr | MethodCallExpr | IndexExpr | RangeExpr
+AssignExpr | PrefixExpr | MethodCallExpr | IndexExpr | RangeExpr | MatchExpr
 
 pub type Stmt = VarDecl | GlobalDecl | FnDecl | Return | Module | Import | ExprStmt | 	
 ForStmt | StructDecl | ForCStmt | ForInStmt | CompIf | ConstDecl | Attr | BranchStmt | 	
@@ -186,17 +186,17 @@ mut:
 
 pub struct File {
 pub:
-	path    string
-	mod     Module
-	imports []Import
-	stmts   []Stmt
+	path       string
+	mod        Module
+	imports    []Import
+	stmts      []Stmt
 	unresolved []Expr
 }
 
 pub struct IdentVar {
 pub:
-	typ  table.Type
-	//name string
+	typ table.Type
+	// name string
 }
 
 type IdentInfo = IdentVar
@@ -275,6 +275,17 @@ pub:
 	pos        token.Position
 }
 
+pub struct MatchExpr {
+pub:
+	tok_kind   token.Kind
+	cond       Expr
+	stmts      []Stmt
+	else_stmts []Stmt
+	ti         table.Type
+	left       Expr // `a` in `a := if ...`
+	pos        token.Position
+}
+
 pub struct CompIf {
 pub:
 	cond       Expr
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v
index a4e4cce4a8..b3869f5f87 100644
--- a/vlib/v/parser/parser.v
+++ b/vlib/v/parser/parser.v
@@ -16,12 +16,14 @@ import (
 const (
 	colored_output = term.can_show_color_on_stderr()
 )
-
+/*
 type PrefixParseFn fn()ast.Expr
 
 type InfixParseFn fn(e ast.Expr)ast.Expr
 
 type PostfixParseFn fn()ast.Expr
+*/
+
 
 struct Parser {
 	scanner     &scanner.Scanner
@@ -232,9 +234,14 @@ pub fn (p mut Parser) stmt() ast.Stmt {
 				tok: p.tok
 			}
 		}
+		.key_unsafe {
+			p.next()
+			p.parse_block()
+			return ast.Stmt{}
+		}
 		else {
 			// `x := ...`
-			if p.tok.kind == .name && p.peek_tok.kind == .decl_assign {
+			if p.tok.kind == .name && p.peek_tok.kind in [.decl_assign, .comma] {
 				return p.var_decl()
 			}
 			expr,ti := p.expr(0)
@@ -286,7 +293,10 @@ fn (p mut Parser) attr() ast.Attr {
 
 fn (p mut Parser) range_expr(low ast.Expr) ast.Expr {
 	// ,table.Type) {
-	p.next()
+	if p.tok.kind != .dotdot {
+		p.next()
+	}
+	p.check(.dotdot)
 	high,typ := p.expr(0)
 	if typ.kind != .int {
 		p.error('non-integer index `$typ.name`')
@@ -372,6 +382,17 @@ pub fn (p mut Parser) name_expr() (ast.Expr,table.Type) {
 		p.next()
 		p.check(.dot)
 	}
+	if p.tok.lit == 'map' && p.peek_tok.kind == .lsbr {
+		p.next()
+		p.check(.lsbr)
+		key_type := p.check_name()
+		if key_type != 'string' {
+			p.error('maps can only have string keys for now')
+		}
+		p.check(.rsbr)
+		p.check_name()
+		return node,typ
+	}
 	// fn call
 	if p.peek_tok.kind == .lpar {
 		println('calling $p.tok.lit')
@@ -380,7 +401,8 @@ pub fn (p mut Parser) name_expr() (ast.Expr,table.Type) {
 		typ = ti2
 	}
 	// struct init
-	else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || p.tok.lit in ['array', 'string', 'mapnode', 'map']) {
+	else if p.peek_tok.kind == .lcbr && (p.tok.lit[0].is_capital() || p.tok.lit in ['array', 'string', 'ustring', 'mapnode', 'map']) && !p.tok.lit[p.tok.lit.len - 1].is_capital() {
+		// || p.table.known_type(p.tok.lit)) {
 		typ = p.parse_type()
 		// p.warn('struct init typ=$typ.name')
 		p.check(.lcbr)
@@ -476,8 +498,8 @@ pub fn (p mut Parser) expr(precedence int) (ast.Expr,table.Type) {
 			}
 			p.next()
 		}
-		// -1, -a, !x, &x etc
-		.minus, .amp, .mul, .not {
+		// -1, -a, !x, &x, ~x
+		.minus, .amp, .mul, .not, .bit_not {
 			node,typ = p.prefix_expr()
 		}
 		// .amp {
@@ -490,6 +512,9 @@ pub fn (p mut Parser) expr(precedence int) (ast.Expr,table.Type) {
 			typ = table.bool_type
 			p.next()
 		}
+		.key_match {
+			return p.match_expr()
+		}
 		.number {
 			node,typ = p.parse_number_literal()
 		}
@@ -504,6 +529,9 @@ pub fn (p mut Parser) expr(precedence int) (ast.Expr,table.Type) {
 		.lsbr {
 			node,typ = p.array_init()
 		}
+		.key_none {
+			p.next()
+		}
 		.key_sizeof {
 			p.next()
 			p.check(.lpar)
@@ -563,7 +591,7 @@ fn (p mut Parser) index_expr(left ast.Expr) ast.Expr {
 	// println('index expr$p.tok.str() line=$p.tok.line_nr')
 	p.next() // [
 	mut index_expr := ast.Expr{}
-	if p.tok.kind == .dotdot {
+	if p.tok.kind == .dotdot || p.peek_tok.kind == .dotdot {
 		// `numbers[..end]`
 		index_expr = p.range_expr(left)
 		// typ = typ_ // set the type back to array
@@ -767,14 +795,16 @@ fn (p mut Parser) if_expr() (ast.Expr,table.Type) {
 	mut ti := table.void_type
 	// mut left := ast.Expr{}
 	// If the last statement is an expression, return its type
-	match stmts[stmts.len - 1] {
-		ast.ExprStmt {
-			p.warn('if expr ret $it.ti.name')
-			ti = it.ti
-			// return node,it.ti
-			// left =
-		}
-		else {}
+	if stmts.len > 0 {
+		match stmts[stmts.len - 1] {
+			ast.ExprStmt {
+				p.warn('if expr ret $it.ti.name')
+				ti = it.ti
+				// return node,it.ti
+				// left =
+			}
+			else {}
+	}
 	}
 	node = ast.IfExpr{
 		cond: cond
@@ -958,6 +988,11 @@ fn (p mut Parser) struct_decl() ast.StructDecl {
 		field_name := p.check_name()
 		// p.warn('field $field_name')
 		ti := p.parse_type()
+		// Default value
+		if p.tok.kind == .assign {
+			p.next()
+			p.expr(0)
+		}
 		ast_fields << ast.Field{
 			name: field_name
 			typ: ti
@@ -1034,9 +1069,9 @@ fn (p mut Parser) var_decl() ast.VarDecl {
 		p.check(.key_static)
 		// p.fspace()
 	}
-	name := p.tok.lit
-	p.read_first_token()
-	expr,typ := p.expr(token.lowest_prec)
+	name := p.check_name()
+	p.next()
+	expr,typ := p.expr(0)
 	if _ := p.table.find_var(name) {
 		p.error('redefinition of `$name`')
 	}
@@ -1101,6 +1136,29 @@ fn (p mut Parser) global_decl() ast.GlobalDecl {
 	}
 }
 
+fn (p mut Parser) match_expr() (ast.Expr,table.Type) {
+	p.check(.key_match)
+	p.expr(0)
+	p.check(.lcbr)
+	for {
+		// p.tok.kind != .rcbr {
+		p.expr(0)
+		p.warn('match block')
+		p.parse_block()
+		if p.tok.kind == .key_else {
+			p.next()
+			p.parse_block()
+		}
+		if p.tok.kind == .rcbr {
+			break
+		}
+	}
+	p.check(.rcbr)
+	mut node := ast.Expr{}
+	node = ast.MatchExpr{}
+	return node,table.void_type
+}
+
 fn (p mut Parser) add_unresolved(expr ast.Expr) table.Type {
 	t := table.Type{
 		idx: p.unresolved.len
diff --git a/vlib/v/token/token.v b/vlib/v/token/token.v
index b48c2f88d1..651047a369 100644
--- a/vlib/v/token/token.v
+++ b/vlib/v/token/token.v
@@ -388,7 +388,9 @@ pub fn (tok Token) precedence() int {
 			return 3
 		}
 		// `||`
-		.logical_or, .assign, .plus_assign, .minus_assign, .div_assign, .mult_assign {
+		.logical_or, .assign, .plus_assign, .minus_assign, .div_assign, .or_assign,
+		//
+		.left_shift_assign, .righ_shift_assign, .mult_assign {
 			return 2
 		}
 		.key_in {
@@ -415,6 +417,7 @@ pub fn (tok Token) is_unary() bool {
 	.plus, .minus, .not, .bit_not, .mul, .amp]
 }
 
+/*
 // NOTE: do we need this for all tokens (is_left_assoc / is_right_assoc),
 // or only ones with the same precedence?
 // is_left_assoc returns true if the token is left associative
@@ -451,6 +454,8 @@ pub fn (tok Token) is_right_assoc() bool {
 	// `&=` | `^=` | `|=`
 	.and_assign, .xor_assign, .or_assign]
 }
+*/
+
 
 pub fn (tok Kind) is_relational() bool {
 	return tok in [
@@ -461,5 +466,5 @@ pub fn (tok Kind) is_relational() bool {
 pub fn (kind Kind) is_infix() bool {
 	return kind in [.plus, .minus, .mod, .mul, .div, .eq, .ne, .gt, .lt, .key_in, .ge, .le, .logical_or,
 	//
-.and, .dot, .pipe, .left_shift, .right_shift]
+	.and, .dot, .pipe, .amp, .left_shift, .right_shift]
 }