[apple/xnu.git] / libkern / c++ / OSUnserialize.y

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

/*  OSUnserialize.y created by rsulack on Nov 21 1998 */

// 		"classic" parser for unserializing OSContainer objects
//
//  XXX - this code should really be removed!
//	- the XML format is now prefered
//	- this code leaks on syntax errors, the XML doesn't
//	- "classic" looks, reads, ... much better than XML :-(
//	- well except the XML is more efficent on OSData
//
//
// to build :
//	bison -p OSUnserialize OSUnserialize.y
//	head -50 OSUnserialize.y > OSUnserialize.cpp
//	sed -e "s/stdio.h/stddef.h/" < OSUnserialize.tab.c >> OSUnserialize.cpp
//
//	when changing code check in both OSUnserialize.y and OSUnserialize.cpp
//
//
//
//
//		 DO NOT EDIT OSUnserialize.tab.cpp!
//
//			this means you!
//
//
//
//
//

     
%{
#include <libkern/c++/OSMetaClass.h>
#include <libkern/c++/OSContainers.h>
#include <libkern/c++/OSLib.h>

typedef	struct object {
	struct object	*next;
	struct object	*prev;
	void		*object;
	int		size;		// for data
	union {
		void	*key;		// for dictionary
		long long offset;	// for offset
	} u;

} object_t;

static int yyerror(const char *s);
static int yylex();

static object_t * newObject();
static void freeObject(object_t *o);

static OSObject *buildOSDictionary(object_t *);
static OSObject *buildOSArray(object_t *);
static OSObject *buildOSSet(object_t *);
static OSObject *buildOSString(object_t *);
static OSObject *buildOSData(object_t *);
static OSObject *buildOSOffset(object_t *);
static OSObject *buildOSBoolean(object_t *o);

static void rememberObject(int, object_t *);
static OSObject *retrieveObject(int);

// temp variable to use during parsing
static object_t *oo;

// resultant object of parsed text
static OSObject	*parsedObject;

#define YYSTYPE object_t *

#include <libkern/OSRuntime.h>

#define malloc(s) kern_os_malloc(s)
#define realloc(a, s) kern_os_realloc(a, s)
#define free(a) kern_os_free(a)

%}
%token NUMBER
%token STRING
%token DATA
%token BOOLEAN
%token SYNTAX_ERROR
     
%% /* Grammar rules and actions follow */

input:	  /* empty */		{ parsedObject = (OSObject *)NULL; YYACCEPT; }
	| object		{ parsedObject = (OSObject *)$1;   YYACCEPT; }
	| SYNTAX_ERROR		{ yyerror("syntax error");	   YYERROR; }
	;

object:	  dict			{ $$ = (object_t *)buildOSDictionary($1); }
	| array			{ $$ = (object_t *)buildOSArray($1); }
	| set			{ $$ = (object_t *)buildOSSet($1); }
	| string		{ $$ = (object_t *)buildOSString($1); }
	| data			{ $$ = (object_t *)buildOSData($1); }
	| offset		{ $$ = (object_t *)buildOSOffset($1); }
	| boolean		{ $$ = (object_t *)buildOSBoolean($1); }
	| '@' NUMBER		{ $$ = (object_t *)retrieveObject($2->u.offset);
				  if ($$) {
				    ((OSObject *)$$)->retain();
				  } else { 
				    yyerror("forward reference detected");
				    YYERROR;
				  }
				  freeObject($2); 
				}
	| object '@' NUMBER	{ $$ = $1; 
				  rememberObject($3->u.offset, $1);
				  freeObject($3); 
				}
	;

//------------------------------------------------------------------------------

dict:	  '{' '}'		{ $$ = NULL; }
	| '{' pairs '}'		{ $$ = $2; }
	;

pairs:	  pair
	| pairs pair		{ $2->next = $1; $1->prev = $2; $$ = $2; }
	;

pair:	  object '=' object ';'	{ $$ = newObject();
				  $$->next = NULL; 
				  $$->prev = NULL;
				  $$->u.key = $1;
				  $$->object = $3; 
				}
	;

//------------------------------------------------------------------------------

array:	  '(' ')'		{ $$ = NULL; }
	| '(' elements ')'	{ $$ = $2; }
	;

set:	  '[' ']'		{ $$ = NULL; }
	| '[' elements ']'	{ $$ = $2; }
	;

elements: object		{ $$ = newObject(); 
				  $$->object = $1; 
				  $$->next = NULL; 
				  $$->prev = NULL; 
				}
	| elements ',' object	{ oo = newObject();
				  oo->object = $3;
				  oo->next = $1;
				  oo->prev = NULL; 
				  $1->prev = oo;
				  $$ = oo; 
				}
	;

