gdk_atoms.c

这个是内存数据库中的一个管理工具

				}
				break;
			case 'x':
				/* \x with one or two hexadecimal digits */
				if (num16(cur[1])) {
					cur++;
					c = base16(*cur);
					if (num16(cur[1])) {
						cur++;
						c = mult16(c) + base16(*cur);
					}
				} else
					c = 'x';
				break;
			case 'a':
				c = '\a';
				break;
			case 'b':
				c = '\b';
				break;
			case 'f':
				c = '\f';
				break;
			case 'n':
				c = '\n';
				break;
			case 'r':
				c = '\r';
				break;
			case 't':
				c = '\t';
				break;
			case '\0':
				c = '\\';
				break;
			case '\'':
			case '\\':
				/* \' and \\ can be handled by the default case */
			default:
				/* unrecognized \ escape, just copy the backslashed character */
				c = *cur;
				break;
			}
			escaped = FALSE;
		} else if (*cur == '\\') {
			escaped = TRUE;
			continue;
		} else {
			c = *cur;
		}
		if (n > 0) {
			/* we're still expecting follow-up bytes in a
			   UTF-8 sequence */
			if ((c & 0xC0) != 0x80) {
				/* incorrect UTF-8 sequence: byte is
				   not 10xxxxxx */
				return -1;
			}
			utf8char = (utf8char << 6) | (c & 0x3F);
			n--;
			if (n == 0) {
				/* this was the last byte in the sequence */
				if ((utf8char & mask) == 0) {
					/* incorrect UTF-8 sequence:
					   not shortest possible */
					return -1;
				}
			}
		} else if (c >= 0x80) {
			int m;

			/* start of multi-byte UTF-8 character */
			for (n = 0, m = 0x40; c & m; n++, m >>= 1)
				;
			/* n now is number of 10xxxxxx bytes that should follow */
			if (n == 0 || n >= 6) {
				/* incorrect UTF-8 sequence */
				/* n==0: c == 10xxxxxx */
				/* n>=6: c == 1111111x */
				return -1;
			}
			mask = utf8chkmsk[n];
			/* collect the Unicode code point in utf8char */
			utf8char = c & ~(0xFFC0 >> n);	/* remove non-x bits */
		}
		*p++ = c;
	}
	if (n > 0) {
		/* incomplete UTF-8 sequence */
		return -1;
	}
	*p++ = 0;
	return len;
}

int
strFromStr(char *src, int *len, char **dst)
{
	unsigned char *p, *start = NULL, *cur = (unsigned char *) src;
	ssize_t res;
	int l = 1, escaped = FALSE;

	while (GDKisspace(*cur))
		cur++;
	if (*cur != '"') {
		if (*dst != NULL && *dst != str_nil) {
			GDKfree(*dst);
		}
		*dst = GDKstrdup(str_nil);
		*len = 2;
		return strncmp((char *) cur, "nil", 3) ? 0 : (int) (((char *) cur + 3) - src);
	}

	/* scout the string to find out its length and whether it was properly quoted */
	for (start = ++cur; *cur != '"' || escaped; cur++) {
		if (*cur == 0) {
			goto error;
		} else if (*cur == '\\' && escaped == FALSE) {
			escaped = TRUE;
		} else {
			escaped = FALSE;
			l++;
		}
	}

	/* alloc new memory */
	p = (unsigned char *) *dst;
	if (p != NULL && (char *) p != str_nil && *len < l) {
		GDKfree(p);
		p = NULL;
	}
	if (p == NULL || (char *) p == str_nil)
		p = GDKmalloc(*len = l);
	*dst = (char *) p;

	assert(cur - start <= INT_MAX);	/* 64bit */
	if ((res = GDKstrFromStr((unsigned char *) *dst, start, cur - start)) >= 0)
		return (int) res;

  error:
	if (*dst && *dst != str_nil)
		GDKfree(*dst);
	*dst = GDKstrdup(str_nil);
	*len = 2;
	return 0;
}



#line 2275 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
/*
#define printable_chr(ch) ((ch)==0 || GDKisgraph((ch)) || GDKisspace((ch)) || \
		         GDKisspecial((ch)) || GDKisupperl((ch)) || GDKislowerl((ch)))
*/
/* all but control characters (in range 0 to 31) and DEL */
#ifdef ASCII_CHR
/* ASCII printable characters */
#define printable_chr(ch)	(' ' <= (ch) && (ch) <= '~')
#else
/* everything except ASCII control characters */
#define printable_chr(ch)	((' ' <= (ch) && (ch) <= '~') || ((ch) & 0x80) != 0)
#endif

