src/libhtml/utils.c - plan9 - Git at Google

 #include <u.h>
 #include <limits.h>
 #include <libc.h>
 #include <draw.h>
 #include <html.h>
 #include "impl.h"

 Rune whitespace[] = { ' ', '\t', '\n', '\r', '\0' };
 Rune notwhitespace[] = { '^', ' ', '\t', '\n', '\r' , '\0'};

 // All lists start out like List structure.
 // List itself can be used as list of int.
 int
 _listlen(List* l)
 {
 	int n = 0;

 	while(l != nil) {
 		l = l->next;
 		n++;
 	}
 	return n;
 }

 // Cons
 List*
 _newlist(int val, List* rest)
 {
 	List* ans;

 	ans = (List*)emalloc(sizeof(List));
 	ans->val = val;
 	ans->next = rest;
 	return ans;
 }

 // Reverse a list in place
 List*
 _revlist(List* l)
 {
 	List* newl;
 	List* nextl;

 	newl = nil;
 	while(l != nil) {
 		nextl = l->next;
 		l->next = newl;
 		newl = l;
 		l = nextl;
 	}
 	return newl;
 }

 // The next few routines take a "character class" as argument.
 //    e.g., "a-zA-Z", or "^ \t\n"
 // (ranges indicated by - except in first position;
 //  ^ is first position means "not in" the following class)

 // Splitl splits s[0:n] just before first character of class cl.
 // Answers go in (p1, n1) and (p2, n2).
 // If no split, the whole thing goes in the first component.
 // Note: answers contain pointers into original string.
 void
 _splitl(Rune* s, int n, Rune* cl, Rune** p1, int* n1, Rune** p2, int* n2)
 {
 	Rune* p;

 	p = _Strnclass(s, cl, n);
 	*p1 = s;
 	if(p == nil) {
 		*n1 = n;
 		*p2 = nil;
 		*n2 = 0;
 	}
 	else {
 		*p2 = p;
 		*n1 = p-s;
 		*n2 = n-*n1;
 	}
 }

 // Splitr splits s[0:n] just after last character of class cl.
 // Answers go in (p1, n1) and (p2, n2).
 // If no split, the whole thing goes in the last component.
 // Note: answers contain pointers into original string.
 void
 _splitr(Rune* s, int n, Rune* cl, Rune** p1, int* n1, Rune** p2, int* n2)
 {
 	Rune* p;

 	p = _Strnrclass(s, cl, n);
 	if(p == nil) {
 		*p1 = nil;
 		*n1 = 0;
 		*p2 = s;
 		*n2 = n;
 	}
 	else {
 		*p1 = s;
 		*p2 = p+1;
 		*n1 = *p2-s;
 		*n2 = n-*n1;
 	}
 }

 // Splitall splits s[0:n] into parts that are separated by characters from class cl.
 // Each part will have nonzero length.
 // At most alen parts are found, and pointers to their starts go into
 // the strarr array, while their lengths go into the lenarr array.
 // The return value is the number of parts found.
 int
 _splitall(Rune* s, int n, Rune* cl, Rune** strarr, int* lenarr, int alen)
 {
 	int i;
 	Rune* p;
 	Rune* q;
 	Rune* slast;

 	if(s == nil || n == 0)
 		return 0;
 	i = 0;
 	p = s;
 	slast = s+n;
 	while(p < slast && i < alen) {
 		while(p < slast && _inclass(*p, cl))
 			p++;
 		if(p == slast)
 			break;
 		q = _Strnclass(p, cl, slast-p);
 		if(q == nil)
 			q = slast;
 		assert(q > p && q <= slast);
 		strarr[i] = p;
 		lenarr[i] = q-p;
 		i++;
 		p = q;
 	}
 	return i;
 }

 // Find part of s that excludes leading and trailing whitespace,
 // and return that part in *pans (and its length in *panslen).
 void
 _trimwhite(Rune* s, int n, Rune** pans, int* panslen)
 {
 	Rune* p;
 	Rune* q;

 	p = nil;
 	if(n > 0) {
 		p = _Strnclass(s, notwhitespace, n);
 		if(p != nil) {
 			q = _Strnrclass(s, notwhitespace, n);
 			assert(q != nil);
 			n = q+1-p;
 		}
 	}
 	*pans = p;
 	*panslen = n;
 }

 // _Strclass returns a pointer to the first element of s that is
 // a member of class cl, nil if none.
 Rune*
 _Strclass(Rune* s, Rune* cl)
 {
 	Rune* p;

 	for(p = s; *p != 0; p++)
 		if(_inclass(*p, cl))
 			return p;
 	return nil;
 }

 // _Strnclass returns a pointer to the first element of s[0:n] that is
 // a member of class cl, nil if none.
 Rune*
 _Strnclass(Rune* s, Rune* cl, int n)
 {
 	Rune* p;

 	for(p = s; n-- && *p != 0; p++)
 		if(_inclass(*p, cl))
 			return p;
 	return nil;
 }

 // _Strrclass returns a pointer to the last element of s that is
 // a member of class cl, nil if none
 Rune*
 _Strrclass(Rune* s, Rune* cl)
 {
 	Rune* p;

 	if(s == nil || *s == 0)
 		return nil;
 	p = s + runestrlen(s) - 1;
 	while(p >= s) {
 		if(_inclass(*p, cl))
 			return p;
 		p--;
 	};
 	return nil;
 }

 // _Strnrclass returns a pointer to the last element of s[0:n] that is
 // a member of class cl, nil if none
 Rune*
 _Strnrclass(Rune* s, Rune* cl, int n)
 {
 	Rune* p;

 	if(s == nil || *s == 0 || n == 0)
 		return nil;
 	p = s + n - 1;
 	while(p >= s) {
 		if(_inclass(*p, cl))
 			return p;
 		p--;
 	};
 	return nil;
 }

 // Is c in the class cl?
 int
 _inclass(Rune c, Rune* cl)
 {
 	int	n;
 	int	ans;
 	int	negate;
 	int	i;

 	n = _Strlen(cl);
 	if(n == 0)
 		return 0;
 	ans = 0;
 	negate = 0;
 	if(cl[0] == '^') {
 		negate = 1;
 		cl++;
 		n--;
 	}
 	for(i = 0; i < n; i++) {
 		if(cl[i] == '-' && i > 0 && i < n - 1) {
 			if(c >= cl[i - 1] && c <= cl[i + 1]) {
 				ans = 1;
 				break;
 			}
 			i++;
 		}
 		else if(c == cl[i]) {
 			ans = 1;
 			break;
 		}
 	}
 	if(negate)
 		ans = !ans;
 	return ans;
 }

 // Is pre a prefix of s?
 int
 _prefix(Rune* pre, Rune* s)
 {
 	int	ns;
 	int	n;
 	int	k;

 	ns = _Strlen(s);
 	n = _Strlen(pre);
 	if(ns < n)
 		return 0;
 	for(k = 0; k < n; k++) {
 		if(pre[k] != s[k])
 			return 0;
 	}
 	return 1;
 }

 // Number of runes in (null-terminated) s
 int
 _Strlen(Rune* s)
 {
 	if(s == nil)
 		return 0;
 	return runestrlen(s);
 }

 // -1, 0, 1 as s1 is lexicographically less, equal greater than s2
 int
 _Strcmp(Rune *s1, Rune *s2)
 {
 	if(s1 == nil)
 		return (s2 == nil || *s2 == 0) ? 0 : -1;
 	if(s2 == nil)
 		return (*s1 == 0) ? 0 : 1;
 	return runestrcmp(s1, s2);
 }

 // Like Strcmp, but use exactly n chars of s1 (assume s1 has at least n chars).
 // Also, do a case-insensitive match, assuming s2
 // has no chars in [A-Z], only their lowercase versions.
 // (This routine is used for in-place keyword lookup, where s2 is in a keyword
 // list and s1 is some substring, possibly mixed-case, in a buffer.)
 int
 _Strncmpci(Rune *s1, int n1, Rune *s2)
 {
 	Rune c1, c2;

 	for(;;) {
 		if(n1-- == 0) {
 			if(*s2 == 0)
 				return 0;
 			return -1;
 		}
 		c1 = *s1++;
 		c2 = *s2++;
 		if(c1 >= 'A' && c1 <= 'Z')
 			c1 = c1 - 'A' + 'a';
 		if(c1 != c2) {
 			if(c1 > c2)
 				return 1;
 			return -1;
 		}
 	}
 }

 // emalloc and copy
 Rune*
 _Strdup(Rune* s)
 {
 	if(s == nil)
 		return nil;
 	return _Strndup(s, runestrlen(s));
 }

 // emalloc and copy n chars of s (assume s is at least that long),
 // and add 0 terminator.
 // Return nil if n==0.
 Rune*
 _Strndup(Rune* s, int n)
 {
 	Rune* ans;

 	if(n <= 0)
 		return nil;
 	ans = _newstr(n);
 	memmove(ans, s, n*sizeof(Rune));
 	ans[n] = 0;
 	return ans;
 }
 // emalloc enough room for n Runes, plus 1 null terminator.
 // (Not initialized to anything.)
 Rune*
 _newstr(int n)
 {
 	return (Rune*)emalloc((n+1)*sizeof(Rune));
 }

 // emalloc and copy s+t
 Rune*
 _Strdup2(Rune* s, Rune* t)
 {
 	int ns, nt;
 	Rune* ans;
 	Rune* p;

 	ns = _Strlen(s);
 	nt = _Strlen(t);
 	if(ns+nt == 0)
 		return nil;
 	ans = _newstr(ns+nt);
 	p = _Stradd(ans, s, ns);
 	p = _Stradd(p, t, nt);
 	*p = 0;
 	return ans;
 }

 // Return emalloc'd substring s[start:stop],
 Rune*
 _Strsubstr(Rune* s, int start, int stop)
 {
 	Rune* t;

 	if(start == stop)
 		return nil;
 	t = _Strndup(s+start, stop-start);
 	return t;
 }

 // Copy n chars to s1 from s2, and return s1+n
 Rune*
 _Stradd(Rune* s1, Rune* s2, int n)
 {
 	if(n == 0)
 		return s1;
 	memmove(s1, s2, n*sizeof(Rune));
 	return s1+n;
 }

 // Like strtol, but converting from Rune* string

 //#define LONG_MAX	2147483647L
 //#define LONG_MIN	-2147483648L

 long
 _Strtol(Rune* nptr, Rune** endptr, int base)
 {
 	Rune* p;
 	long n, nn;
 	int c, ovfl, v, neg, ndig;

 	p = nptr;
 	neg = 0;
 	n = 0;
 	ndig = 0;
 	ovfl = 0;

 	/*
 	 * White space
 	 */
 	for(;;p++){
 		switch(*p){
 		case ' ':
 		case '\t':
 		case '\n':
 		case '\f':
 		case '\r':
 		case '\v':
 			continue;
 		}
 		break;
 	}

 	/*
 	 * Sign
 	 */
 	if(*p=='-' || *p=='+')
 		if(*p++ == '-')
 			neg = 1;

 	/*
 	 * Base
 	 */
 	if(base==0){
 		if(*p != '0')
 			base = 10;
 		else{
 			base = 8;
 			if(p[1]=='x' || p[1]=='X'){
 				p += 2;
 				base = 16;
 			}
 		}
 	}else if(base==16 && *p=='0'){
 		if(p[1]=='x' || p[1]=='X')
 			p += 2;
 	}else if(base<0 || 36<base)
 		goto Return;

 	/*
 	 * Non-empty sequence of digits
 	 */
 	for(;; p++,ndig++){
 		c = *p;
 		v = base;
 		if('0'<=c && c<='9')
 			v = c - '0';
 		else if('a'<=c && c<='z')
 			v = c - 'a' + 10;
 		else if('A'<=c && c<='Z')
 			v = c - 'A' + 10;
 		if(v >= base)
 			break;
 		nn = n*base + v;
 		if(nn < n)
 			ovfl = 1;
 		n = nn;
 	}

     Return:
 	if(ndig == 0)
 		p = nptr;
 	if(endptr)
 		*endptr = p;
 	if(ovfl){
 		if(neg)
 			return LONG_MIN;
 		return LONG_MAX;
 	}
 	if(neg)
 		return -n;
 	return n;
 }

 // Convert buf[0:n], bytes whose character set is chset,
 // into a emalloc'd null-terminated Unicode string.
 Rune*
 toStr(uchar* buf, int n, int chset)
 {
 	int i;
 	int m;
 	Rune ch;
 	Rune* ans;

 	switch(chset) {
 	case US_Ascii:
 	case ISO_8859_1:
 		ans = (Rune*)emalloc((n+1)*sizeof(Rune));
 		for(i = 0; i < n; i++)
 			ans[i] = buf[i];
 		ans[n] = 0;
 		break;

 	case UTF_8:
 		m = 0;
 		for(i = 0; i < n; ) {
 			i += chartorune(&ch, (char*)(buf+i));
 			m++;
 		}
 		ans = (Rune*)emalloc((m+1)*sizeof(Rune));
 		m = 0;
 		for(i = 0; i < n; ) {
 			i += chartorune(&ch, (char*)(buf+i));
 			ans[m++] = ch;
 		}
 		ans[m] = 0;
 		break;

 	default:
 		ans = nil;
 		assert(0);
 	}
 	return ans;
 }

 // Convert buf[0:n], Unicode characters,
 // into an emalloc'd null-terminated string in character set chset.
 // Use 0x80 for unconvertable characters.
 uchar*
 fromStr(Rune* buf, int n, int chset)
 {
 	uchar* ans;
 	int i, lim, m;
 	Rune ch;
 	uchar* p;
 	uchar s[UTFmax];

 	ans = nil;
 	switch(chset) {
 	case US_Ascii:
 	case ISO_8859_1:
 		ans = (uchar*)emalloc(n+1);
 		lim = (chset==US_Ascii)? 127 : 255;
 		for(i = 0; i < n; i++) {
 			ch = buf[i];
 			if(ch > lim)
 				ch = 0x80;
 			ans[i] = ch;
 		}
 		ans[n] = 0;
 		break;

 	case UTF_8:
 		m = 0;
 		for(i = 0; i < n; i++) {
 			m += runetochar((char*)s, &buf[i]);
 		}
 		ans = (uchar*)emalloc(m+1);
 		p = ans;
 		for(i = 0; i < n; i++)
 			p += runetochar((char*)p, &buf[i]);
 		*p = 0;
 		break;

 	default:
 		assert(0);
 	}
 	return ans;

 }

 // Convert n to emalloc'd String.
 Rune*
 _ltoStr(int n)
 {
 	int m;
 	uchar buf[20];

 	m = snprint((char*)buf, sizeof(buf), "%d", n);
 	return toStr(buf, m, US_Ascii);
 }
	#include <u.h>
	#include <limits.h>
	#include <libc.h>
	#include <draw.h>
	#include <html.h>
	#include "impl.h"

	Rune whitespace[] = { ' ', '\t', '\n', '\r', '\0' };
	Rune notwhitespace[] = { '^', ' ', '\t', '\n', '\r' , '\0'};

	// All lists start out like List structure.
	// List itself can be used as list of int.
	int
	_listlen(List* l)
	{
	int n = 0;

	while(l != nil) {
	l = l->next;
	n++;
	}
	return n;
	}

	// Cons
	List*
	_newlist(int val, List* rest)
	{
	List* ans;

	ans = (List*)emalloc(sizeof(List));
	ans->val = val;
	ans->next = rest;
	return ans;
	}

	// Reverse a list in place
	List*
	_revlist(List* l)
	{
	List* newl;
	List* nextl;

	newl = nil;
	while(l != nil) {
	nextl = l->next;
	l->next = newl;
	newl = l;
	l = nextl;
	}
	return newl;
	}

	// The next few routines take a "character class" as argument.
	// e.g., "a-zA-Z", or "^ \t\n"
	// (ranges indicated by - except in first position;
	// ^ is first position means "not in" the following class)

	// Splitl splits s[0:n] just before first character of class cl.
	// Answers go in (p1, n1) and (p2, n2).
	// If no split, the whole thing goes in the first component.
	// Note: answers contain pointers into original string.
	void
	_splitl(Rune* s, int n, Rune* cl, Rune** p1, int* n1, Rune** p2, int* n2)
	{
	Rune* p;

	p = _Strnclass(s, cl, n);
	*p1 = s;
	if(p == nil) {
	*n1 = n;
	*p2 = nil;
	*n2 = 0;
	}
	else {
	*p2 = p;
	*n1 = p-s;
	n2 = n-n1;
	}
	}

	// Splitr splits s[0:n] just after last character of class cl.
	// Answers go in (p1, n1) and (p2, n2).
	// If no split, the whole thing goes in the last component.
	// Note: answers contain pointers into original string.
	void
	_splitr(Rune* s, int n, Rune* cl, Rune** p1, int* n1, Rune** p2, int* n2)
	{
	Rune* p;

	p = _Strnrclass(s, cl, n);
	if(p == nil) {
	*p1 = nil;
	*n1 = 0;
	*p2 = s;
	*n2 = n;
	}
	else {
	*p1 = s;
	*p2 = p+1;
	n1 = p2-s;
	n2 = n-n1;
	}
	}

	// Splitall splits s[0:n] into parts that are separated by characters from class cl.
	// Each part will have nonzero length.
	// At most alen parts are found, and pointers to their starts go into
	// the strarr array, while their lengths go into the lenarr array.
	// The return value is the number of parts found.
	int
	_splitall(Rune* s, int n, Rune* cl, Rune** strarr, int* lenarr, int alen)
	{
	int i;
	Rune* p;
	Rune* q;
	Rune* slast;

	if(s == nil \|\| n == 0)
	return 0;
	i = 0;
	p = s;
	slast = s+n;
	while(p < slast && i < alen) {
	while(p < slast && _inclass(*p, cl))
	p++;
	if(p == slast)
	break;
	q = _Strnclass(p, cl, slast-p);
	if(q == nil)
	q = slast;
	assert(q > p && q <= slast);
	strarr[i] = p;
	lenarr[i] = q-p;
	i++;
	p = q;
	}
	return i;
	}

	// Find part of s that excludes leading and trailing whitespace,
	// and return that part in pans (and its length in panslen).
	void
	_trimwhite(Rune* s, int n, Rune** pans, int* panslen)
	{
	Rune* p;
	Rune* q;

	p = nil;
	if(n > 0) {
	p = _Strnclass(s, notwhitespace, n);
	if(p != nil) {
	q = _Strnrclass(s, notwhitespace, n);
	assert(q != nil);
	n = q+1-p;
	}
	}
	*pans = p;
	*panslen = n;
	}

	// _Strclass returns a pointer to the first element of s that is
	// a member of class cl, nil if none.
	Rune*
	_Strclass(Rune* s, Rune* cl)
	{
	Rune* p;

	for(p = s; *p != 0; p++)
	if(_inclass(*p, cl))
	return p;
	return nil;
	}

	// _Strnclass returns a pointer to the first element of s[0:n] that is
	// a member of class cl, nil if none.
	Rune*
	_Strnclass(Rune* s, Rune* cl, int n)
	{
	Rune* p;

	for(p = s; n-- && *p != 0; p++)
	if(_inclass(*p, cl))
	return p;
	return nil;
	}

	// _Strrclass returns a pointer to the last element of s that is
	// a member of class cl, nil if none
	Rune*
	_Strrclass(Rune* s, Rune* cl)
	{
	Rune* p;

	if(s == nil \|\| *s == 0)
	return nil;
	p = s + runestrlen(s) - 1;
	while(p >= s) {
	if(_inclass(*p, cl))
	return p;
	p--;
	};
	return nil;
	}

	// _Strnrclass returns a pointer to the last element of s[0:n] that is
	// a member of class cl, nil if none
	Rune*
	_Strnrclass(Rune* s, Rune* cl, int n)
	{
	Rune* p;

	if(s == nil \|\| *s == 0 \|\| n == 0)
	return nil;
	p = s + n - 1;
	while(p >= s) {
	if(_inclass(*p, cl))
	return p;
	p--;
	};
	return nil;
	}

	// Is c in the class cl?
	int
	_inclass(Rune c, Rune* cl)
	{
	int n;
	int ans;
	int negate;
	int i;

	n = _Strlen(cl);
	if(n == 0)
	return 0;
	ans = 0;
	negate = 0;
	if(cl[0] == '^') {
	negate = 1;
	cl++;
	n--;
	}
	for(i = 0; i < n; i++) {
	if(cl[i] == '-' && i > 0 && i < n - 1) {
	if(c >= cl[i - 1] && c <= cl[i + 1]) {
	ans = 1;
	break;
	}
	i++;
	}
	else if(c == cl[i]) {
	ans = 1;
	break;
	}
	}
	if(negate)
	ans = !ans;
	return ans;
	}

	// Is pre a prefix of s?
	int
	_prefix(Rune* pre, Rune* s)
	{
	int ns;
	int n;
	int k;

	ns = _Strlen(s);
	n = _Strlen(pre);
	if(ns < n)
	return 0;
	for(k = 0; k < n; k++) {
	if(pre[k] != s[k])
	return 0;
	}
	return 1;
	}

	// Number of runes in (null-terminated) s
	int
	_Strlen(Rune* s)
	{
	if(s == nil)
	return 0;
	return runestrlen(s);
	}

	// -1, 0, 1 as s1 is lexicographically less, equal greater than s2
	int
	_Strcmp(Rune s1, Rune s2)
	{
	if(s1 == nil)
	return (s2 == nil \|\| *s2 == 0) ? 0 : -1;
	if(s2 == nil)
	return (*s1 == 0) ? 0 : 1;
	return runestrcmp(s1, s2);
	}

	// Like Strcmp, but use exactly n chars of s1 (assume s1 has at least n chars).
	// Also, do a case-insensitive match, assuming s2
	// has no chars in [A-Z], only their lowercase versions.
	// (This routine is used for in-place keyword lookup, where s2 is in a keyword
	// list and s1 is some substring, possibly mixed-case, in a buffer.)
	int
	_Strncmpci(Rune s1, int n1, Rune s2)
	{
	Rune c1, c2;

	for(;;) {
	if(n1-- == 0) {
	if(*s2 == 0)
	return 0;
	return -1;
	}
	c1 = *s1++;
	c2 = *s2++;
	if(c1 >= 'A' && c1 <= 'Z')
	c1 = c1 - 'A' + 'a';
	if(c1 != c2) {
	if(c1 > c2)
	return 1;
	return -1;
	}
	}
	}

	// emalloc and copy
	Rune*
	_Strdup(Rune* s)
	{
	if(s == nil)
	return nil;
	return _Strndup(s, runestrlen(s));
	}

	// emalloc and copy n chars of s (assume s is at least that long),
	// and add 0 terminator.
	// Return nil if n==0.
	Rune*
	_Strndup(Rune* s, int n)
	{
	Rune* ans;

	if(n <= 0)
	return nil;
	ans = _newstr(n);
	memmove(ans, s, n*sizeof(Rune));
	ans[n] = 0;
	return ans;
	}
	// emalloc enough room for n Runes, plus 1 null terminator.
	// (Not initialized to anything.)
	Rune*
	_newstr(int n)
	{
	return (Rune)emalloc((n+1)sizeof(Rune));
	}

	// emalloc and copy s+t
	Rune*
	_Strdup2(Rune* s, Rune* t)
	{
	int ns, nt;
	Rune* ans;
	Rune* p;

	ns = _Strlen(s);
	nt = _Strlen(t);
	if(ns+nt == 0)
	return nil;
	ans = _newstr(ns+nt);
	p = _Stradd(ans, s, ns);
	p = _Stradd(p, t, nt);
	*p = 0;
	return ans;
	}

	// Return emalloc'd substring s[start:stop],
	Rune*
	_Strsubstr(Rune* s, int start, int stop)
	{
	Rune* t;

	if(start == stop)
	return nil;
	t = _Strndup(s+start, stop-start);
	return t;
	}

	// Copy n chars to s1 from s2, and return s1+n
	Rune*
	_Stradd(Rune* s1, Rune* s2, int n)
	{
	if(n == 0)
	return s1;
	memmove(s1, s2, n*sizeof(Rune));
	return s1+n;
	}

	// Like strtol, but converting from Rune* string

	//#define LONG_MAX 2147483647L
	//#define LONG_MIN -2147483648L

	long
	_Strtol(Rune* nptr, Rune** endptr, int base)
	{
	Rune* p;
	long n, nn;
	int c, ovfl, v, neg, ndig;

	p = nptr;
	neg = 0;
	n = 0;
	ndig = 0;
	ovfl = 0;

	/*
	* White space
	*/
	for(;;p++){
	switch(*p){
	case ' ':
	case '\t':
	case '\n':
	case '\f':
	case '\r':
	case '\v':
	continue;
	}
	break;
	}

	/*
	* Sign
	*/
	if(p=='-' \|\| p=='+')
	if(*p++ == '-')
	neg = 1;

	/*
	* Base
	*/
	if(base==0){
	if(*p != '0')
	base = 10;
	else{
	base = 8;
	if(p[1]=='x' \|\| p[1]=='X'){
	p += 2;
	base = 16;
	}
	}
	}else if(base==16 && *p=='0'){
	if(p[1]=='x' \|\| p[1]=='X')
	p += 2;
	}else if(base<0 \|\| 36<base)
	goto Return;

	/*
	* Non-empty sequence of digits
	*/
	for(;; p++,ndig++){
	c = *p;
	v = base;
	if('0'<=c && c<='9')
	v = c - '0';
	else if('a'<=c && c<='z')
	v = c - 'a' + 10;
	else if('A'<=c && c<='Z')
	v = c - 'A' + 10;
	if(v >= base)
	break;
	nn = n*base + v;
	if(nn < n)
	ovfl = 1;
	n = nn;
	}

	Return:
	if(ndig == 0)
	p = nptr;
	if(endptr)
	*endptr = p;
	if(ovfl){
	if(neg)
	return LONG_MIN;
	return LONG_MAX;
	}
	if(neg)
	return -n;
	return n;
	}

	// Convert buf[0:n], bytes whose character set is chset,
	// into a emalloc'd null-terminated Unicode string.
	Rune*
	toStr(uchar* buf, int n, int chset)
	{
	int i;
	int m;
	Rune ch;
	Rune* ans;

	switch(chset) {
	case US_Ascii:
	case ISO_8859_1:
	ans = (Rune)emalloc((n+1)sizeof(Rune));
	for(i = 0; i < n; i++)
	ans[i] = buf[i];
	ans[n] = 0;
	break;

	case UTF_8:
	m = 0;
	for(i = 0; i < n; ) {
	i += chartorune(&ch, (char*)(buf+i));
	m++;
	}
	ans = (Rune)emalloc((m+1)sizeof(Rune));
	m = 0;
	for(i = 0; i < n; ) {
	i += chartorune(&ch, (char*)(buf+i));
	ans[m++] = ch;
	}
	ans[m] = 0;
	break;

	default:
	ans = nil;
	assert(0);
	}
	return ans;
	}

	// Convert buf[0:n], Unicode characters,
	// into an emalloc'd null-terminated string in character set chset.
	// Use 0x80 for unconvertable characters.
	uchar*
	fromStr(Rune* buf, int n, int chset)
	{
	uchar* ans;
	int i, lim, m;
	Rune ch;
	uchar* p;
	uchar s[UTFmax];

	ans = nil;
	switch(chset) {
	case US_Ascii:
	case ISO_8859_1:
	ans = (uchar*)emalloc(n+1);
	lim = (chset==US_Ascii)? 127 : 255;
	for(i = 0; i < n; i++) {
	ch = buf[i];
	if(ch > lim)
	ch = 0x80;
	ans[i] = ch;
	}
	ans[n] = 0;
	break;

	case UTF_8:
	m = 0;
	for(i = 0; i < n; i++) {
	m += runetochar((char*)s, &buf[i]);
	}
	ans = (uchar*)emalloc(m+1);
	p = ans;
	for(i = 0; i < n; i++)
	p += runetochar((char*)p, &buf[i]);
	*p = 0;
	break;

	default:
	assert(0);
	}
	return ans;

	}

	// Convert n to emalloc'd String.
	Rune*
	_ltoStr(int n)
	{
	int m;
	uchar buf[20];

	m = snprint((char*)buf, sizeof(buf), "%d", n);
	return toStr(buf, m, US_Ascii);
	}