//------------------------------------------------------------------------------

offset:	  NUMBER ':' NUMBER	{ $$ = $1;
				  $$->size = $3->u.offset;
				  freeObject($3); 
				}
	;

//------------------------------------------------------------------------------

data:	  DATA
	;

//------------------------------------------------------------------------------

string:	  STRING
	;

//------------------------------------------------------------------------------

boolean:  BOOLEAN
	;

%%
     
static int		lineNumber = 0;
static const char	*parseBuffer;
static int		parseBufferIndex;

#define currentChar()	(parseBuffer[parseBufferIndex])
#define nextChar()	(parseBuffer[++parseBufferIndex])
#define prevChar()	(parseBuffer[parseBufferIndex - 1])

#define isSpace(c)	((c) == ' ' || (c) == '\t')
#define isAlpha(c)	(((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
#define isDigit(c)	((c) >= '0' && (c) <= '9')
#define isAlphaDigit(c)	((c) >= 'a' && (c) <= 'f')
#define isHexDigit(c)	(isDigit(c) || isAlphaDigit(c))
#define isAlphaNumeric(c) (isAlpha(c) || isDigit(c) || ((c) == '-')) 

static char yyerror_message[128];

int
yyerror(const char *s)  /* Called by yyparse on error */
{
	snprintf(yyerror_message, sizeof(yyerror_message), "OSUnserialize: %s near line %d\n", s, lineNumber);
	return 0;
}

int
yylex()
{
	int c;

	if (parseBufferIndex == 0) lineNumber = 1;

 top:
	c = currentChar();

	/* skip white space  */
	if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {};

	/* skip over comments */
	if (c == '#') while ((c = nextChar()) != 0 && c != '\n') {};

	/* keep track of line number, don't return \n's */
	if (c == '\n') {
		lineNumber++;
		(void)nextChar();
		goto top;
	}

	/* parse boolean */
	if (c == '.') {
		bool boolean = false;
		if (nextChar() == 't') {
			if (nextChar() != 'r') return SYNTAX_ERROR;
			if (nextChar() != 'u') return SYNTAX_ERROR;
			if (nextChar() != 'e') return SYNTAX_ERROR;
			boolean = true;
		} else {
			if (currentChar() != 'f') return SYNTAX_ERROR;
			if (nextChar() != 'a') return SYNTAX_ERROR;
			if (nextChar() != 'l') return SYNTAX_ERROR;
			if (nextChar() != 's') return SYNTAX_ERROR;
			if (nextChar() != 'e') return SYNTAX_ERROR;
		}
		if (nextChar() != '.') return SYNTAX_ERROR;
		/* skip over dot */
		(void)nextChar();

		yylval = (object_t *)boolean;
		return BOOLEAN;
	}

	/* parse unquoted string */
	if (isAlpha(c)) {
		int start, length;
		char * tempString;

		start = parseBufferIndex;
		/* find end of string */
		while (isAlphaNumeric(c)) { 
			c = nextChar();
		}
		length = parseBufferIndex - start;

		/* copy to null terminated buffer */
		tempString = (char *)malloc(length + 1);
		if (tempString == NULL) {
			printf("OSUnserialize: can't alloc temp memory\n");
			return 0;
		}
		bcopy(&parseBuffer[start], tempString, length);
		tempString[length] = 0;
		yylval = (object_t *)tempString;
		return STRING;
	}

	/* parse quoted string */
	if (c == '"' || c == '\'') {
		int start, length;
		char * tempString;
		char quoteChar = c;

		start = parseBufferIndex + 1;		// skip quote
		/* find end of string, line, buffer */
		while ((c = nextChar()) != quoteChar) {
			if (c == '\\') c = nextChar();
			if (c == '\n') lineNumber++;
			if (c == 0) return SYNTAX_ERROR;
		}
		length = parseBufferIndex - start;
		/* skip over trailing quote */
		(void)nextChar();
		/* copy to null terminated buffer */
		tempString = (char *)malloc(length + 1);
		if (tempString == NULL) {
			printf("OSUnserialize: can't alloc temp memory\n");
			return 0;
		}

		int to = 0;
		for (int from=start; from < parseBufferIndex; from++) {
			// hack - skip over backslashes
			if (parseBuffer[from] == '\\') {
				length--;
				continue;
			}
			tempString[to] = parseBuffer[from]; 
			to++;
		}
		tempString[length] = 0;
		yylval = (object_t *)tempString;
		return STRING;
	}

	/* process numbers */
	if (isDigit (c))
	{
		unsigned long long n = 0;
		int base = 10;

		if (c == '0') {
			c = nextChar();
			if (c == 'x') {
				base = 16;
				c = nextChar();
			}
		}
		if (base == 10) {
			while(isDigit(c)) {
				n = (n * base + c - '0');
				c = nextChar();
			}
		} else {
			while(isHexDigit(c)) {
				if (isDigit(c)) {
					n = (n * base + c - '0');
				} else {
					n = (n * base + 0xa + c - 'a');
				}
				c = nextChar();
			}
		}

		yylval = newObject();
		yylval->u.offset = n;
			
		return NUMBER;
	}

#define OSDATA_ALLOC_SIZE 4096
	
	/* process data */
	if (c == '<') {
		unsigned char *d, *start, *lastStart;

		start = lastStart = d = (unsigned char *)malloc(OSDATA_ALLOC_SIZE);
		c = nextChar();	// skip over '<'
		while (c != 0 && c != '>') {

			if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {};
			if (c == '#') while ((c = nextChar()) != 0 && c != '\n') {};
			if (c == '\n') {
				lineNumber++;
				c = nextChar();
				continue;
			}

			// get high nibble
			if (!isHexDigit(c)) break;
			if (isDigit(c)) {
				*d = (c - '0') << 4;
			} else {
				*d =  (0xa + (c - 'a')) << 4;
			}

			// get low nibble
			c = nextChar();
			if (!isHexDigit(c)) break;
			if (isDigit(c)) {
				*d |= c - '0';
			} else {
				*d |= 0xa + (c - 'a');
			}
	
			d++;
			if ((d - lastStart) >= OSDATA_ALLOC_SIZE) {
				int oldsize = d - start;
				start = (unsigned char *)realloc(start, oldsize + OSDATA_ALLOC_SIZE);
				d = lastStart = start + oldsize;
			}
			c = nextChar();
		}
		if (c != '>' ) {
			free(start);
			return SYNTAX_ERROR;
		}

		// got it!
		yylval = newObject();
		yylval->object = start;
		yylval->size = d - start;

		(void)nextChar();	// skip over '>'
		return DATA;
	}


	/* return single chars, move pointer to next char */
	(void)nextChar();
	return c;
}