int
strToStr(char **dst, int *len, char *src)
{
	int l = 1;

	if (GDK_STRNIL((str) src)) {
		
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (char *) GDKmalloc(*len = 4);
	} else if (*len < (int) 4) {
		GDKfree(*dst);
		*dst = (char *) GDKmalloc(*len = 4);
	}


#line 2294 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"


		strcpy(*dst, "nil");
		return 3;
	} else {
		char *s, *r = (char *) src;
		int cur = 0, end, sz = 0;

		for (end = 0; src[end]; end++)
			if (src[end] == '\t' || src[end] == '\n' || src[end] == '\\' || src[end] == '"') {
				sz += 2;
#ifndef ASCII_CHR
			} else if (src[end] == (char) '\302' &&
				   0200 <= ((int) src[end + 1] & 0377) &&
				   ((int) src[end + 1] & 0377) <= 0237) {
				/* Unicode control character (code
				   point range U-00000080 through
				   U-0000009F encoded in UTF-8 */
				/* for the first one of the two UTF-8
				   bytes we count a width of 7 and for
				   the second one 1, together that's
				   8, i.e. the width of two
				   backslash-escaped octal coded
				   characters */
				sz += 7;
#endif
			} else if (!printable_chr(src[end])) {
				sz += 4;
			} else {
				sz++;
			}
		
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (char *) GDKmalloc(*len = sz+3);
	} else if (*len < (int) sz+3) {
		GDKfree(*dst);
		*dst = (char *) GDKmalloc(*len = sz+3);
	}


#line 2325 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"


		for (s = *dst; cur < end; cur++)
			if (r[cur] == '\t') {
				s[l++] = '\\';
				s[l++] = 't';
			} else if (r[cur] == '\n') {
				s[l++] = '\\';
				s[l++] = 'n';
			} else if (r[cur] == '\\') {
				s[l++] = '\\';
				s[l++] = '\\';
			} else if (r[cur] == '"') {
				s[l++] = '\\';
				s[l++] = '"';
			} else if (!printable_chr(r[cur])
#ifndef ASCII_CHR
				   || (r[cur] == (char) '\302' &&
				       0200 <= ((int) r[cur + 1] & 0377) &&
				       ((int) r[cur + 1] & 0377) <= 0237)
				   || (cur > 0 &&
				       r[cur - 1] == (char) '\302' &&
				       0200 <= ((int) r[cur] & 0377) &&
				       ((int) r[cur] & 0377) <= 0237)
#endif
				) {
				sprintf(s + l, "\\%03o", (unsigned char) r[cur]);
				l += 4;
			} else {
				s[l++] = r[cur];
			}
		s[0] = s[l++] = '"';
		s[l] = 0;
	}
	return l;
}

str
strRead(str a, stream *s, size_t cnt)
{
	int len;

	(void) cnt;
	assert(cnt == 1);
	if (!stream_readInt(s, &len))
		return NULL;
	if ((a = GDKmalloc(len + 1)) == NULL)
		return NULL;
	if (len && stream_read(s, a, len, 1) != 1) {
		GDKfree(a);
		return NULL;
	}
	a[len] = 0;
	return a;
}

int
strWrite(str a, stream *s, size_t cnt)
{
	size_t len = strlen(a);

	(void) cnt;
	assert(cnt == 1);
	if (stream_writeInt(s, (int) len) && stream_write(s, a, len, 1) == 1)
		return GDK_SUCCEED;
	else
		return GDK_FAIL;
}



#line 2402 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"


#line 2403 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
oid	GDKoid, GDKflushed;


#line 2407 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
OIDinit(void)
{
	GDKflushed = GDKoid = 0;
	return 0;
}



#line 2417 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
oid
OIDrand(void)
{
	return 1000000;
}



#line 2426 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
oid
OIDbase(oid o)
{
	gdk_set_lock(MT_system_lock, "OIDbase");
	GDKoid = o;
	gdk_unset_lock(MT_system_lock, "OIDbase");
	return o;
}

