code: drawterm

Info  •  Files  •  Log

libc: update various libc functions (from 9front)

--- a/libc/cleanname.c

+++ b/libc/cleanname.c

@@ -9,9 +9,10 @@

 cleanname(char *name)

 {

 	char *p, *q, *dotdot;

-	int rooted;

+	int rooted, erasedprefix;

 	rooted = name[0] == '/';

+	erasedprefix = 0;

 	/*

 	 * invariants:

@@ -24,9 +25,11 @@

 	while(*p) {

 		if(p[0] == '/')	/* null element */

 			p++;

-		else if(p[0] == '.' && SEP(p[1]))

+		else if(p[0] == '.' && SEP(p[1])) {

+			if(p == name)

+				erasedprefix = 1;

 			p += 1;	/* don't count the separator in case it is nul */

-		else if(p[0] == '.' && p[1] == '.' && SEP(p[2])) {

+		} else if(p[0] == '.' && p[1] == '.' && SEP(p[2])) {

 			p += 2;

 			if(q > dotdot) {	/* can backtrack */

 				while(--q > dotdot && *q != '/')

@@ -38,6 +41,8 @@

 				*q++ = '.';

 				dotdot = q;

 			}

+			if(q == name)

+				erasedprefix = 1;	/* erased entire path via dotdot */

 		} else {	/* real path element */

 			if(q != name+rooted)

 				*q++ = '/';

@@ -48,5 +53,11 @@

 	if(q == name)	/* empty string is really ``.'' */

 		*q++ = '.';

 	*q = '\0';

+	if(erasedprefix && name[0] == '#'){

+		/* this was not a #x device path originally - make it not one now */

+		memmove(name+2, name, strlen(name)+1);

+		name[0] = '.';

+		name[1] = '/';

+	}

 	return name;

 }

--- a/libc/crypt.c

+++ b/libc/crypt.c

@@ -9,7 +9,6 @@

  */

 #include <u.h>

 #include <libc.h>

-#include <auth.h>

 #include <libsec.h>

 /*

--- a/libc/nrand.c

+++ b/libc/nrand.c

@@ -10,6 +10,9 @@

 	if(n < 0)

 		return n;

+	if(n == 1)

+		return 0;

+	/* and if n == 0, you deserve what you get */

 	slop = MASK % n;

 	do

 		v = lrand();

--- a/libc/rune.c

+++ b/libc/rune.c

@@ -1,24 +1,29 @@

 #include	<u.h>

 #include	<libc.h>

-#define Bit(i) (7-(i))

-/* N 0's preceded by i 1's, T(Bit(2)) is 1100 0000 */

-#define T(i) (((1 << (Bit(i)+1))-1) ^ 0xFF)

-/* 0000 0000 0000 0111 1111 1111 */

-#define	RuneX(i) ((1 << (Bit(i) + ((i)-1)*Bitx))-1)

-

 enum

 {

-	Bitx	= Bit(1),

+	Bit1	= 7,

+	Bitx	= 6,

+	Bit2	= 5,

+	Bit3	= 4,

+	Bit4	= 3,

+	Bit5	= 2,

-	Tx	= T(1),			/* 1000 0000 */

-	Rune1 = (1<<(Bit(0)+0*Bitx))-1,	/* 0000 0000 0000 0000 0111 1111 */

+	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */

+	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */

+	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */

+	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */

+	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */

+	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */

-	Maskx	= (1<<Bitx)-1,		/* 0011 1111 */

-	Testx	= Maskx ^ 0xFF,		/* 1100 0000 */

+	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0000 0000 0111 1111 */

+	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0000 0000 0111 1111 1111 */

+	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 0000 0000 1111 1111 1111 1111 */

+	Rune4	= (1<<(Bit4+3*Bitx))-1,		/* 0011 1111 1111 1111 1111 1111 */

-	SurrogateMin	= 0xD800,

-	SurrogateMax	= 0xDFFF,

+	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */

+	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */

 	Bad	= Runeerror,

 };

@@ -26,41 +31,67 @@

 int

 chartorune(Rune *rune, char *str)

 {

-	int c[UTFmax], i;

-	Rune l;

+	int c, c1, c2, c3;

+	long l;

 	/*

-	 * N character sequence

+	 * one character sequence

 	 *	00000-0007F => T1

-	 *	00080-007FF => T2 Tx

-	 *	00800-0FFFF => T3 Tx Tx

-	 *	10000-10FFFF => T4 Tx Tx Tx

 	 */

-

-	c[0] = *(uchar*)(str);

-	if(c[0] < Tx){

-		*rune = c[0];

+	c = *(uchar*)str;

+	if(c < Tx) {

+		*rune = c;

 		return 1;

 	}

-	l = c[0];

-	for(i = 1; i < UTFmax; i++) {

-		c[i] = *(uchar*)(str+i);

-		c[i] ^= Tx;

-		if(c[i] & Testx)

+	/*

+	 * two character sequence

+	 *	0080-07FF => T2 Tx

+	 */

+	c1 = *(uchar*)(str+1) ^ Tx;

+	if(c1 & Testx)

+		goto bad;

+	if(c < T3) {

+		if(c < T2)

 			goto bad;

-		l = (l << Bitx) | c[i];

-		if(c[0] < T(i + 2)) {

-			l &= RuneX(i + 1);

-			if(i == 1) {

-				if(c[0] < T(2) || l <= Rune1)

-					goto bad;

-			} else if(l <= RuneX(i) || l > Runemax)

+		l = ((c << Bitx) | c1) & Rune2;

+		if(l <= Rune1)

+			goto bad;

+		*rune = l;

+		return 2;

+	}

+

+	/*

+	 * three character sequence

+	 *	0800-FFFF => T3 Tx Tx

+	 */

+	c2 = *(uchar*)(str+2) ^ Tx;

+	if(c2 & Testx)

+		goto bad;

+	if(c < T4) {

+		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;

+		if(l <= Rune2)

+			goto bad;

+		*rune = l;

+		return 3;

+	}

+

+ 	/*

+	 * four character sequence

+	 *	10000-10FFFF => T4 Tx Tx Tx

+	 */

+	if(UTFmax >= 4) {

+		c3 = *(uchar*)(str+3) ^ Tx;

+		if(c3 & Testx)

+			goto bad;

+		if(c < T5) {

+			l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;

+			if(l <= Rune3)

 				goto bad;

-			if (i == 2 && SurrogateMin <= l && l <= SurrogateMax)

+			if(l > Runemax)

 				goto bad;

 			*rune = l;

-			return i + 1;

+			return 4;

 		}

 	}

@@ -75,10 +106,16 @@

 int

 runetochar(char *str, Rune *rune)

 {

-	int i, j;

-	Rune c;

+	long c;

 	c = *rune;

+	if(c > Runemax)

+		c = Runeerror;

+

+	/*

+	 * one character sequence

+	 *	00000-0007F => 00-7F

+	 */

 	if(c <= Rune1) {

 		str[0] = c;

 		return 1;

@@ -85,35 +122,35 @@

 	}

 	/*

-	 * one character sequence

-	 *	00000-0007F => 00-7F

 	 * two character sequence

 	 *	0080-07FF => T2 Tx

+	 */

+	if(c <= Rune2) {

+		str[0] = T2 | (c >> 1*Bitx);

+		str[1] = Tx | (c & Maskx);

+		return 2;

+	}

+

+	/*

 	 * three character sequence

 	 *	0800-FFFF => T3 Tx Tx

-	 * four character sequence (21-bit value)

-	 *     10000-1FFFFF => T4 Tx Tx Tx

-	 * If the Rune is out of range or a surrogate half,

-	 * convert it to the error rune.

-	 * Do this test when i==3 because the error rune encodes to three bytes.

-	 * Doing it earlier would duplicate work, since an out of range

-	 * Rune wouldn't have fit in one or two bytes.

 	 */

-	for(i = 2; i < UTFmax + 1; i++){

-		if(i == 3){

-			if(c > Runemax)

-				c = Runeerror;

-			if(SurrogateMin <= c && c <= SurrogateMax)

-				c = Runeerror;

-		}

-		if (c <= RuneX(i) || i == UTFmax ) {

-			str[0] = T(i) |  (c >> (i - 1)*Bitx);

-			for(j = 1; j < i; j++)

-				str[j] = Tx | ((c >> (i - j - 1)*Bitx) & Maskx);

-			return i;

-		}

+	if(c <= Rune3) {

+		str[0] = T3 |  (c >> 2*Bitx);

+		str[1] = Tx | ((c >> 1*Bitx) & Maskx);

+		str[2] = Tx |  (c & Maskx);

+		return 3;

 	}

-	return UTFmax;

+

+	/*

+	 * four character sequence

+	 *	10000-1FFFFF => T4 Tx Tx Tx

+	 */

+	str[0] = T4 |  (c >> 3*Bitx);

+	str[1] = Tx | ((c >> 2*Bitx) & Maskx);

+	str[2] = Tx | ((c >> 1*Bitx) & Maskx);

+	str[3] = Tx |  (c & Maskx);

+	return 4;

 }

 int

@@ -120,7 +157,7 @@

 runelen(long c)

 {

 	Rune rune;

-	char str[10];

+	char str[UTFmax];

 	rune = c;

 	return runetochar(str, &rune);

@@ -129,21 +166,21 @@

 int

 runenlen(Rune *r, int nrune)

 {

-	int nb, i;

-	Rune c;

+	int nb, c;

 	nb = 0;

 	while(nrune--) {

 		c = *r++;

-		if(c <= Rune1){

+		if(c <= Rune1)

 			nb++;

-		} else {

-			for(i = 2; i < UTFmax + 1; i++)

-				if(c <= RuneX(i) || i == UTFmax){

-					nb += i;

-					break;

-				}

-		}

+		else

+		if(c <= Rune2)

+			nb += 2;

+		else

+		if(c <= Rune3 || c > Runemax)

+			nb += 3;

+		else

+			nb += 4;

 	}

 	return nb;

 }

@@ -151,8 +188,7 @@

 int

 fullrune(char *str, int n)

 {

-	int  i;

-	Rune c;

+	int c;

 	if(n <= 0)

 		return 0;

@@ -159,8 +195,10 @@

 	c = *(uchar*)str;

 	if(c < Tx)

 		return 1;

-	for(i = 3; i < UTFmax + 1; i++)

-		if(c < T(i))

-			return n >= i - 1;

-	return n >= UTFmax;

+	if(c < T3)

+		return n >= 2;

+	if(UTFmax == 3 || c < T4)

+		return n >= 3;

+	return n >= 4;

 }

+

--- a/libc/runestrdup.c

+++ b/libc/runestrdup.c

@@ -2,13 +2,13 @@

 #include <libc.h>

 Rune*

-runestrdup(Rune *s) 

-{  

+runestrdup(Rune *s)

+{

 	Rune *ns;

 	ns = malloc(sizeof(Rune)*(runestrlen(s) + 1));

 	if(ns == 0)

 		return 0;

-

+	setmalloctag(ns, getcallerpc(&s));

 	return runestrcpy(ns, s);

 }

--- a/libc/runestrecpy.c

+++ b/libc/runestrecpy.c

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

 	while(*s1++ = *s2++){

 		if(s1 == es1){

-			*--s1 = '\0';

+			s1[-1] = '\0';

 			break;

 		}

 	}

-	return s1;

+	return s1-1;

 }

--- a/libc/runetype.c

+++ b/libc/runetype.c

@@ -211,9 +211,14 @@

 {

 	0x0009,	0x000a,	/* tab and newline */

 	0x0020,	0x0020,	/* space */

+	0x0085, 0x0085,

 	0x00a0,	0x00a0,	/*   */

+	0x1680, 0x1680,

+	0x180e, 0x180e,

 	0x2000,	0x200b,	/*   - ​ */

 	0x2028,	0x2029,	/* 
 - 
 */

+	0x202f, 0x202f,

+	0x205f, 0x205f,

 	0x3000,	0x3000,	/* 　 */

 	0xfeff,	0xfeff,	/*  */

 };

@@ -611,6 +616,34 @@

 	0x1ff3, 509,	/* ῳ ῼ */

 };

+static Rune __isdigitr[] = {

+	0x0030, 0x0039,

+	0x0660, 0x0669,

+	0x06f0, 0x06f9,

+	0x07c0, 0x07c9,

+	0x0966, 0x096f,

+	0x09e6, 0x09ef,

+	0x0a66, 0x0a6f,

+	0x0ae6, 0x0aef,

+	0x0b66, 0x0b6f,

+	0x0be6, 0x0bef,

+	0x0c66, 0x0c6f,

+	0x0ce6, 0x0cef,

+	0x0d66, 0x0d6f,

+	0x0e50, 0x0e59,

+	0x0ed0, 0x0ed9,

+	0x0f20, 0x0f29,

+	0x1040, 0x1049,

+	0x17e0, 0x17e9,

+	0x1810, 0x1819,

+	0x1946, 0x194f,

+	0x19d0, 0x19d9,

+	0x1b50, 0x1b59,

+	0xff10, 0xff19,

+	0x104a0, 0x104a9,

+	0x1d7ce, 0x1d7ff,

+};

+

 /*

  * upper case ranges

  *	3rd col is conversion excess 500

@@ -1132,6 +1165,17 @@

 	Rune *p;

 	p = bsearch(c, _space2, nelem(_space2)/2, 2);

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

+		return 1;

+	return 0;

+}

+

+int

+isdigitrune(Rune c)

+{

+	Rune *p;

+

+	p = bsearch(c, __isdigitr, nelem(__isdigitr)/2, 2);

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

 		return 1;

 	return 0;

--- a/libc/utfecpy.c

+++ b/libc/utfecpy.c

@@ -10,7 +10,7 @@

 		return to;

 	end = memccpy(to, from, '\0', e - to);

 	if(end == nil){

-		end = e-1;

+		end = e;

 		while(end>to && (*--end&0xC0)==0x80)

 			;

 		*end = '\0';