// !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!#
// !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!#
// !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!#

#if DEBUG
int debugUnserializeAllocCount = 0;
#endif

object_t *
newObject()
{
#if DEBUG
	debugUnserializeAllocCount++;
#endif
	return (object_t *)malloc(sizeof(object_t));
}

void
freeObject(object_t *o)
{
#if DEBUG
	debugUnserializeAllocCount--;
#endif
	free(o);
}

static OSDictionary *tags;

static void 
rememberObject(int tag, object_t *o)
{
	char key[16];
	snprintf(key, sizeof(key), "%u", tag);

	tags->setObject(key, (OSObject *)o);
}

static OSObject *
retrieveObject(int tag)
{
	char key[16];
	snprintf(key, sizeof(key), "%u", tag);

	return tags->getObject(key);
}

OSObject *
buildOSDictionary(object_t *o)
{
	object_t *temp, *last = o;
	int count = 0;

	// get count and last object
	while (o) {
		count++;
		last = o;
		o = o->next;
	}
	o = last;

	OSDictionary *d = OSDictionary::withCapacity(count);

	while (o) {
#ifdef metaclass_stuff_worksXXX
		if (((OSObject *)o->u.key)->metaCast("OSSymbol")) {
			// XXX the evil frontdoor
			d->setObject((OSSymbol *)o->u.key, (OSObject *)o->object);
		} else {
                        // If it isn't a symbol, I hope it's a string!
			d->setObject((OSString *)o->u.key, (OSObject *)o->object);
		}
#else
		d->setObject((OSString *)o->u.key, (OSObject *)o->object);
#endif
		((OSObject *)o->object)->release();
		((OSObject *)o->u.key)->release();
		temp = o;
		o = o->prev;
		freeObject(temp);
	}
	return d;
};

OSObject *
buildOSArray(object_t *o)
{
	object_t *temp, *last = o;
	int count = 0;

	// get count and last object
	while (o) {
		count++;
		last = o;
		o = o->next;
	}
	o = last;

	OSArray *a = OSArray::withCapacity(count);

	while (o) {
		a->setObject((OSObject *)o->object);
		((OSObject *)o->object)->release();
		temp = o;
		o = o->prev;
		freeObject(temp);
	}
	return a;
};