oid
OIDseed(oid o)
{
	oid t, p = GDKoid;

	gdk_set_lock(MT_system_lock, "OIDseed");
	t = OIDrand();
	if (o > t)
		t = o;
	if (p >= t)
		t = p;
	gdk_unset_lock(MT_system_lock, "OIDseed");
	return t;
}



#line 2454 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
oid
OIDread(str s)
{
	oid new = 0, *p = &new;
	int l = sizeof(oid);

	while (GDKisspace(*s))
		s++;
	while (GDKisdigit(*s)) {
		s += OIDfromStr(s, &l, &p);
		while (GDKisspace(*s))
			s++;
		new = OIDseed(new);
	}
	return new;
}



#line 2474 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
OIDwrite(stream *s)
{
	int ret = 0;

	gdk_set_lock(MT_system_lock, "OIDwrite");
	if (GDKoid) {
		GDKflushed = GDKoid;
		ATOMprint(TYPE_oid, &GDKflushed, s);
		if (stream_errnr(s) || stream_write(s, " ", 1, 1) <= 0)
			ret = -1;
	}
	gdk_unset_lock(MT_system_lock, "OIDwrite");
	return ret;
}

int
OIDdirty(void)
{
	if (GDKoid && GDKoid > GDKflushed) {
		return TRUE;
	}
	return FALSE;
}



#line 2502 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
oid
OIDnew(size_t inc)
{
	oid ret;

	gdk_set_lock(MT_system_lock, "OIDnew");
	if (!GDKoid)
		GDKoid = OIDrand();
	ret = GDKoid;
	GDKoid += inc;
	gdk_unset_lock(MT_system_lock, "OIDnew");
	return ret;
}



#line 2519 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
int
OIDfromStr(char *src, int *len, oid **dst)
{
#if SIZEOF_OID == SIZEOF_INT
	int ui, *uip = &ui;
	int l = (int) sizeof(int);
#else
	lng ui, *uip = &ui;
	int l = (int) sizeof(lng);
#endif
	int pos = 0;
	str p = src;

	
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (oid *) GDKmalloc(*len = sizeof(oid));
	} else if (*len < (int) sizeof(oid)) {
		GDKfree(*dst);
		*dst = (oid *) GDKmalloc(*len = sizeof(oid));
	}


#line 2532 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"


	**dst = oid_nil;
	while (GDKisspace(*p))
		p++;
	if (GDKisdigit(*p)) {
#if SIZEOF_OID == SIZEOF_INT
		pos = intFromStr(p, &l, &uip);
#else
		pos = lngFromStr(p, &l, &uip);
#endif
		if (pos > 0 && p[pos] == '@') {
			while (GDKisdigit(p[pos]))
				pos++;
		}
		if (pos > 0 && ui >= 0) {
			**dst = ui;
		}
		p += pos;
	}
	return (int) (p - src);
}

int
OIDtoStr(char **dst, int *len, oid *src)
{
	
#line 1089 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
	if (!*dst) {
		*dst = (char *) GDKmalloc(*len = oidStrlen);
	} else if (*len < (int) oidStrlen) {
		GDKfree(*dst);
		*dst = (char *) GDKmalloc(*len = oidStrlen);
	}


#line 2558 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"


	if (*src == oid_nil) {
		strcpy(*dst, "nil");
		return 3;
	}
	snprintf(*dst, *len, SZFMT "@0", (size_t) * src);
	return (int) strlen(*dst);
}



#line 2586 "/export/scratch0/monet/monet.GNU.64.64.d.14791/MonetDB/src/gdk/gdk_atoms.mx"
static str unknown[MAXATOMS] = { NULL };

int 
ATOMunknown_add( str nme ) 
{
	int i = 1;
	for (;i<MAXATOMS; i++) {
		if (!unknown[i]) {
			unknown[i] = GDKstrdup(nme);
			return -i;
		}
	}
	assert(0);
	return 0;
}

int
ATOMunknown_del( int i) 
{
	assert(unknown[-i]);
	GDKfree(unknown[-i]);
	unknown[-i] = NULL;
	return 0;
}

int
ATOMunknown_find( str nme ) 
{
	int i = 1;
	for (;i<MAXATOMS; i++) {
		if (unknown[i] && strcmp(unknown[i], nme) == 0) {
			return -i;
		}
	}
	return ATOMunknown_add(nme);
}

str
ATOMunknown_name( int i )
{
	assert(unknown[-i]);
	return unknown[-i];
}