shithub: mc

--- a/alloc.myr

+++ b/alloc.myr

@@ -6,8 +6,8 @@

 	generic alloc	: (		-> @a*)

 	generic free	: (v:@a*	-> void)

-	generic mkslice	: (n : size	-> @a[,])

-	generic freeslice: (sl : @a[,]	-> void)

+	generic mkslice	: (n : size	-> @a[:])

+	generic freeslice: (sl : @a[:]	-> void)

 	const bytealloc	: (sz:size	-> byte*)

 	const bytefree	: (m:byte*, sz:size	-> void)

@@ -57,7 +57,7 @@

 	var p

 	p = bytealloc(n*sizeof(@a)) castto(@a*)

-	-> p[0,n]

+	-> p[0:n]

 generic freeslice = {sl

--- a/chartype.myr

+++ b/chartype.myr

@@ -1061,11 +1061,11 @@

 	while t.len > nelt

 		sz /= 2

 		m = sz*nelt

-		l = t[m, t.len]

+		l = t[m:]

 		if c >= l[0]

-			t = l[0,m]

+			t = l[0:m]

 		else

-			t = t[0,m]

+			t = t[0:m]

;;

;;

@@ -1083,11 +1083,11 @@

 	if isupper(c) || islower(c)

 		-> true

-	elif findc(c, ralpha2[,], ralpha2.len/2, 2, &l)

+	elif findc(c, ralpha2[:], ralpha2.len/2, 2, &l)

 		if (c >= l[0] && c <= l[1])

 			-> true

;;

-	elif findc(c, ralpha1[,], ralpha1.len, 1, &l)

+	elif findc(c, ralpha1[:], ralpha1.len, 1, &l)

 		if (c == l[0])

 			-> true

;;

@@ -1098,7 +1098,7 @@

 const isnum = {c

 	var l

-	if findc(c, rnums[,], rnums.len/2, 2, &l)

+	if findc(c, rnums[:], rnums.len/2, 2, &l)

 		if(c >= l[0] && c <= l[1])

 			-> true

;;

@@ -1115,8 +1115,8 @@

 	var sl

 	var len

-	l = rspace2[,]

-	sl = rspace2[,]

+	l = rspace2[:]

+	sl = rspace2[:]

 	len = rspace2.len/2

 	if findc(c, sl, len, 2, &l)

 		if(c >= l[0] && c <= l[1])

@@ -1129,11 +1129,11 @@

 const islower = {c

 	var l

-	if findc(c, rtoupper2[,], rtoupper2.len, 2, &l)

+	if findc(c, rtoupper2[:], rtoupper2.len, 2, &l)

 		if (c >= l[0] && c <= l[1])

 			-> true

;;

-	elif findc(c, rtoupper1[,], rtoupper1.len, 1, &l)

+	elif findc(c, rtoupper1[:], rtoupper1.len, 1, &l)

 		if (c == l[0])

 			-> true

;;

@@ -1144,11 +1144,11 @@

 const isupper = {c

 	var l

-	if findc(c, rtolower2[,], rtolower2.len, 2, &l)

+	if findc(c, rtolower2[:], rtolower2.len, 2, &l)

 		if (c >= l[0] && c <= l[1])

 			-> true

;;

-	elif findc(c, rtolower1[,], rtolower1.len, 1, &l)

+	elif findc(c, rtolower1[:], rtolower1.len, 1, &l)

 		if (c == l[0])

 			-> true

;;

@@ -1163,11 +1163,11 @@

 const tolower = {c

 	var l

-	if findc(c, rtolower2[,], rtolower2.len/3, 3, &l)

+	if findc(c, rtolower2[:], rtolower2.len/3, 3, &l)

 		if c >= l[0] && c <= l[1]

 			-> c + l[2] - 500;

;;

-	elif findc(c, rtolower1[,], rtolower1.len/2, 2, &l)

+	elif findc(c, rtolower1[:], rtolower1.len/2, 2, &l)

 		if c == l[0]

 			-> c + l[1] - 500;

;;

@@ -1178,11 +1178,11 @@

 const toupper = {c

 	var l

-	if findc(c, rtoupper2[,], rtoupper2.len/3, 3, &l);

+	if findc(c, rtoupper2[:], rtoupper2.len/3, 3, &l);

 		if c >= l[0] && c <= l[1]

 			-> c + l[2] - 500;

;;

-	elif findc(c, rtoupper1[,], rtoupper1.len/2, 2, &l);

+	elif findc(c, rtoupper1[:], rtoupper1.len/2, 2, &l);

 		if c == l[0]

 			-> c + l[1] - 500;

;;

@@ -1193,7 +1193,7 @@

 const totitle = {c

 	var l

-	if findc(c, rtotitle1[,], rtotitle1.len/2, 2, &l);

+	if findc(c, rtotitle1[:], rtotitle1.len/2, 2, &l);

 		if c == l[0]

 			-> c + l[1] - 500;

;;

--- a/die.myr

+++ b/die.myr

@@ -2,8 +2,8 @@

 use "types.use"

 pkg std =

-	const die	: (msg : byte[,] -> void)

-	const assert	: (cond : bool, msg : byte[,] -> void)

+	const die	: (msg : byte[:] -> void)

+	const assert	: (cond : bool, msg : byte[:] -> void)

;;

 const die = {msg

--- a/fmt.myr

+++ b/fmt.myr

@@ -5,9 +5,9 @@

 use "varargs.use"

 pkg std =

-	const bfmt	: (buf : byte[,], fmt : byte[,], args:... -> size)

-	const bfmtv	: (buf : byte[,], fmt : byte[,], ap:valist -> size)

-	const put	: (fmt : byte[,], args:... -> size)

+	const bfmt	: (buf : byte[:], fmt : byte[:], args:... -> size)

+	const bfmtv	: (buf : byte[:], fmt : byte[:], ap:valist -> size)

+	const put	: (fmt : byte[:], args:... -> size)

;;

 const put = {fmt, args

@@ -14,8 +14,8 @@

 	var buf : byte[2048]

 	var n

-	n = bfmtv(buf[0,2048], fmt, vastart(&args))

-	write(1, buf[0,n])

+	n = bfmtv(buf[:], fmt, vastart(&args))

+	write(1, buf[:n])

 	-> n

@@ -26,7 +26,7 @@

 const bfmtv = {buf, fmt, ap

 	var c

 	var n

-	var s_val : byte[,]

+	var s_val : byte[:]

 	var b_val : int8

 	var w_val : int16

 	var i_val : int32

@@ -41,32 +41,32 @@

 			match c

 			's':

 				(s_val, ap) = vanext(ap)

-				n += strfmt(buf[n, buf.len], s_val)

+				n += strfmt(buf[n:], s_val)

;;

 			/* format integers */

 			'b':

 				(b_val, ap) = vanext(ap)

-				n += intfmt(buf[n, buf.len], b_val castto(int64), 10)

+				n += intfmt(buf[n:], b_val castto(int64), 10)

;;

 			'w':

 				(w_val, ap) = vanext(ap)

-				n += intfmt(buf[n, buf.len], i_val castto(int64), 10)

+				n += intfmt(buf[n:], i_val castto(int64), 10)

;;

 			'i':

 				(i_val, ap) = vanext(ap)

-				n += intfmt(buf[n, buf.len], i_val castto(int64), 10)

+				n += intfmt(buf[n:], i_val castto(int64), 10)

;;

 			'l':

 				(l_val, ap) = vanext(ap)

-				n += intfmt(buf[n, buf.len], i_val castto(int64), 10)

+				n += intfmt(buf[n:], i_val castto(int64), 10)

;;

 			'p':

 				(p_val, ap) = vanext(ap)

-				n += intfmt(buf[n, buf.len], p_val castto(int64), 16)

+				n += intfmt(buf[n:], p_val castto(int64), 16)

;;

;;

 		else

-			n += encode(buf[n,buf.len], c)

+			n += encode(buf[n:], c)

;;

;;

 	-> n

@@ -106,10 +106,10 @@

;;

 	n = 0

 	if isneg

-		n += encode(buf[n,buf.len], '-')

+		n += encode(buf[n:], '-')

;;

 	for j = i-1; j >= 0; j--

-		n += encode(buf[n,buf.len], b[j])

+		n += encode(buf[n:], b[j])

;;

 	-> n

--- a/sys-linux.myr

+++ b/sys-linux.myr

@@ -373,11 +373,11 @@

 	const exit	: (status:int64 -> void)

 	const getpid	: ( -> int64)

 	const kill	: (pid:int64, sig:int64 -> int64)

-	const open	: (path:byte[,], opts:fdopt, mode:int64 -> int64)

+	const open	: (path:byte[:], opts:fdopt, mode:int64 -> int64)

 	const close	: (fd:int64 -> int64)

-	const creat	: (path:byte[,], mode:int64 -> int64)

-	const read	: (fd:int64, buf:byte[,] -> int64)

-	const write	: (fd:int64, buf:byte[,] -> int64)

+	const creat	: (path:byte[:], mode:int64 -> int64)

+	const read	: (fd:int64, buf:byte[:] -> int64)

+	const write	: (fd:int64, buf:byte[:] -> int64)

 	const lseek	: (fd:int64, off:uint64, whence:int64 -> int64)

 	const fstat	: (fd:int64, sb:statbuf* -> int64)

 	const munmap	: (addr:byte*, len:size -> int64)

--- a/test.myr

+++ b/test.myr

@@ -45,13 +45,13 @@

 		else

 			std.write(1, "Dunno\n")

;;

-		if !std.encode(buf[0,std.charlen(c)], c)

+		if !std.encode(buf[:std.charlen(c)], c)

 			std.write(1, "couldn't encode\n")

;;

-		std.write(1, buf[0,std.charlen(c)])

+		std.write(1, buf[:std.charlen(c)])

 		std.write(1, "\n")

;;

-	if !std.encode(buf[0,3], -1)

+	if !std.encode(buf[0:3], -1)

 		std.write(1, "couldn't encode\n")

;;

--- a/utf.myr

+++ b/utf.myr

@@ -6,14 +6,14 @@

 	const Badchar	: char = -1 castto(char)

 	const charlen	: (chr : char -> size)

-	const encode	: (buf : byte[,], chr : char -> size)

-	const decode	: (buf : byte[,] -> char)

-	const striter	: (str : byte[,] -> [char, byte[,]])

+	const encode	: (buf : byte[:], chr : char -> size)

+	const decode	: (buf : byte[:] -> char)

+	const striter	: (str : byte[:] -> [char, byte[:]])

-	const strjoin	: (lst : byte[,][,], delim:byte[,] -> byte[,])

-	const strsep	: (str : byte[,], delim:byte[,] -> byte[,][,])

-	const strbjoin	: (lst : byte[,][,], delim:byte[,] -> byte[,])

-	const strbsep	: (str : byte[,], delim:byte[,] -> byte[,][,])

+	const strjoin	: (lst : byte[:][:], delim:byte[:] -> byte[:])

+	const strsep	: (str : byte[:], delim:byte[:] -> byte[:][:])

+	const strbjoin	: (lst : byte[:][:], delim:byte[:] -> byte[:])

+	const strbsep	: (str : byte[:], delim:byte[:] -> byte[:][:])

;;

 const charlen = {c

@@ -88,12 +88,12 @@

 	else

 		/* skip one char forward so we can try

 		   resyncing the character stream */

-		-> (Badchar, str[1,str.len])

+		-> (Badchar, str[1:])

;;

 	if len == 0 || len > str.len

 		/* again, we want to try to resync */

-		-> (Badchar, str[1,str.len])

+		-> (Badchar, str[1:])

;;

 	mask = (1 << (8 - len)) - 1

@@ -103,5 +103,5 @@

 		chr = (chr << 6) | (tmp & 0x3f)

;;

-	-> (chr castto(char), str[len, str.len])

+	-> (chr castto(char), str[len:])

--

⑨