OSObject *
buildOSSet(object_t *o)
{
	OSArray *a = (OSArray *)buildOSArray(o);
	OSSet *s = OSSet::withArray(a, a->getCapacity());

	a->release();
	return s;
};

OSObject *
buildOSString(object_t *o)
{
	OSString *s = OSString::withCString((char *)o);

	free(o);

	return s;
};

OSObject *
buildOSData(object_t *o)
{
	OSData *d;

	if (o->size) {
		d = OSData::withBytes(o->object, o->size);
	} else {
		d = OSData::withCapacity(0);
	}
	free(o->object);
	freeObject(o);
	return d;
};

OSObject *
buildOSOffset(object_t *o)
{
	OSNumber *off = OSNumber::withNumber(o->u.offset, o->size);
	freeObject(o);
	return off;
};

OSObject *
buildOSBoolean(object_t *o)
{
	OSBoolean *b = OSBoolean::withBoolean((bool)o);
	return b;
};

__BEGIN_DECLS
#include <kern/locks.h>
__END_DECLS

static lck_mtx_t *lock = 0;
extern lck_grp_t *IOLockGroup;

OSObject*
OSUnserialize(const char *buffer, OSString **errorString)
{
	OSObject *object;

	if (!lock) {
		lock = lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL);
		lck_mtx_lock(lock);
	} else {
		lck_mtx_lock(lock);

	}

#if DEBUG
	debugUnserializeAllocCount = 0;
#endif
	yyerror_message[0] = 0;	//just in case
	parseBuffer = buffer;
	parseBufferIndex = 0;
	tags = OSDictionary::withCapacity(128);
	if (yyparse() == 0) {
		object = parsedObject;
		if (errorString) *errorString = NULL;
	} else {
		object = NULL;
		if (errorString)
			*errorString = OSString::withCString(yyerror_message);
	}

	tags->release();
#if DEBUG
	if (debugUnserializeAllocCount) {
		printf("OSUnserialize: allocation check failed, count = %d.\n", 
		       debugUnserializeAllocCount);
	}
#endif
	lck_mtx_unlock(lock);

	return object;
}


//
//
//
//
//
//		 DO NOT EDIT OSUnserialize.cpp!
//
//			this means you!
//
//
//
//
//
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28
	29	/* OSUnserialize.y created by rsulack on Nov 21 1998 */
	30
	31	// "classic" parser for unserializing OSContainer objects
	32	//
	33	// XXX - this code should really be removed!
	34	// - the XML format is now prefered
	35	// - this code leaks on syntax errors, the XML doesn't
	36	// - "classic" looks, reads, ... much better than XML :-(
	37	// - well except the XML is more efficent on OSData
	38	//
	39	//
	40	// to build :
	41	// bison -p OSUnserialize OSUnserialize.y
	42	// head -50 OSUnserialize.y > OSUnserialize.cpp
	43	// sed -e "s/stdio.h/stddef.h/" < OSUnserialize.tab.c >> OSUnserialize.cpp
	44	//
	45	// when changing code check in both OSUnserialize.y and OSUnserialize.cpp
	46	//
	47	//
	48	//
	49	//
	50	// DO NOT EDIT OSUnserialize.tab.cpp!
	51	//
	52	// this means you!
	53	//
	54	//
	55	//
	56	//
	57	//
	58
	59
	60	%{
	61	#include <libkern/c++/OSMetaClass.h>
	62	#include <libkern/c++/OSContainers.h>
	63	#include <libkern/c++/OSLib.h>
	64
	65	typedef struct object {
	66	struct object *next;
	67	struct object *prev;
	68	void *object;
	69	int size; // for data
	70	union {
	71	void *key; // for dictionary
	72	long long offset; // for offset
	73	} u;
	74
	75	} object_t;
	76
b0d623f7	77	static int yyerror(const char *s);
1c79356b A	78	static int yylex();
	79
	80	static object_t * newObject();
	81	static void freeObject(object_t *o);
	82
	83	static OSObject buildOSDictionary(object_t );
	84	static OSObject buildOSArray(object_t );
	85	static OSObject buildOSSet(object_t );
	86	static OSObject buildOSString(object_t );
	87	static OSObject buildOSData(object_t );
	88	static OSObject buildOSOffset(object_t );
	89	static OSObject buildOSBoolean(object_t o);
	90
	91	static void rememberObject(int, object_t *);
	92	static OSObject *retrieveObject(int);
	93
	94	// temp variable to use during parsing
b0d623f7	95	static object_t *oo;
1c79356b A	96
	97	// resultant object of parsed text
	98	static OSObject *parsedObject;
	99
	100	#define YYSTYPE object_t *
	101
d9a64523	102	#include <libkern/OSRuntime.h>
1c79356b A	103
	104	#define malloc(s) kern_os_malloc(s)
	105	#define realloc(a, s) kern_os_realloc(a, s)
	106	#define free(a) kern_os_free(a)
	107
	108	%}
	109	%token NUMBER
	110	%token STRING
	111	%token DATA
	112	%token BOOLEAN
	113	%token SYNTAX_ERROR
	114
	115	%% /* Grammar rules and actions follow */
	116
	117	input: /* empty / { parsedObject = (OSObject )NULL; YYACCEPT; }
	118	\| object { parsedObject = (OSObject *)$1; YYACCEPT; }
	119	\| SYNTAX_ERROR { yyerror("syntax error"); YYERROR; }
	120	;
	121
	122	object: dict { $$ = (object_t *)buildOSDictionary($1); }
	123	\| array { $$ = (object_t *)buildOSArray($1); }
	124	\| set { $$ = (object_t *)buildOSSet($1); }
	125	\| string { $$ = (object_t *)buildOSString($1); }
	126	\| data { $$ = (object_t *)buildOSData($1); }
	127	\| offset { $$ = (object_t *)buildOSOffset($1); }
	128	\| boolean { $$ = (object_t *)buildOSBoolean($1); }
	129	\| '@' NUMBER { $$ = (object_t *)retrieveObject($2->u.offset);
	130	if ($$) {
	131	((OSObject *)$$)->retain();
	132	} else {
	133	yyerror("forward reference detected");
	134	YYERROR;
	135	}
	136	freeObject($2);
	137	}
	138	\| object '@' NUMBER { $$ = $1;
	139	rememberObject($3->u.offset, $1);
	140	freeObject($3);
	141	}
	142	;
	143
	144	//------------------------------------------------------------------------------
	145
	146	dict: '{' '}' { $$ = NULL; }
	147	\| '{' pairs '}' { $$ = $2; }
	148	;
	149
	150	pairs: pair
	151	\| pairs pair { $2->next = $1; $1->prev = $2; $$ = $2; }
	152	;
	153
	154	pair: object '=' object ';' { $$ = newObject();
	155	$$->next = NULL;
	156	$$->prev = NULL;
	157	$$->u.key = $1;
	158	$$->object = $3;
	159	}
	160	;
	161
	162	//------------------------------------------------------------------------------
	163
	164	array: '(' ')' { $$ = NULL; }
	165	\| '(' elements ')' { $$ = $2; }
	166	;
167
168	set: '[' ']' { $$ = NULL; }
169	\| '[' elements ']' { $$ = $2; }
170	;
171
172	elements: object { $$ = newObject();
173	$$->object = $1;
174	$$->next = NULL;
175	$$->prev = NULL;
176	}
b0d623f7 A	177	\| elements ',' object { oo = newObject();
	178	oo->object = $3;
	179	oo->next = $1;
	180	oo->prev = NULL;
	181	$1->prev = oo;
	182	$$ = oo;
1c79356b A	183	}
	184	;
	185
	186	//------------------------------------------------------------------------------
	187
	188	offset: NUMBER ':' NUMBER { $$ = $1;
	189	$$->size = $3->u.offset;
	190	freeObject($3);
	191	}
	192	;
	193
	194	//------------------------------------------------------------------------------
	195
	196	data: DATA
	197	;
	198
	199	//------------------------------------------------------------------------------
	200
	201	string: STRING
	202	;
	203
	204	//------------------------------------------------------------------------------
	205
	206	boolean: BOOLEAN
	207	;
	208
	209	%%
	210
	211	static int lineNumber = 0;
	212	static const char *parseBuffer;
	213	static int parseBufferIndex;
	214
	215	#define currentChar() (parseBuffer[parseBufferIndex])
	216	#define nextChar() (parseBuffer[++parseBufferIndex])
	217	#define prevChar() (parseBuffer[parseBufferIndex - 1])
	218
	219	#define isSpace(c) ((c) == ' ' \|\| (c) == '\t')
	220	#define isAlpha(c) (((c) >= 'A' && (c) <= 'Z') \|\| ((c) >= 'a' && (c) <= 'z'))
	221	#define isDigit(c) ((c) >= '0' && (c) <= '9')
	222	#define isAlphaDigit(c) ((c) >= 'a' && (c) <= 'f')
	223	#define isHexDigit(c) (isDigit(c) \|\| isAlphaDigit(c))
	224	#define isAlphaNumeric(c) (isAlpha(c) \|\| isDigit(c) \|\| ((c) == '-'))
	225
	226	static char yyerror_message[128];
	227
	228	int
b0d623f7	229	yyerror(const char s) / Called by yyparse on error */
1c79356b	230	{
b0d623f7	231	snprintf(yyerror_message, sizeof(yyerror_message), "OSUnserialize: %s near line %d\n", s, lineNumber);
1c79356b A	232	return 0;
	233	}
	234
	235	int
	236	yylex()
	237	{
	238	int c;
	239
	240	if (parseBufferIndex == 0) lineNumber = 1;
	241
	242	top:
	243	c = currentChar();
	244
	245	/* skip white space */
	246	if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {};
	247
	248	/* skip over comments */
	249	if (c == '#') while ((c = nextChar()) != 0 && c != '\n') {};
	250
	251	/* keep track of line number, don't return \n's */
	252	if (c == '\n') {
	253	lineNumber++;
	254	(void)nextChar();
	255	goto top;
	256	}
	257
	258	/* parse boolean */
	259	if (c == '.') {
	260	bool boolean = false;
	261	if (nextChar() == 't') {
	262	if (nextChar() != 'r') return SYNTAX_ERROR;
	263	if (nextChar() != 'u') return SYNTAX_ERROR;
	264	if (nextChar() != 'e') return SYNTAX_ERROR;
	265	boolean = true;
	266	} else {
	267	if (currentChar() != 'f') return SYNTAX_ERROR;
	268	if (nextChar() != 'a') return SYNTAX_ERROR;
	269	if (nextChar() != 'l') return SYNTAX_ERROR;
	270	if (nextChar() != 's') return SYNTAX_ERROR;
	271	if (nextChar() != 'e') return SYNTAX_ERROR;
	272	}
	273	if (nextChar() != '.') return SYNTAX_ERROR;
	274	/* skip over dot */
	275	(void)nextChar();
	276
	277	yylval = (object_t *)boolean;
	278	return BOOLEAN;
	279	}
	280
	281	/* parse unquoted string */
	282	if (isAlpha(c)) {
	283	int start, length;
	284	char * tempString;
	285
	286	start = parseBufferIndex;
	287	/* find end of string */
	288	while (isAlphaNumeric(c)) {
	289	c = nextChar();
	290	}
	291	length = parseBufferIndex - start;
	292
	293	/* copy to null terminated buffer */
	294	tempString = (char *)malloc(length + 1);
cb323159	295	if (tempString == NULL) {
1c79356b A	296	printf("OSUnserialize: can't alloc temp memory\n");
	297	return 0;
	298	}
	299	bcopy(&parseBuffer[start], tempString, length);
	300	tempString[length] = 0;
	301	yylval = (object_t *)tempString;
	302	return STRING;
	303	}
	304
	305	/* parse quoted string */
	306	if (c == '"' \|\| c == '\'') {
	307	int start, length;
	308	char * tempString;
	309	char quoteChar = c;
	310
	311	start = parseBufferIndex + 1; // skip quote
	312	/* find end of string, line, buffer */
	313	while ((c = nextChar()) != quoteChar) {
	314	if (c == '\\') c = nextChar();
	315	if (c == '\n') lineNumber++;
	316	if (c == 0) return SYNTAX_ERROR;
	317	}
	318	length = parseBufferIndex - start;
	319	/* skip over trailing quote */
	320	(void)nextChar();
	321	/* copy to null terminated buffer */
	322	tempString = (char *)malloc(length + 1);
cb323159	323	if (tempString == NULL) {
1c79356b A	324	printf("OSUnserialize: can't alloc temp memory\n");
	325	return 0;
	326	}
	327
	328	int to = 0;
	329	for (int from=start; from < parseBufferIndex; from++) {
	330	// hack - skip over backslashes
	331	if (parseBuffer[from] == '\\') {
	332	length--;
	333	continue;
	334	}
	335	tempString[to] = parseBuffer[from];
	336	to++;
	337	}
	338	tempString[length] = 0;
	339	yylval = (object_t *)tempString;
	340	return STRING;
	341	}
	342
	343	/* process numbers */
	344	if (isDigit (c))
	345	{
	346	unsigned long long n = 0;
	347	int base = 10;
	348
	349	if (c == '0') {
	350	c = nextChar();
	351	if (c == 'x') {
	352	base = 16;
	353	c = nextChar();
	354	}
	355	}
	356	if (base == 10) {
	357	while(isDigit(c)) {
	358	n = (n * base + c - '0');
	359	c = nextChar();
	360	}
	361	} else {
	362	while(isHexDigit(c)) {
	363	if (isDigit(c)) {
	364	n = (n * base + c - '0');
	365	} else {
	366	n = (n * base + 0xa + c - 'a');
	367	}
	368	c = nextChar();
	369	}
	370	}
	371
	372	yylval = newObject();
	373	yylval->u.offset = n;
	374
	375	return NUMBER;
	376	}
	377
	378	#define OSDATA_ALLOC_SIZE 4096
	379
	380	/* process data */
	381	if (c == '<') {
	382	unsigned char d, start, *lastStart;
	383
	384	start = lastStart = d = (unsigned char *)malloc(OSDATA_ALLOC_SIZE);
	385	c = nextChar(); // skip over '<'
	386	while (c != 0 && c != '>') {
	387
388	if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {};
389	if (c == '#') while ((c = nextChar()) != 0 && c != '\n') {};
390	if (c == '\n') {
391	lineNumber++;
392	c = nextChar();
393	continue;
394	}
395
396	// get high nibble
397	if (!isHexDigit(c)) break;
398	if (isDigit(c)) {
399	*d = (c - '0') << 4;
400	} else {
401	*d = (0xa + (c - 'a')) << 4;
402	}
403
404	// get low nibble
405	c = nextChar();
406	if (!isHexDigit(c)) break;
407	if (isDigit(c)) {
408	*d \|= c - '0';
409	} else {
410	*d \|= 0xa + (c - 'a');
411	}
412
413	d++;
414	if ((d - lastStart) >= OSDATA_ALLOC_SIZE) {
415	int oldsize = d - start;
416	start = (unsigned char *)realloc(start, oldsize + OSDATA_ALLOC_SIZE);
417	d = lastStart = start + oldsize;
418	}
419	c = nextChar();
420	}
421	if (c != '>' ) {
422	free(start);
423	return SYNTAX_ERROR;
424	}
425
426	// got it!
427	yylval = newObject();
428	yylval->object = start;
429	yylval->size = d - start;
430
431	(void)nextChar(); // skip over '>'
432	return DATA;
433	}
434
435
436	/* return single chars, move pointer to next char */
437	(void)nextChar();
438	return c;
439	}
440
441	// !@$&)(^Q$&^!$(!@$_(^%_(Q#$(_&!$_(&!$_(&!#$(*!@&^!@#%!_!#
442	// !@$&)(^Q$&^!$(!@$_(^%_(Q#$(_&!$_(&!$_(&!#$(*!@&^!@#%!_!#
443	// !@$&)(^Q$&^!$(!@$_(^%_(Q#$(_&!$_(&!$_(&!#$(*!@&^!@#%!_!#
444
b0d623f7	445	#if DEBUG
1c79356b A	446	int debugUnserializeAllocCount = 0;
	447	#endif
	448
	449	object_t *
	450	newObject()
	451	{
b0d623f7	452	#if DEBUG
1c79356b A	453	debugUnserializeAllocCount++;
	454	#endif
	455	return (object_t *)malloc(sizeof(object_t));
	456	}
	457
	458	void
	459	freeObject(object_t *o)
	460	{
b0d623f7	461	#if DEBUG
1c79356b A	462	debugUnserializeAllocCount--;
	463	#endif
	464	free(o);
	465	}
	466
	467	static OSDictionary *tags;
	468
	469	static void
	470	rememberObject(int tag, object_t *o)
	471	{
	472	char key[16];
b0d623f7	473	snprintf(key, sizeof(key), "%u", tag);
1c79356b A	474
	475	tags->setObject(key, (OSObject *)o);
	476	}
	477
	478	static OSObject *
	479	retrieveObject(int tag)
	480	{
	481	char key[16];
b0d623f7	482	snprintf(key, sizeof(key), "%u", tag);
1c79356b A	483
	484	return tags->getObject(key);
	485	}
	486
	487	OSObject *
	488	buildOSDictionary(object_t *o)
	489	{
	490	object_t temp, last = o;
	491	int count = 0;
	492
	493	// get count and last object
	494	while (o) {
	495	count++;
	496	last = o;
	497	o = o->next;
	498	}
	499	o = last;
	500
	501	OSDictionary *d = OSDictionary::withCapacity(count);
	502
	503	while (o) {
	504	#ifdef metaclass_stuff_worksXXX
	505	if (((OSObject *)o->u.key)->metaCast("OSSymbol")) {
	506	// XXX the evil frontdoor
	507	d->setObject((OSSymbol )o->u.key, (OSObject )o->object);
	508	} else {
	509	// If it isn't a symbol, I hope it's a string!
	510	d->setObject((OSString )o->u.key, (OSObject )o->object);
	511	}
	512	#else
	513	d->setObject((OSString )o->u.key, (OSObject )o->object);
	514	#endif
	515	((OSObject *)o->object)->release();
	516	((OSObject *)o->u.key)->release();
	517	temp = o;
	518	o = o->prev;
	519	freeObject(temp);
	520	}
	521	return d;
	522	};
	523
	524	OSObject *
	525	buildOSArray(object_t *o)
	526	{
	527	object_t temp, last = o;
	528	int count = 0;
	529
	530	// get count and last object
	531	while (o) {
	532	count++;
	533	last = o;
	534	o = o->next;
	535	}
	536	o = last;
	537
	538	OSArray *a = OSArray::withCapacity(count);
	539
	540	while (o) {
	541	a->setObject((OSObject *)o->object);
	542	((OSObject *)o->object)->release();
	543	temp = o;
	544	o = o->prev;
	545	freeObject(temp);
	546	}
547	return a;
548	};
549
550	OSObject *
551	buildOSSet(object_t *o)
552	{
553	OSArray a = (OSArray )buildOSArray(o);
554	OSSet *s = OSSet::withArray(a, a->getCapacity());
555
556	a->release();
557	return s;
558	};
559
560	OSObject *
561	buildOSString(object_t *o)
562	{
563	OSString s = OSString::withCString((char )o);
564
565	free(o);
566
567	return s;
568	};
569
570	OSObject *
571	buildOSData(object_t *o)
572	{
573	OSData *d;
574
575	if (o->size) {
576	d = OSData::withBytes(o->object, o->size);
577	} else {
578	d = OSData::withCapacity(0);
579	}
580	free(o->object);
581	freeObject(o);
582	return d;
583	};
584
585	OSObject *
586	buildOSOffset(object_t *o)
587	{
588	OSNumber *off = OSNumber::withNumber(o->u.offset, o->size);
589	freeObject(o);
590	return off;
591	};
592
593	OSObject *
594	buildOSBoolean(object_t *o)
595	{
596	OSBoolean *b = OSBoolean::withBoolean((bool)o);
597	return b;
598	};
599
600	__BEGIN_DECLS
b0d623f7	601	#include <kern/locks.h>
1c79356b A	602	__END_DECLS
1c79356b A	603
b0d623f7 A	604	static lck_mtx_t *lock = 0;
b0d623f7 A	605	extern lck_grp_t *IOLockGroup;
1c79356b A	606
	607	OSObject*
	608	OSUnserialize(const char buffer, OSString *errorString)
	609	{
	610	OSObject *object;
	611
	612	if (!lock) {
b0d623f7 A	613	lock = lck_mtx_alloc_init(IOLockGroup, LCK_ATTR_NULL);
b0d623f7 A	614	lck_mtx_lock(lock);
1c79356b	615	} else {
b0d623f7	616	lck_mtx_lock(lock);
1c79356b A	617
	618	}
	619
b0d623f7	620	#if DEBUG
1c79356b A	621	debugUnserializeAllocCount = 0;
	622	#endif
	623	yyerror_message[0] = 0; //just in case
	624	parseBuffer = buffer;
	625	parseBufferIndex = 0;
	626	tags = OSDictionary::withCapacity(128);
	627	if (yyparse() == 0) {
	628	object = parsedObject;
cb323159	629	if (errorString) *errorString = NULL;
1c79356b	630	} else {
cb323159	631	object = NULL;
1c79356b A	632	if (errorString)
	633	*errorString = OSString::withCString(yyerror_message);
	634	}
	635
	636	tags->release();
b0d623f7	637	#if DEBUG
1c79356b A	638	if (debugUnserializeAllocCount) {
	639	printf("OSUnserialize: allocation check failed, count = %d.\n",
	640	debugUnserializeAllocCount);
	641	}
	642	#endif
b0d623f7	643	lck_mtx_unlock(lock);
1c79356b A	644
	645	return object;
	646	}
	647
	648
	649	//
	650	//
	651	//
	652	//
	653	//
	654	// DO NOT EDIT OSUnserialize.cpp!
	655	//
	656	// this means you!
	657	//
	658	//
	659	//
	660	//
	661	//