Index: trunk/i386/libsaio/xml.c
===================================================================
--- trunk/i386/libsaio/xml.c	(revision 2581)
+++ trunk/i386/libsaio/xml.c	(revision 2582)
@@ -2,15 +2,15 @@
  * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_LICENSE_HEADER_START@
- * 
+ *
  * Portions Copyright (c) 2003 Apple Computer, Inc.  All Rights
- * Reserved.  
+ * Reserved.
  * The contents of this file constitute Original Code as defined in and
  * 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.  Please obtain a copy of the License at
  * http://www.apple.com/publicsource and read it before using this file.
- * 
+ *
  * This 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,
@@ -18,7 +18,7 @@
  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  * License for the specific language governing rights and limitations
  * under the License.
- * 
+ *
  * @APPLE_LICENSE_HEADER_END@
  */
 
@@ -30,12 +30,12 @@
 string_ref *ref_strings = NULL;
 
 /// TODO: remove below
-static char* buffer_start = NULL;
+static char *buffer_start = NULL;
 // TODO: redo the next two functions
-void SaveRefString(char* string, int id)
+void SaveRefString(char *string, int id)
 {
 	//printf("Adding Ref String %d (%s)\n", id, string);
-	string_ref* tmp = ref_strings;
+	string_ref *tmp = ref_strings;
 	while(tmp)
 	{
 		if(tmp->id == id)
@@ -55,9 +55,9 @@
 	ref_strings = new_ref;
 }
 
-char* GetRefString(int id)
+char *GetRefString(int id)
 {
-	string_ref* tmp = ref_strings;
+	string_ref *tmp = ref_strings;
 	while(tmp)
 	{
 		if(tmp->id == id) return tmp->string;
@@ -127,12 +127,12 @@
 //==========================================================================
 // XMLGetProperty
 
-TagPtr
-XMLGetProperty(TagPtr dict, const char * key)
+TagPtr XMLGetProperty(TagPtr dict, const char *key)
 {
 	TagPtr tagList, tag;
 
-	if (dict->type != kTagTypeDict) {
+	if (dict->type != kTagTypeDict)
+	{
 		return 0;
 	}
 
@@ -142,11 +142,13 @@
 		tag = tagList;
 		tagList = tag->tagNext;
 
-		if ((tag->type != kTagTypeKey) || (tag->string == 0)) {
+		if ((tag->type != kTagTypeKey) || (tag->string == 0))
+		{
 			continue;
 		}
 
-		if (!strcmp(tag->string, key)) {
+		if (!strcmp(tag->string, key))
+		{
 			return tag->tag;
 		}
 	}
@@ -156,12 +158,12 @@
 //==========================================================================
 // XMLGetProperty
 
-TagPtr
-XMLGetKey( TagPtr dict, int id )
+TagPtr XMLGetKey( TagPtr dict, int id )
 {
 	TagPtr tagList, tag;
-    
-	if (dict->type != kTagTypeDict) {
+
+	if (dict->type != kTagTypeDict)
+	{
 		return 0;
 	}
 
@@ -173,12 +175,14 @@
 		tag = tagList;
 		tagList = tag->tagNext;
 
-		if ((tag->type != kTagTypeKey) || (tag->string == 0)) {
+		if ((tag->type != kTagTypeKey) || (tag->string == 0))
+		{
 			continue;
 		}
 
         	element++;
-		if(id == element) {
+		if(id == element)
+		{
 			return tag;
 		}
 
@@ -188,7 +192,8 @@
 
 TagPtr XMLGetValueForKey(TagPtr key)
 {
-	if (!key || key->type != kTagTypeKey) {
+	if (!key || key->type != kTagTypeKey)
+	{
 		return 0;
 	}
 
@@ -204,7 +209,8 @@
 	int count = 0;
 	TagPtr tagList, tag;
 
-	if (dict->type != kTagTypeDict && dict->type != kTagTypeArray) {
+	if (dict->type != kTagTypeDict && dict->type != kTagTypeArray)
+	{
 		return 0;
 	}
 
@@ -214,24 +220,26 @@
 	{
 		tag = tagList;
 		tagList = tag->tagNext;
-		
+
 		if (((tag->type != kTagTypeKey) && ((tag->string == 0) || (tag->string[0] == 0)))
 			&& (dict->type != kTagTypeArray)	// If we are an array, any element is valid
-			) {
+			)
+		{
 			continue;
 		}
-		
+
 		//if(tag->type == kTagTypeKey) printf("Located key %s\n", tag->string);
 
 		count++;
 	}
-	
+
 	return count;
 }
 
 TagPtr XMLGetElement( TagPtr dict, int id )
 {
-	if(dict->type != kTagTypeArray) {
+	if(dict->type != kTagTypeArray)
+	{
 		return 0;
 	}
 
@@ -243,16 +251,16 @@
 		element++;
 		tmp = tmp->tagNext;
 	}
-	
+
 	return tmp;
 }
+
 /* Function for basic XML character entities parsing */
 
-char*
-XMLDecode(const char* src)
+char *XMLDecode(const char* src)
 {
 	typedef const struct XMLEntity {
-		const char* name;
+		const char *name;
 		size_t nameLen;
 		char value;
 	} XMLEntity;
@@ -269,7 +277,8 @@
 	const char *s;
 	char *out, *o;
 
-	if ( !src || !(len = strlen(src)) || !(out = malloc(len+1)) ) {
+	if ( !src || !(len = strlen(src)) || !(out = malloc(len+1)) )
+	{
 		return 0;
 	}
 
@@ -277,19 +286,22 @@
 	s = src;
 	while (s <= src+len) /* Make sure the terminator is also copied */
 	{
-		if ( *s == '&' ) {
+		if ( *s == '&' )
+		{
 			bool entFound = false;
 			int i;
 
 			s++;
 			for ( i = 0; i < sizeof(ents)/sizeof(ents[0]); i++)
 			{
-				if ( strncmp(s, ents[i].name, ents[i].nameLen) == 0 ) {
+				if ( strncmp(s, ents[i].name, ents[i].nameLen) == 0 )
+				{
 					entFound = true;
 					break;
 				}
 			}
-			if ( entFound ) {
+			if ( entFound )
+			{
 				*o++ = ents[i].value;
 				s += ents[i].nameLen;
 
@@ -303,7 +315,6 @@
 	return out;
 }
 
-//#if UNUSED
 //==========================================================================
 // XMLParseFile
 // Expects to see one dictionary in the XML file, the final pos will be returned
@@ -311,58 +322,69 @@
 // Puts the first dictionary it finds in the
 // tag pointer and returns the end of the dic, or returns -1 if not found.
 //
-long
-XMLParseFile( char * buffer, TagPtr * dict )
+long XMLParseFile( char * buffer, TagPtr *dict )
 {
-	long       length, pos;
-	TagPtr     tag;
-	pos = 0;
-	char       *configBuffer;
+	long	length;
+	long	pos = 0;
+	TagPtr	tag;
+	char	*configBuffer;
 
 	int strlength = strlen(buffer);
 	configBuffer = malloc(strlength+1);
 	bcopy(buffer, configBuffer, strlength);
+
 	configBuffer[strlength] = 0;
 
 	buffer_start = configBuffer;
 
-    while (1)
-    {
-        length = XMLParseNextTag(configBuffer + pos, &tag);
-        if (length == -1) break;
+	while (1)
+	{
+		length = XMLParseNextTag(configBuffer + pos, &tag);
+		if (length == -1) break;
 
-        pos += length;
+		pos += length;
 
-        if (tag == 0) continue;
-        if (tag->type == kTagTypeDict) break;
-    
-        XMLFreeTag(tag);
-    }
+		if (tag == 0)
+		{
+			continue;
+		}
+
+		if (tag->type == kTagTypeDict)
+		{
+			break;
+		}
+
+		XMLFreeTag(tag);
+	}
 	free(configBuffer);
-	if (length < 0) {
-        return -1;
-    }
-    *dict = tag;
-    return pos;
+	if (length < 0)
+	{
+		return -1;
+	}
+	*dict = tag;
+	return pos;
 }
-//#endif /* UNUSED */
 
 //==========================================================================
 // ParseNextTag
 // TODO: cleanup
-long
-XMLParseNextTag( char * buffer, TagPtr * tag )
+long XMLParseNextTag( char *buffer, TagPtr *tag )
 {
-	long   length, pos;
-	char * tagName;
+	long	length = 0;
+	long	pos = 0;
 
+
+	char	*tagName;
+
 	length = GetNextTag(buffer, &tagName, 0);
-	if (length == -1) {
+	if (length == -1)
+	{
 		return -1;
 	}
 
 	pos = length;
-	if (!strncmp(tagName, kXMLTagPList, 6)) {
+	if (!strncmp(tagName, kXMLTagPList, 6))
+	{
 		length = 0;
         // just a header; nothing to parse
         // return-via-reference tag should be left alone
@@ -371,51 +393,70 @@
 	else if (!strcmp(tagName, kXMLTagDict))
 	{
 		length = ParseTagList(buffer + pos, tag, kTagTypeDict, 0);
-	} else if (!strncmp(tagName, kXMLTagDict, strlen(kXMLTagDict)) && tagName[strlen(tagName)-1] == '/') {
+	}
+	else if (!strncmp(tagName, kXMLTagDict, strlen(kXMLTagDict)) && tagName[strlen(tagName)-1] == '/')
+	{
 		length = ParseTagList(buffer + pos, tag, kTagTypeDict, 1);
-	} else if (!strncmp(tagName, kXMLTagDict " ", strlen(kXMLTagDict " "))) {
+	}
+	else if (!strncmp(tagName, kXMLTagDict " ", strlen(kXMLTagDict " ")))
+	{
 		length = ParseTagList(buffer + pos, tag, kTagTypeDict, 0);
 	}
 	/***** key ****/
-	else if (!strcmp(tagName, kXMLTagKey)) {
+	else if (!strcmp(tagName, kXMLTagKey))
+	{
 		length = ParseTagKey(buffer + pos, tag);
 	}
 
 	/***** string ****/
-	else if (!strcmp(tagName, kXMLTagString)) {
+	else if (!strcmp(tagName, kXMLTagString))
+	{
 		length = ParseTagString(buffer + pos, tag);
-	} else if (!strncmp(tagName, kXMLTagString " ", strlen(kXMLTagString " "))) {
+	}
+	else if (!strncmp(tagName, kXMLTagString " ", strlen(kXMLTagString " ")))
+	{
 		// TODO: save tag if if found
-		if(!strncmp(tagName + strlen(kXMLTagString " "), kXMLStringID, strlen(kXMLStringID))) {
+		if(!strncmp(tagName + strlen(kXMLTagString " "), kXMLStringID, strlen(kXMLStringID)))
+		{
 			// ID=
 			int id = 0;
 			int cnt = strlen(kXMLTagString " " kXMLStringID "\"") + 1;
 			while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;
 			tagName[cnt] = 0;
 			char* val = tagName + strlen(kXMLTagString " " kXMLStringID "\"");
-			while(*val) {
-				if ((*val >= '0' && *val <= '9')) { // 0 - 9
+			while(*val)
+			{
+				if ((*val >= '0' && *val <= '9'))	// 0 - 9
+				{
 					id = (id * 10) + (*val++ - '0');
-				} else {
+				}
+				else
+				{
 					printf("ParseStringID error (0x%x)\n", *val);
 					getchar();
 					return -1;
 				}
 			}
 			length = ParseTagString(buffer + pos, tag);
-			
+
 			SaveRefString(buffer + pos, id);
-		} else if(!strncmp(tagName + strlen(kXMLTagString " "), kXMLStringIDRef, strlen(kXMLStringIDRef))) {
+		}
+		else if(!strncmp(tagName + strlen(kXMLTagString " "), kXMLStringIDRef, strlen(kXMLStringIDRef)))
+		{
 			// IDREF=
 			int id = 0;
 			int cnt = strlen(kXMLTagString " " kXMLStringIDRef "\"") + 1;
 			while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;
 			tagName[cnt] = 0;
 			char* val = tagName + strlen(kXMLTagString " " kXMLStringIDRef "\"");
-			while(*val) {
-				if ((*val >= '0' && *val <= '9')) { // 0 - 9
+			while(*val)
+			{
+				if ((*val >= '0' && *val <= '9'))	// 0 - 9
+				{
 					id = (id * 10) + (*val++ - '0');
-				} else {
+				}
+				else
+				{
 					printf("ParseStringIDREF error (0x%x)\n", *val);
 					getchar();
 					return -1;
@@ -430,53 +471,67 @@
 			tmpTag->tagNext = 0;
 			tmpTag->offset = buffer_start ? buffer - buffer_start  + pos : 0;
 			*tag = tmpTag;
-			
+
 			length = 0;
 			//printf("Located IDREF, id = %d, string = %s\n", id, str);
 		}
 	}
 
 	/***** integer ****/
-	else if (!strcmp(tagName, kXMLTagInteger)) {
+	else if (!strcmp(tagName, kXMLTagInteger))
+	{
 		length = ParseTagInteger(buffer + pos, tag);
-	} else if (!strncmp(tagName, kXMLTagInteger " ", strlen(kXMLTagInteger " "))) {
-		if(!strncmp(tagName + strlen(kXMLTagInteger " "), kXMLStringID, strlen(kXMLStringID))) {
+	}
+	else if (!strncmp(tagName, kXMLTagInteger " ", strlen(kXMLTagInteger " ")))
+	{
+		if(!strncmp(tagName + strlen(kXMLTagInteger " "), kXMLStringID, strlen(kXMLStringID)))
+		{
 			// ID=
 			int id = 0;
 			int cnt = strlen(kXMLTagInteger " " kXMLStringID "\"") + 1;
 			while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;
 			tagName[cnt] = 0;
 			char* val = tagName + strlen(kXMLTagInteger " " kXMLStringID "\"");
-			while(*val) 	{
-				if ((*val >= '0' && *val <= '9')) { // 0 - 9
+			while(*val)
+			{
+				if ((*val >= '0' && *val <= '9'))	// 0 - 9
+				{
 					id = (id * 10) + (*val++ - '0');
-				} else {
+				}
+				else
+				{
 					printf("ParseIntegerID error (0x%x)\n", *val);
 					getchar();
 					return -1;
 				}
 			}
 			length = ParseTagInteger(buffer + pos, tag);
-			
+
 			SaveRefString((*tag)->string, id);
-		} else if(!strncmp(tagName + strlen(kXMLTagInteger " "), kXMLStringIDRef, strlen(kXMLStringIDRef))) {
+		}
+		else if(!strncmp(tagName + strlen(kXMLTagInteger " "), kXMLStringIDRef, strlen(kXMLStringIDRef)))
+		{
 			// IDREF=
 			int id = 0;
 			int cnt = strlen(kXMLTagInteger " " kXMLStringIDRef "\"") + 1;
 			while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;
 			tagName[cnt] = 0;
 			char* val = tagName + strlen(kXMLTagInteger " " kXMLStringIDRef "\"");
-			while(*val) {
-				if ((*val >= '0' && *val <= '9')) { // 0 - 9
+			while(*val)
+			{
+				if ((*val >= '0' && *val <= '9'))	// 0 - 9
+				{
 					id = (id * 10) + (*val++ - '0');
-				} else {
+				}
+				else
+				{
 					printf("ParseStringIDREF error (0x%x)\n", *val);
 					getchar();
 					return -1;
 				}
 			}
 			int integer = (int)GetRefString(id);
-			
+
 			TagPtr tmpTag = NewTag();
 			tmpTag->type = kTagTypeInteger;
 			tmpTag->string = (char*) integer;
@@ -485,22 +540,26 @@
 			tmpTag->offset = buffer_start ? buffer - buffer_start + pos : 0;
 
 			*tag = tmpTag;
-			
+
 			length = 0;
 			//printf("Located IDREF, id = %d, string = %s\n", id, str);
-		} else {
+		}
+		else
+		{
 			length = ParseTagInteger(buffer + pos, tag);
 		}
 	}
 
 
 	/***** false ****/
-	else if (!strcmp(tagName, kXMLTagFalse)) {
+	else if (!strcmp(tagName, kXMLTagFalse))
+	{
 		length = ParseTagBoolean(buffer + pos, tag, kTagTypeFalse);
 	}
 
 	/***** true ****/
-	else if (!strcmp(tagName, kXMLTagTrue)) {
+	else if (!strcmp(tagName, kXMLTagTrue))
+	{
 		length = ParseTagBoolean(buffer + pos, tag, kTagTypeTrue);
 	}
 
@@ -511,35 +570,47 @@
 
 
 	/***** data ****/
-	else if (!strcmp(tagName, kXMLTagData)) {
+	else if (!strcmp(tagName, kXMLTagData))
+	{
 		length = ParseTagData(buffer + pos, tag);
-	} else if (!strncmp(tagName, kXMLTagData " ", strlen(kXMLTagData " "))) {
+	}
+	else if (!strncmp(tagName, kXMLTagData " ", strlen(kXMLTagData " ")))
+	{
 		length = ParseTagData(buffer + pos, tag);
-	} else if (!strcmp(tagName, kXMLTagDate)) {
+	}
+	else if (!strcmp(tagName, kXMLTagDate))
+	{
 		length = ParseTagDate(buffer + pos, tag);
 	}
 
 	/***** date ****/
-	else if (!strncmp(tagName, kXMLTagDate " ", strlen(kXMLTagDate " "))) {
+	else if (!strncmp(tagName, kXMLTagDate " ", strlen(kXMLTagDate " ")))
+	{
 		length = ParseTagDate(buffer + pos, tag);
 	}	/***** array ****/
-	else if (!strcmp(tagName, kXMLTagArray)) {
+	else if (!strcmp(tagName, kXMLTagArray))
+	{
 		length = ParseTagList(buffer + pos, tag, kTagTypeArray, 0);
 	}
-	else if (!strncmp(tagName, kXMLTagArray " ", strlen(kXMLTagArray " "))) {
+	else if (!strncmp(tagName, kXMLTagArray " ", strlen(kXMLTagArray " ")))
+	{
 		length = ParseTagList(buffer + pos, tag, kTagTypeArray, 0);
-	} else if (!strcmp(tagName, kXMLTagArray "/")) {
+	}
+	else if (!strcmp(tagName, kXMLTagArray "/"))
+	{
 		length = ParseTagList(buffer + pos, tag, kTagTypeArray, 1);
 	}
 
 	/***** unknown ****/
-	else {
-        // it wasn't parsed so we consumed no additional characters
+	else
+	{
+		// it wasn't parsed so we consumed no additional characters
 		*tag = 0;
 		length = 0;
 	}
 
-	if (length == -1) {
+	if (length == -1)
+	{
 		return -1;
 	}
 
@@ -549,40 +620,45 @@
 //==========================================================================
 // ParseTagList
 
-static long
-ParseTagList( char * buffer, TagPtr * tag, long type, long empty )
+static long ParseTagList( char *buffer, TagPtr *tag, long type, long empty )
 {
-	long   length, pos;
-	TagPtr tagList, tmpTag;
+	long		pos = 0;
+	long		length = 0;
+	TagPtr		tagList = 0;
+	TagPtr		tmpTag;
+
   
-	tagList = 0;
-	pos = 0;
-  
-	if (!empty) {
-		while (1) {
+	if (!empty)
+	{
+		while (1)
+		{
 			length = XMLParseNextTag(buffer + pos, &tmpTag);
-			if (length == -1) {
+			if (length == -1)
+			{
 				break;
 			}
 
 			pos += length;
       
 			// detect end of list
-			if (tmpTag == 0) {
+			if (tmpTag == 0)
+			{
 				break;
 			}
 			tmpTag->tagNext = tagList;
 			tagList = tmpTag;
 		}
 
-		if (length == -1) {
+		if (length == -1)
+		{
 			XMLFreeTag(tagList);
 			return -1;
 		}
 	}
   
 	tmpTag = NewTag();
-	if (tmpTag == 0) {
+	if (tmpTag == 0)
+	{
 		XMLFreeTag(tagList);
 		return -1;
 	}
@@ -601,31 +677,36 @@
 //==========================================================================
 // ParseTagKey
 
-static long
-ParseTagKey( char * buffer, TagPtr * tag )
+static long ParseTagKey( char *buffer, TagPtr *tag )
 {
-	long   length, length2;
-	char   *string;
-	TagPtr tmpTag, subTag;
+	long		length = 0;
+	long		length2 = 0;
+	char		*string;
+	TagPtr		tmpTag;
+	TagPtr		subTag;
   
 	length = FixDataMatchingTag(buffer, kXMLTagKey);
-	if (length == -1) {
+	if (length == -1)
+	{
 		return -1;
 	}
   
 	length2 = XMLParseNextTag(buffer + length, &subTag);
-	if (length2 == -1) {
+	if (length2 == -1)
+	{
 		return -1;
 	}
 
 	tmpTag = NewTag();
-	if (tmpTag == 0) {
+	if (tmpTag == 0)
+	{
 		XMLFreeTag(subTag);
 		return -1;
 	}
   
 	string = NewSymbol(buffer);
-	if (string == 0) {
+	if (string == 0)
+	{
 		XMLFreeTag(subTag);
 		XMLFreeTag(tmpTag);
 		return -1;
@@ -638,31 +719,33 @@
 	tmpTag->tagNext = 0;
   
 	*tag = tmpTag;
-  
+
 	return length + length2;
 }
 
 //==========================================================================
 // ParseTagString
 
-static long
-ParseTagString( char * buffer, TagPtr * tag )
+static long ParseTagString( char *buffer, TagPtr *tag )
 {
-	long   length;
-	char * string;
+	long		length = 0;
+	char		*string;
   
 	length = FixDataMatchingTag(buffer, kXMLTagString);
-	if (length == -1) {
+	if (length == -1)
+	{
 		return -1;
 	}
   
 	TagPtr tmpTag = NewTag();
-	if (tmpTag == 0) {
+	if (tmpTag == 0)
+	{
 		return -1;
 	}
-  
+
 	string = NewSymbol(buffer);
-	if (string == 0) {
+	if (string == 0)
+	{
 		XMLFreeTag(tmpTag);
 		return -1;
 	}
@@ -670,8 +753,8 @@
 	tmpTag->type = kTagTypeString;
 	tmpTag->string = string;
 	tmpTag->tag = 0;
+	tmpTag->tagNext = 0;
 	tmpTag->offset = buffer_start ? buffer - buffer_start: 0;
-	tmpTag->tagNext = 0;
 
 	*tag = tmpTag;
 	return length;
@@ -680,8 +763,7 @@
 //==========================================================================
 // ParseTagInteger
 
-static long
-ParseTagInteger( char * buffer, TagPtr * tag )
+static long ParseTagInteger( char *buffer, TagPtr *tag )
 {
 	long   length, integer;
 	bool negative = false;
@@ -704,46 +786,62 @@
 		
 		return 0;
 	}
-	
+
 	size = length = FixDataMatchingTag(buffer, kXMLTagInteger);
-	if (length == -1) {
+	if (length == -1)
+	{
 		return -1;
 	}
 
 	tmpTag = NewTag();
 
-	if (tmpTag == 0) {
+	if (tmpTag == 0)
+	{
 		return -1;
 	}
 	integer = 0;
 
-	if(size > 1 && (val[1] == 'x' || val[1] == 'X')) { // Hex value
+	if(size > 1 && (val[1] == 'x' || val[1] == 'X'))	// Hex value
+	{
 		val += 2;
-		while(*val) {
-			if ((*val >= '0' && *val <= '9')) { // 0 - 9
-
+		while(*val)
+		{			
+			if ((*val >= '0' && *val <= '9'))	// 0 - 9
+			{
 				integer = (integer * 16) + (*val++ - '0');
-			} else if ((*val >= 'a' && *val <= 'f')) { // a - f
+			}
+			else if ((*val >= 'a' && *val <= 'f'))	// a - f
+			{
 				integer = (integer * 16) + (*val++ - 'a' + 10);
-			} else if ((*val >= 'A' && *val <= 'F')) { // A - F
+			}
+			else if ((*val >= 'A' && *val <= 'F'))	// A - F
+			{
 				integer = (integer * 16) + (*val++ - 'A' + 10);
-			} else {
+			}
+			else
+			{
 				printf("ParseTagInteger hex error (0x%x) in buffer %s\n", *val, buffer);
 				getchar();
 				XMLFreeTag(tmpTag);
 				return -1;
 			}
 		}
-	} else if ( size ) { // Decimal value
-		if (*val == '-') {
+	}
+	else if ( size )	// Decimal value
+	{
+		if (*val == '-')
+		{
 			negative = true;
 			val++;
 			size--;
 		}
 		
-		for (integer = 0; size > 0; size--) {
-			if(*val) { // UGLY HACK, fix me.
-				if (*val < '0' || *val > '9') {
+		for (integer = 0; size > 0; size--)
+		{
+			if(*val) // UGLY HACK, fix me.
+			{
+				if (*val < '0' || *val > '9')
+				{
 					printf("ParseTagInteger decimal error (0x%x) in buffer %s\n", *val, buffer);
 					getchar();
 					return -1;
@@ -772,28 +870,36 @@
 //==========================================================================
 // ParseTagData
 
-static long
-ParseTagData( char * buffer, TagPtr * tag )
+static long ParseTagData( char *buffer, TagPtr *tag )
 {
-	int actuallen = 0;
-	long   length;
-	TagPtr tmpTag;
+	int		actuallen = 0;
+	long		length = 0;
+	TagPtr		tmpTag;
+	char		*string;
 
 	length = FixDataMatchingTag(buffer, kXMLTagData);
-	if (length == -1) return -1;
+	if (length == -1)
+	{
+		return -1;
+	}
 
 	tmpTag = NewTag();
-	if (tmpTag == 0) return -1;
+	if (tmpTag == 0)
+	{
+		return -1;
+	}
 
 	//printf("ParseTagData unimplimented\n");
 	//printf("Data: %s\n", buffer);
 	//	getchar();
 
-	char* string = BASE64Decode(buffer, strlen(buffer), &actuallen);
+	string = BASE64Decode(buffer, strlen(buffer), &actuallen);
 	tmpTag->type = kTagTypeData;
 	tmpTag->string = string;
+
 	tmpTag->tag = 0;
 	tmpTag->offset = actuallen; // buffer_start ? buffer - buffer_start: 0;
+
 	tmpTag->tagNext = 0;
 
 	*tag = tmpTag;
@@ -804,17 +910,22 @@
 //==========================================================================
 // ParseTagDate
 
-static long
-ParseTagDate( char * buffer, TagPtr * tag )
+static long ParseTagDate( char *buffer, TagPtr *tag )
 {
-	long   length;
-	TagPtr tmpTag;
+	long		length = 0;
+	TagPtr		tmpTag;
 
 	length = FixDataMatchingTag(buffer, kXMLTagDate);
-	if (length == -1) return -1;
+	if (length == -1)
+	{
+		return -1;
+	}
 
 	tmpTag = NewTag();
-	if (tmpTag == 0) return -1;
+	if (tmpTag == 0)
+	{
+		return -1;
+	}
 
 	printf("ParseTagDate unimplimented\n");
 	getchar();
@@ -822,8 +933,8 @@
 	tmpTag->type = kTagTypeDate;
 	tmpTag->string = 0;
 	tmpTag->tag = 0;
+	tmpTag->tagNext = 0;
 	tmpTag->offset = buffer_start ? buffer - buffer_start: 0;
-	tmpTag->tagNext = 0;
 
 	*tag = tmpTag;
 
@@ -833,19 +944,21 @@
 //==========================================================================
 // ParseTagBoolean
 
-long
-ParseTagBoolean( char * buffer, TagPtr * tag, long type )
+long ParseTagBoolean( char *buffer, TagPtr *tag, long type )
 {
 	TagPtr tmpTag;
 
 	tmpTag = NewTag();
-	if (tmpTag == 0) return -1;
+	if (tmpTag == 0)
+	{
+		return -1;
+	}
 
 	tmpTag->type = type;
 	tmpTag->string = 0;
 	tmpTag->tag = 0;
+	tmpTag->tagNext = 0;
 	tmpTag->offset = buffer_start ? buffer - buffer_start: 0;
-	tmpTag->tagNext = 0;
 
 	*tag = tmpTag;
 
@@ -855,32 +968,44 @@
 //==========================================================================
 // GetNextTag
 
-static long
-GetNextTag( char * buffer, char ** tag, long * start )
+static long GetNextTag( char *buffer, char **tag, long *start )
 {
-	long cnt, cnt2;
+	long	cnt;
+	long	cnt2;
 
-	if (tag == 0) {
+	if (tag == 0)
+	{
 		return -1;
 	}
 
 	// Find the start of the tag.
 	cnt = 0;
-	while ((buffer[cnt] != '\0') && (buffer[cnt] != '<')) cnt++;
-	if (buffer[cnt] == '\0') {
+	while ((buffer[cnt] != '\0') && (buffer[cnt] != '<'))
+	{
+		cnt++;
+	}
+
+	if (buffer[cnt] == '\0')
+	{
 		return -1;
 	}
 	// Find the end of the tag.
 	cnt2 = cnt + 1;
-	while ((buffer[cnt2] != '\0') && (buffer[cnt2] != '>')) cnt2++;
-	if (buffer[cnt2] == '\0') {
+	while ((buffer[cnt2] != '\0') && (buffer[cnt2] != '>'))
+	{
+		cnt2++;
+	}
+
+	if (buffer[cnt2] == '\0')
+	{
 		return -1;
 	}
 
 	// Fix the tag data.
 	*tag = buffer + cnt + 1;
 	buffer[cnt2] = '\0';
-	if (start) {
+	if (start)
+	{
 		*start = cnt;
 	}
 
@@ -893,25 +1018,33 @@
 // Returns the length of the data found, counting the end tag,
 // or -1 if the end tag was not found.
 
-static long
-FixDataMatchingTag( char * buffer, char * tag )
+static long FixDataMatchingTag( char *buffer, char *tag )
 {
-    long   length, start, stop;
-    char * endTag;
-    
-    start = 0;
-    while (1)
-    {
-        length = GetNextTag(buffer + start, &endTag, &stop);
-        if (length == -1) return -1;
-        
-        if ((*endTag == '/') && !strcmp(endTag + 1, tag)) break;
-        start += length;
-    }
-    
-    buffer[start + stop] = '\0';
-    
-    return start + length;
+	long	length;
+	long	start;
+	long	stop;
+	char	*endTag;
+
+	start = 0;
+	while (1)
+	{
+		length = GetNextTag(buffer + start, &endTag, &stop);
+		if (length == -1)
+		{
+			return -1;
+		}
+
+		if ((*endTag == '/') && !strcmp(endTag + 1, tag))
+		{
+			break;
+		}
+
+		start += length;
+	}
+
+	buffer[start + stop] = '\0';
+
+	return start + length;
 }
 
 //==========================================================================
@@ -921,48 +1054,51 @@
 
 static TagPtr gTagsFree;
 
-static TagPtr
-NewTag( void )
+static TagPtr NewTag( void )
 {
-	long   cnt;
-	TagPtr tag;
+	long		cnt;
+	TagPtr		tag;
   
-    if (gTagsFree == 0)
-    {
-        tag = (TagPtr)malloc(kTagsPerBlock * sizeof(Tag));
-        if (tag == 0) return 0;
-        
-        // Initalize the new tags.
-        for (cnt = 0; cnt < kTagsPerBlock; cnt++)
-        {
-            tag[cnt].type = kTagTypeNone;
-            tag[cnt].string = 0;
-            tag[cnt].tag = 0;
-            tag[cnt].tagNext = tag + cnt + 1;
-        }
-        tag[kTagsPerBlock - 1].tagNext = 0;
+	if (gTagsFree == 0)
+	{
+		tag = (TagPtr)malloc(kTagsPerBlock *sizeof(Tag));
+		if (tag == 0)
+		{
+			return 0;
+		}
 
-        gTagsFree = tag;
-    }
+		// Initalize the new tags.
+		for (cnt = 0; cnt < kTagsPerBlock; cnt++)
+		{
+			tag[cnt].type = kTagTypeNone;
+			tag[cnt].string = 0;
+			tag[cnt].tag = 0;
+			tag[cnt].tagNext = tag + cnt + 1;
+		}
+		tag[kTagsPerBlock - 1].tagNext = 0;
 
-    tag = gTagsFree;
-    gTagsFree = tag->tagNext;
-    
-    return tag;
+		gTagsFree = tag;
+	}
+
+	tag = gTagsFree;
+	gTagsFree = tag->tagNext;
+
+	return tag;
 }
 
 //==========================================================================
 // XMLFreeTag
 
-void
-XMLFreeTag( TagPtr tag )
+void XMLFreeTag( TagPtr tag )
 {
 #if DOFREE
-	if (tag == 0) {
+	if (tag == 0)
+	{
 		return;
 	}
   
-	if (!XMLIsInteger(tag) && tag->string) {
+	if (!XMLIsInteger(tag) && tag->string)
+	{
 		FreeSymbol(tag->string);
 	}
 
@@ -992,26 +1128,28 @@
 };
 typedef struct Symbol Symbol, *SymbolPtr;
 
-static SymbolPtr FindSymbol(char * string, SymbolPtr * prevSymbol);
+static SymbolPtr FindSymbol(char *string, SymbolPtr *prevSymbol);
 
 static SymbolPtr gSymbolsHead;
 
 //==========================================================================
 // NewSymbol
 
-static char *
-NewSymbol( char * string )
+static char *NewSymbol( char *string )
 {
 	static SymbolPtr lastGuy = 0;
-	SymbolPtr symbol;
 
+	SymbolPtr	symbol;
+
 	// Look for string in the list of symbols.
 	symbol = FindSymbol(string, 0);
 
-    // Add the new symbol.
-	if (symbol == 0) {
+	// Add the new symbol.
+	if (symbol == 0)
+	{
 		symbol = (SymbolPtr)malloc(sizeof(Symbol) + 1 + strlen(string));
-		if (symbol == 0) { //return 0;
+		if (symbol == 0)
+		{	//return 0;
 			stop("NULL symbol!");
 		}
 
@@ -1027,7 +1165,8 @@
 	// Update the refCount and return the string.
 	symbol->refCount++;
 
-	if (lastGuy && lastGuy->next != 0) {
+	if (lastGuy && lastGuy->next != 0)
+	{
 		stop("last guy not last!");
 	}
 
@@ -1038,29 +1177,33 @@
 // FreeSymbol
 
 #if DOFREE
-static void
-FreeSymbol( char * string )
+static void FreeSymbol( char *string )
 {
 	SymbolPtr symbol, prev;
 	prev = 0;
 
 	// Look for string in the list of symbols.
 	symbol = FindSymbol(string, &prev);
-	if (symbol == 0) {
+	if (symbol == 0)
+	{
 		return;
 	}
 
 	// Update the refCount.
 	symbol->refCount--;
 
-	if (symbol->refCount != 0) {
+	if (symbol->refCount != 0)
+	{
 		return;
 	}
 
 	// Remove the symbol from the list.
-	if (prev != 0) {
+	if (prev != 0)
+	{
 		prev->next = symbol->next;
-	} else {
+	}
+	else
+	{
 		gSymbolsHead = symbol->next;
 	}
 
@@ -1072,16 +1215,17 @@
 //==========================================================================
 // FindSymbol
 
-static SymbolPtr
-FindSymbol( char * string, SymbolPtr * prevSymbol )
+static SymbolPtr FindSymbol( char *string, SymbolPtr *prevSymbol )
 {
 	SymbolPtr symbol, prev;
-  
+
 	symbol = gSymbolsHead;
 	prev = 0;
   
-	while (symbol != 0) {
-		if (!strcmp(symbol->string, string)) {
+	while (symbol != NULL)
+	{
+		if (!strcmp(symbol->string, string))
+		{
 			break;
 		}
     
@@ -1089,7 +1233,8 @@
 		symbol = symbol->next;
 	}
   
-	if ((symbol != 0) && (prevSymbol != 0)) {
+	if ((symbol != 0) && (prevSymbol != 0))
+	{
 		*prevSymbol = prev;
 	}
 
@@ -1098,7 +1243,8 @@
 
 bool XMLIsType(TagPtr dict, enum xmltype type)
 {
-	if(!dict) {
+	if(!dict)
+	{
 		return (type == kTagTypeNone);
 	}
 	return (dict->type == type);
@@ -1112,10 +1258,13 @@
 
 TagPtr XMLCastArray(TagPtr dict)
 {
-	if(!dict) {
+	if(!dict)
+	{
 		return NULL;
 	}
-	if(dict->type == kTagTypeArray) {
+
+	if(dict->type == kTagTypeArray)
+	{
 		return dict;
 	} else {
 		return NULL;
@@ -1134,12 +1283,17 @@
 
 TagPtr XMLCastDict(TagPtr dict)
 {
-	if(!dict) {
+	if(!dict)
+	{
 		return NULL;
 	}
-	if(dict->type == kTagTypeDict) {
+
+	if(dict->type == kTagTypeDict)
+	{
 		return dict;
-	} else {
+	}
+	else
+	{
 		return NULL;
 	}
 }
@@ -1149,26 +1303,30 @@
     return entry && ((entry->type == kTagTypeString) || (entry->type == kTagTypeKey));
 }
 
-char* XMLCastString(TagPtr dict)
+char *XMLCastString(TagPtr dict)
 {
-	if(!dict) {
+	if(!dict)
+	{
 		return NULL;
 	}
 
-	if((dict->type == kTagTypeString) || (dict->type == kTagTypeKey)) {
+	if((dict->type == kTagTypeString) || (dict->type == kTagTypeKey))
+	{
 		return dict->string;
 	}
 
 	return NULL;
 }
 
-char* XMLCastData(TagPtr dict, int* length)
+char *XMLCastData(TagPtr dict, int* length)
 {
-	if(!dict) {
+	if(!dict)
+	{
 		return NULL;
 	}
 
-	if((dict->type == kTagTypeData) || (dict->type == kTagTypeKey)) {
+	if((dict->type == kTagTypeData) || (dict->type == kTagTypeKey))
+	{
 		*length = dict->offset;
 		return dict->string;
 	}
@@ -1179,9 +1337,12 @@
 
 long XMLCastStringOffset(TagPtr dict)
 {
-	if(dict && ((dict->type == kTagTypeString) || (dict->type == kTagTypeKey))) {
+	if(dict && ((dict->type == kTagTypeString) || (dict->type == kTagTypeKey)))
+	{
 		return dict->offset;
-	} else {
+	}
+	else
+	{
 		return -1;
 	}
 }
@@ -1193,10 +1354,13 @@
 
 bool XMLCastBoolean(TagPtr dict)
 {
-	if(!dict) {
+	if(!dict)
+	{
 		return false;
 	}
-	if(dict->type == kTagTypeTrue) {
+
+	if(dict->type == kTagTypeTrue)
+	{
 		return true;
 	}
 	return false;
@@ -1209,19 +1373,23 @@
 
 int XMLCastInteger(TagPtr dict)
 {
-	if(!dict) {
+	if(!dict)
+	{
 		//printf("XMLCastInteger: null dict\n");
 		return 0;
 	}
-	if(dict->type == kTagTypeInteger) {
+
+	if(dict->type == kTagTypeInteger)
+	{
 		return (int)(dict->string);
 	}
 	return 0;
 }
 
-bool XMLAddTagToDictionary(TagPtr dict, char* key, TagPtr value)
+bool XMLAddTagToDictionary(TagPtr dict, char *key, TagPtr value)
 {
-	if (!dict || dict->type != kTagTypeDict) {
+	if (!dict || dict->type != kTagTypeDict)
+	{
 		return false;
 	}
 
@@ -1229,12 +1397,14 @@
 	char* string;
 
 	tmpTag = NewTag();
-	if (tmpTag == 0) {
+	if (tmpTag == 0)
+	{
 		return false;
 	}
 
 	string = NewSymbol(key);
-	if (string == 0) {
+	if (string == 0)
+	{
 		XMLFreeTag(tmpTag);
 		return false;
 	}
@@ -1246,13 +1416,15 @@
 	tmpTag->tagNext = 0;
 
 	TagPtr tagList = dict->tag;
-	if(!tagList) {
+	if(!tagList)
+	{
 		// First tag
 		dict->tag = tmpTag;
 		return true;
 	}
 	while(tagList && tagList->tagNext) tagList = tagList->tagNext;
-	if(tagList) {
+	if(tagList)
+	{
 		tagList->tagNext = tmpTag;
 		return true;
 	}
Index: trunk/i386/libsaio/efi.h
===================================================================
--- trunk/i386/libsaio/efi.h	(revision 2581)
+++ trunk/i386/libsaio/efi.h	(revision 2582)
@@ -254,7 +254,7 @@
   IN EFI_UINTN                    DescriptorSize,
   IN EFI_UINT32                   DescriptorVersion,
   IN EFI_MEMORY_DESCRIPTOR        * VirtualMap
-  );
+  ) __attribute__((regparm(0)));
 
 typedef
 EFI_RUNTIMESERVICE
@@ -262,7 +262,7 @@
 (EFIAPI *EFI_CONVERT_POINTER) (
   IN EFI_UINTN                DebugDisposition,
   IN OUT VOID                 **Address
-  );
+  ) __attribute__((regparm(0)));
 
 
 // Variable attributes
@@ -281,7 +281,7 @@
   OUT EFI_UINT32              * Attributes OPTIONAL,
   IN OUT EFI_UINTN            * DataSize,
   OUT VOID                    * Data
-  );
+  ) __attribute__((regparm(0)));
 
 typedef
 EFI_RUNTIMESERVICE
@@ -290,7 +290,7 @@
   IN OUT EFI_UINTN            * VariableNameSize,
   IN OUT EFI_CHAR16           * VariableName,
   IN OUT EFI_GUID             * VendorGuid
-  );
+  ) __attribute__((regparm(0)));
 
 typedef
 EFI_RUNTIMESERVICE
@@ -301,7 +301,7 @@
   IN EFI_UINT32               Attributes,
   IN EFI_UINTN                DataSize,
   IN VOID                     * Data
-  );
+  ) __attribute__((regparm(0)));
 
 
 // EFI Time
@@ -318,14 +318,14 @@
 (EFIAPI *EFI_GET_TIME) (
   OUT EFI_TIME                * Time,
   OUT EFI_TIME_CAPABILITIES   * Capabilities OPTIONAL
-  );
+  ) __attribute__((regparm(0)));
 
 typedef
 EFI_RUNTIMESERVICE
 EFI_STATUS
 (EFIAPI *EFI_SET_TIME) (
   IN EFI_TIME                 * Time
-  );
+  ) __attribute__((regparm(0)));
 
 typedef
 EFI_RUNTIMESERVICE
@@ -334,7 +334,7 @@
   OUT EFI_BOOLEAN             * Enabled,
   OUT EFI_BOOLEAN             * Pending,
   OUT EFI_TIME                * Time
-  );
+  ) __attribute__((regparm(0)));
 
 typedef
 EFI_RUNTIMESERVICE
@@ -342,7 +342,7 @@
 (EFIAPI *EFI_SET_WAKEUP_TIME) (
   IN EFI_BOOLEAN              Enable,
   IN EFI_TIME                 * Time OPTIONAL
-  );
+  ) __attribute((regparm(0)));
 
 typedef enum {
   EfiResetCold,
@@ -363,7 +363,7 @@
   IN EFI_STATUS                   ResetStatus,
   IN EFI_UINTN                    DataSize,
   IN EFI_CHAR16                   * ResetData OPTIONAL
-  );
+  ) __attribute__((regparm(0)));
 
 typedef
 EFI_RUNTIMESERVICE
@@ -391,7 +391,7 @@
   IN EFI_UINT32                 Instance,
   IN EFI_GUID                   * CallerId OPTIONAL,
   IN EFI_STATUS_CODE_DATA       * Data OPTIONAL
-  );
+  ) __attribute__((regparm(0)));
 
 #endif
 //
Index: trunk/i386/libsaio/vbe.c
===================================================================
--- trunk/i386/libsaio/vbe.c	(revision 2581)
+++ trunk/i386/libsaio/vbe.c	(revision 2582)
@@ -129,7 +129,7 @@
 #define kC                30.0   // C = (C'-J) * (K/256) + J
 #define kM                300.0  // M = K/256 * M'
 
-int Round(double f)
+static int Round(double f)
 {
 	return (int)(f + 0.5);
 }
Index: trunk/i386/libsaio/device_tree.c
===================================================================
--- trunk/i386/libsaio/device_tree.c	(revision 2581)
+++ trunk/i386/libsaio/device_tree.c	(revision 2582)
@@ -82,8 +82,7 @@
 
 //==============================================================================
 
-Property *
-DT__AddProperty(Node *node, const char *name, uint32_t length, void *value)
+Property *DT__AddProperty(Node *node, const char *name, uint32_t length, void *value)
 {
 	Property *prop;
 
@@ -143,8 +142,7 @@
 
 //==============================================================================
 
-Node *
-DT__AddChild(Node *parent, const char *name)
+Node *DT__AddChild(Node *parent, const char *name)
 {
 	Node *node;
 
@@ -206,8 +204,7 @@
 
 //==============================================================================
 
-void
-DT__FreeProperty(Property *prop)
+void DT__FreeProperty(Property *prop)
 {
 	prop->next = freeProperties;
 	freeProperties = prop;
@@ -215,8 +212,7 @@
 
 //==============================================================================
 
-void
-DT__FreeNode(Node *node)
+void DT__FreeNode(Node *node)
 {
 	node->next = freeNodes;
 	freeNodes = node;
@@ -224,8 +220,7 @@
 
 //==============================================================================
 
-void
-DT__Initialize(void)
+void DT__Initialize(void)
 {
 	DPRINTF("DT__Initialize\n");
 
@@ -246,8 +241,7 @@
 /*
  * Free up memory used by in-memory representation of device tree.
  */
-void
-DT__Finalize(void)
+void DT__Finalize(void)
 {
 	Node *node;
 	Property *prop;
@@ -280,8 +274,7 @@
 
 //==============================================================================
 
-static void *
-FlattenNodes(Node *node, void *buffer)
+static void *FlattenNodes(Node *node, void *buffer)
 {
 	Property *prop;
 	DeviceTreeNode *flatNode;
@@ -325,8 +318,7 @@
  * To use your own buffer, call with *result = &buffer.
  */
 
-void
-DT__FlattenDeviceTree(void **buffer_p, uint32_t *length)
+void DT__FlattenDeviceTree(void **buffer_p, uint32_t *length)
 {
 	uint32_t totalSize;
 	void * buf;
@@ -378,8 +370,7 @@
 
 //==============================================================================
 
-char *
-DT__GetName(Node *node)
+char *DT__GetName(Node *node)
 {
 	Property *prop;
 
@@ -400,8 +391,7 @@
 
 //==============================================================================
 // Bungo
-Property *
-DT__GetProperty(Node *node, const char *name)
+Property *DT__GetProperty(Node *node, const char *name)
 {
 	Property *prop;
 
@@ -418,8 +408,7 @@
 
 //==============================================================================
 
-Node *
-DT__FindNode(const char *path, bool createIfMissing)
+Node *DT__FindNode(const char *path, bool createIfMissing)
 {
 	Node *node, *child;
 	DTPropertyNameBuf nameBuf;
@@ -486,8 +475,7 @@
 
 //==============================================================================
 
-void
-DT__PrintNode(Node *node, int level)
+void DT__PrintNode(Node *node, int level)
 {
 	char spaces[10], *cp = spaces;
 	Property *prop;
@@ -524,8 +512,7 @@
 
 //==============================================================================
 
-static void
-_PrintTree(Node *node, int level)
+static void _PrintTree(Node *node, int level)
 {
 	DT__PrintNode(node, level);
 
@@ -539,8 +526,7 @@
 
 //==============================================================================
 
-void
-DT__PrintTree(Node *node)
+void DT__PrintTree(Node *node)
 {
 	if (node == 0) node = rootNode;
 	_PrintTree(node, 0);
@@ -548,8 +534,7 @@
 
 //==============================================================================
 
-void
-DT__PrintFlattenedNode(DTEntry entry, int level)
+void DT__PrintFlattenedNode(DTEntry entry, int level)
 {
 	char spaces[10], *cp = spaces;
 	DTPropertyIterator	                propIter;
@@ -580,8 +565,7 @@
 
 //==============================================================================
 
-static void
-_PrintFlattenedTree(DTEntry entry, int level)
+static void _PrintFlattenedTree(DTEntry entry, int level)
 {
 	DTEntryIterator entryIter;
 
@@ -602,16 +586,14 @@
 
 //==============================================================================
 
-void
-DT__PrintFlattenedTree(DTEntry entry)
+void DT__PrintFlattenedTree(DTEntry entry)
 {
 	_PrintFlattenedTree(entry, 0);
 }
 
 //==============================================================================
 
-int
-main(int argc, char **argv)
+int main(int argc, char **argv)
 {
 	DTEntry			dtEntry;
 	DTPropertyIterator	propIter;
Index: trunk/i386/libsaio/hfs.c
===================================================================
--- trunk/i386/libsaio/hfs.c	(revision 2581)
+++ trunk/i386/libsaio/hfs.c	(revision 2582)
@@ -295,7 +295,7 @@
 	char entry[512];
 	char devStr[12];
 	u_int32_t dirID;
-	long result, flags;
+	long result, flags = 0;
 
 	if (HFSInitPartition(ih) == -1)
 	{
@@ -647,6 +647,8 @@
 		*flags = kFileTypeUnknown;
 		tmpTime = 0;
 		break;
+	default:
+		break;
 	}
 
 	if (time != 0)
@@ -920,6 +922,12 @@
 	curNode  = SWAP_BE32(gBTHeaders[btree]->rootNode);
 	nodeSize = SWAP_BE16(gBTHeaders[btree]->nodeSize);
 	nodeBuf  = (char *)malloc(nodeSize);
+
+	if (!nodeBuf) 
+	{
+		return -1;
+	}
+
 	node     = (BTNodeDescriptor *)nodeBuf;
 
 	while (1)
@@ -1018,6 +1026,8 @@
 				break;
 			case kHFSPlusFileThreadRecord   : entrySize = 264;
 				break;
+			default:
+				break;
 		}
 	}
 	else
Index: trunk/i386/libsaio/nvidia.c
===================================================================
--- trunk/i386/libsaio/nvidia.c	(revision 2581)
+++ trunk/i386/libsaio/nvidia.c	(revision 2582)
@@ -2323,11 +2323,11 @@
 	devprop_add_nvidia_template(device);
 	devprop_add_value(device, "NVCAP", default_NVCAP, NVCAP_LEN);
 	devprop_add_value(device, "NVPM", default_NVPM, NVPM_LEN);
-	devprop_add_value(device, "VRAM,totalsize", (uint8_t*)&videoRam, 4);
-	devprop_add_value(device, "model", (uint8_t*)model, strlen(model) + 1);
-	devprop_add_value(device, "rom-revision", (uint8_t*)biosVersion, strlen(biosVersion) + 1);
-	devprop_add_value(device, "@0,display-cfg", default_dcfg_0, DCFG0_LEN);
-	devprop_add_value(device, "@1,display-cfg", default_dcfg_1, DCFG1_LEN);
+	devprop_add_value(device, "VRAM,totalsize", (uint8_t *)&videoRam, 4);
+	devprop_add_value(device, "model", (uint8_t *)model, strlen(model) + 1);
+	devprop_add_value(device, "rom-revision", (uint8_t *)biosVersion, strlen(biosVersion) + 1);
+	devprop_add_value(device, "@0,display-cfg", (uint8_t *)&default_dcfg_0, DCFG0_LEN);
+	devprop_add_value(device, "@1,display-cfg", (uint8_t *)&default_dcfg_1, DCFG1_LEN);
 
 	/******************** Added Marchrius.**********************/
 	//              For the AppleBacklightDisplay              //
Index: trunk/i386/libsaio/ati.c
===================================================================
--- trunk/i386/libsaio/ati.c	(revision 2581)
+++ trunk/i386/libsaio/ati.c	(revision 2582)
@@ -137,7 +137,12 @@
 	{"Hamachi",	4},
 	{"OPM",         6},
 	{"Ikura",       6},
-	{"IkuraS",      1}
+	{"IkuraS",      1},
+	/* AMD8000Controller */
+	{"Baladi",      5},	//desktop
+	{"Exmoor",      4},	//mobile
+	{"Basset",      4}
+
 };
 
 static radeon_card_info_t radeon_cards[] = {
@@ -1500,7 +1505,8 @@
 //	{ 0x99A2,	0x00000000, CHIP_FAMILY_ARUBA,	"AMD Radeon HD",      kNull       }, // Mobile
 //	{ 0x99A4,	0x00000000, CHIP_FAMILY_ARUBA,	"AMD Radeon HD",      kNull       },
 
-	{ 0x6613,	0x00000000, CHIP_FAMILY_BONAIRE,	"AMD Radeon R7 240",	kFutomaki		},
+	{ 0x6610,	0x00000000, CHIP_FAMILY_OLAND,		"AMD Radeon R7 250",	kFutomaki		},
+	{ 0x6613,	0x00000000, CHIP_FAMILY_OLAND,		"AMD Radeon R7 240",	kFutomaki		},
 	{ 0x665C,	0x00000000, CHIP_FAMILY_BONAIRE,	"AMD Radeon HD 7790",	kFutomaki		},
 	{ 0x665D,	0x00000000, CHIP_FAMILY_BONAIRE,	"AMD Radeon R9 260",	kFutomaki		},
 
@@ -1641,8 +1647,8 @@
 //	{ 0x67A8,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon",            kFutomaki	},
 //	{ 0x67A9,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon",            kFutomaki	},
 //	{ 0x67AA,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon",            kFutomaki	},
-	{ 0x67B0,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon R9 290X",           kFutomaki	},
-	{ 0x67B1,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon R9 290",            kFutomaki	}, // CHIP_FAMILY_HAWAII
+	{ 0x67B0,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon R9 290X",           kBaladi	},
+	{ 0x67B1,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon R9 290",            kBaladi	}, // CHIP_FAMILY_HAWAII
 //	{ 0x67B8,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon",            kFutomaki	},
 //	{ 0x67B9,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon",            kFutomaki	},
 //	{ 0x67BA,	0x00000000, CHIP_FAMILY_HAWAII,	"AMD Radeon",            kFutomaki	},
@@ -1770,7 +1776,7 @@
 	val->type = kCst;
 	val->size = 4;
 	val->data = (uint8_t *)&v;
-	
+
 	return true;
 }
 
@@ -1850,7 +1856,7 @@
 	val->type = kPtr;
 	val->size = card->rom_size;
 	val->data = card->rom;
-	
+
 	return true;
 }
 
@@ -2284,11 +2290,12 @@
 }
 #endif
 
+static char	name[24];
+static char	name_parent[24];
+
 static bool init_card(pci_dt_t *pci_dev)
 {
 	bool	add_vbios = true;
-	char	name[24];
-	char	name_parent[24];
 	int		i;
 	int		n_ports = 0;
 
@@ -2347,7 +2354,7 @@
 			{
 				read_disabled_vbios();
 			}
-			verbose("\n");
+			verbose("Video BIOS read from file\n");
 		}
 	}
 
Index: trunk/i386/libsaio/load.c
===================================================================
--- trunk/i386/libsaio/load.c	(revision 2581)
+++ trunk/i386/libsaio/load.c	(revision 2582)
@@ -57,17 +57,20 @@
 	struct fat_arch   *fap = (struct fat_arch *)((unsigned long)*binary + sizeof(struct fat_header));
 	cpu_type_t fapcputype;
 	uint32_t fapoffset;
-	uint32_t fapsize;	
+	uint32_t fapsize;
 
 	if (fhp->magic == FAT_MAGIC)/* 0xcafebabe */
 	{
 		nfat = fhp->nfat_arch;
 		swapped = 0;
-	} else if (fhp->magic == FAT_CIGAM)/* 0xbebafeca */
+	}
+	else if (fhp->magic == FAT_CIGAM)/* 0xbebafeca */
 	{
 		nfat = OSSwapInt32(fhp->nfat_arch);
 		swapped = 1;
-	} else {
+	}
+	else
+	{
 		return -1;
 	}
 
@@ -78,7 +81,9 @@
 			fapcputype = OSSwapInt32(fap->cputype);
 			fapoffset = OSSwapInt32(fap->offset);
 			fapsize = OSSwapInt32(fap->size);
-		} else {
+		}
+		else
+		{
 			fapcputype = fap->cputype;
 			fapoffset = fap->offset;
 			fapsize = fap->size;
@@ -258,12 +263,14 @@
 		segname = segCmd->segname;
 
 #ifdef DEBUG
-  printf("segname: %s, vmaddr: %x, vmsize: %x, fileoff: %x, filesize: %x, nsects: %d, flags: %x.\n",
-	 segCmd->segname, (unsigned)vmaddr, (unsigned)vmsize, (unsigned)fileaddr, (unsigned)filesize,
-         (unsigned) segCmd->nsects, (unsigned)segCmd->flags);
-  getchar();
+	printf("segname: %s, vmaddr: %x, vmsize: %x, fileoff: %x, filesize: %x, nsects: %d, flags: %x.\n",
+		segCmd->segname, (unsigned)vmaddr, (unsigned)vmsize, (unsigned)fileaddr, (unsigned)filesize,
+		(unsigned) segCmd->nsects, (unsigned)segCmd->flags);
+	getchar();
 #endif
-	} else {
+	}
+	else
+	{
 		struct segment_command *segCmd;
 
 		segCmd = (struct segment_command *)cmdBase;
@@ -276,7 +283,7 @@
 
 #ifdef DEBUG
 	printf("segname: %s, vmaddr: %x, vmsize: %x, fileoff: %x, filesize: %x, nsects: %d, flags: %x.\n",
-	segCmd->segname, (unsigned)vmaddr, (unsigned)vmsize, (unsigned)fileaddr, (unsigned)filesize, (unsigned) segCmd->nsects, (unsigned)segCmd->flags);
+		segCmd->segname, (unsigned)vmaddr, (unsigned)vmsize, (unsigned)fileaddr, (unsigned)filesize, (unsigned) segCmd->nsects, (unsigned)segCmd->flags);
 	getchar();
 #endif
 	}
@@ -289,21 +296,25 @@
 	}
 
 	if (! ((vmaddr >= KERNEL_ADDR && (vmaddr + vmsize) <= (KERNEL_ADDR + KERNEL_LEN)) ||
-		 (vmaddr >= HIB_ADDR && (vmaddr + vmsize) <= (HIB_ADDR + HIB_LEN)))) {
+		 (vmaddr >= HIB_ADDR && (vmaddr + vmsize) <= (HIB_ADDR + HIB_LEN))))
+	{
 		stop("Kernel overflows available space");
 	}
 
-	if (vmsize && ((strcmp(segname, "__PRELINK_INFO") == 0) || (strcmp(segname, "__PRELINK") == 0))) {
+	if (vmsize && ((strcmp(segname, "__PRELINK_INFO") == 0) || (strcmp(segname, "__PRELINK") == 0)))
+	{
 		gHaveKernelCache = true;
 	}
 
 	// Copy from file load area.
-	if (vmsize>0 && filesize > 0) {
+	if (vmsize>0 && filesize > 0)
+	{
 		bcopy((char *)fileaddr, (char *)vmaddr, vmsize > filesize ? filesize : vmsize);
 	}
 
 	// Zero space at the end of the segment.
-	if (vmsize > filesize) {
+	if (vmsize > filesize)
+	{
 		bzero((char *)(vmaddr + filesize), vmsize - filesize);
 	}
 
@@ -317,7 +328,8 @@
 
 static long DecodeUnixThread(long cmdBase, unsigned int *entry)
 {
-	switch (archCpuType) {
+	switch (archCpuType)
+	{
 		case CPU_TYPE_I386:
 		{
 			i386_thread_state_t *i386ThreadState;
@@ -355,8 +367,8 @@
 	symTab = (struct symtab_command *)cmdBase;
 
 #if DEBUG
-
-	printf("symoff: %x, nsyms: %x, stroff: %x, strsize: %x\n", symTab->symoff, symTab->nsyms, symTab->stroff, symTab->strsize);
+	printf("symoff: %x, nsyms: %x, stroff: %x, strsize: %x\n",
+		symTab->symoff, symTab->nsyms, symTab->stroff, symTab->strsize);
 	getchar();
 #endif
 
Index: trunk/i386/libsaio/ati.h
===================================================================
--- trunk/i386/libsaio/ati.h	(revision 2581)
+++ trunk/i386/libsaio/ati.h	(revision 2582)
@@ -179,6 +179,10 @@
 	kOPM,
 	kIkura,
 	kIkuraS,
+	/* AMD8000Controller */
+	kBaladi,
+	kExmoor,
+	kBasset,
 	kCfgEnd
 } ati_config_name_t;
 
Index: trunk/i386/libsaio/cpu.c
===================================================================
--- trunk/i386/libsaio/cpu.c	(revision 2581)
+++ trunk/i386/libsaio/cpu.c	(revision 2582)
@@ -312,11 +312,11 @@
 		cores_per_package = 1;
 	}
 
-	if (p->CPU.CPUID[CPUID_0][0] >= 0x5) // Monitor/Mwait
+	if (p->CPU.CPUID[CPUID_0][0] >= 0x5)	// Monitor/Mwait
 	{
 		do_cpuid(5,  p->CPU.CPUID[CPUID_5]);
 	}
-	if (p->CPU.CPUID[CPUID_0][0] >= 6) // Thermal/Power
+	if (p->CPU.CPUID[CPUID_0][0] >= 6)	// Thermal/Power
 	{
 		do_cpuid(6, p->CPU.CPUID[CPUID_6]);
 	}
Index: trunk/i386/libsaio/platform.h
===================================================================
--- trunk/i386/libsaio/platform.h	(revision 2581)
+++ trunk/i386/libsaio/platform.h	(revision 2582)
@@ -35,7 +35,7 @@
 #define CPUID_MODEL_DOTHAN		0x0D			// Dothan Pentium M, Celeron M (90nm)
 #define CPUID_MODEL_YONAH		0x0E			// Sossaman, Yonah
 #define CPUID_MODEL_MEROM		0x0F			// Allendale, Conroe, Kentsfield, Woodcrest, Clovertown, Tigerton, Merom
-#define CPUID_MODEL_CONROE		0x0F			// 
+#define CPUID_MODEL_CONROE		0x0F			//
 #define CPUID_MODEL_CELERON		0x16			// Merom, Conroe (65nm), Celeron (45nm)
 #define CPUID_MODEL_PENRYN		0x17			// Wolfdale, Yorkfield, Harpertown, Penryn
 #define CPUID_MODEL_WOLFDALE		0x17			// Xeon 31xx, 33xx, 52xx, 54xx, Core 2 Quad 8xxx and 9xxx
@@ -337,6 +337,7 @@
 
 /* Maximum number of ram slots */
 #define MAX_RAM_SLOTS			8
+
 #define RAM_SLOT_ENUMERATOR		{0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11}
 
 /* Maximum number of SPD bytes */
Index: trunk/i386/libsaio/pci_setup.c
===================================================================
--- trunk/i386/libsaio/pci_setup.c	(revision 2581)
+++ trunk/i386/libsaio/pci_setup.c	(revision 2582)
@@ -2,11 +2,18 @@
 #include "boot.h"
 #include "bootstruct.h"
 #include "pci.h"
-#include "gma.h"
-#include "nvidia.h"
-#include "hda.h"
 #include "modules.h"
 
+#ifndef DEBUG_PCI_SETUP
+#define DEBUG_PCI_SETUP 0
+#endif
+
+#if DEBUG_PCI_SETUP
+#define DBG(x...)	printf(x)
+#else
+#define DBG(x...)
+#endif
+
 extern bool setup_ati_devprop(pci_dt_t *ati_dev);
 extern bool setup_nvidia_devprop(pci_dt_t *nvda_dev);
 extern bool setup_gma_devprop(pci_dt_t *gma_dev);
@@ -37,13 +44,15 @@
 		switch (current->class_id)
 		{
 			case PCI_CLASS_BRIDGE_HOST:
+				DBG("Setup BRIDGE_HOST \n");
 				if (current->dev.addr == PCIADDR(0, 0, 0))
 				{
 					dram_controller_dev = current;
 				}
 				break; // PCI_CLASS_BRIDGE_HOST
-				
+
 			case PCI_CLASS_NETWORK_ETHERNET:
+				DBG("Setup ETHERNET %s enabled\n", do_eth_devprop? "is":"is not");
 				if (do_eth_devprop)
 				{
 					set_eth_builtin(current);
@@ -51,6 +60,7 @@
 				break; // PCI_CLASS_NETWORK_ETHERNET
 
 			case PCI_CLASS_DISPLAY_VGA:
+				DBG("GraphicsEnabler %s enabled\n", do_gfx_devprop? "is":"is not");
 				if (do_gfx_devprop)
 				{
 					switch (current->vendor_id)
@@ -95,6 +105,7 @@
 				break; // PCI_CLASS_DISPLAY_VGA
 
 			case PCI_CLASS_MULTIMEDIA_AUDIO_DEV:
+				DBG("Setup HDEF %s enabled\n", do_hda_devprop? "is":"is not");
 				if (do_hda_devprop)
 				{
 					setup_hda_devprop(current);
@@ -102,10 +113,12 @@
 				break; // PCI_CLASS_MULTIMEDIA_AUDIO_DEV
 
 			case PCI_CLASS_SERIAL_USB:
+				DBG("USB\n");
 				notify_usb_dev(current);
 				break; // PCI_CLASS_SERIAL_USB
 
 			case PCI_CLASS_BRIDGE_ISA:
+				DBG("Force HPET %s enabled\n", do_enable_hpet? "is":"is not");
 				if (do_enable_hpet)
 				{
 					force_enable_hpet(current);
@@ -115,7 +128,7 @@
 			}
 
 		execute_hook("PCIDevice", current, NULL, NULL, NULL);
-		
+		DBG("setup_pci_devs current device ID = [%04x:%04x]\n", current->vendor_id, current->device_id);
 		setup_pci_devs(current->children);
 		current = current->next;
 	}
Index: trunk/i386/libsaio/nvidia_helper.c
===================================================================
--- trunk/i386/libsaio/nvidia_helper.c	(revision 2581)
+++ trunk/i386/libsaio/nvidia_helper.c	(revision 2582)
@@ -52,28 +52,28 @@
  
  */
 
-cardList_t* cardList = NULL;
+cardList_t *cardList = NULL;
 
-void add_card(char* model, uint32_t id, uint32_t subid, uint64_t videoRam)
+void add_card(char *model, uint32_t id, uint32_t subid, uint64_t videoRam)
 {
 	
-	cardList_t* new_card = malloc(sizeof(cardList_t));
+	cardList_t *new_card = malloc(sizeof(cardList_t));
 	if (new_card)
 	{	
 		new_card->next = cardList;
 		
 		cardList = new_card;
 		
-		new_card->id = id;
-		new_card->subid = subid;
-		new_card->videoRam = videoRam;
-		new_card->model = model;
+		new_card->id		= id;
+		new_card->subid		= subid;
+		new_card->videoRam	= videoRam;
+		new_card->model		= model;
 	}	
 }
 
-cardList_t* FindCardWithIds(uint32_t id, uint32_t subid)
+cardList_t *FindCardWithIds(uint32_t id, uint32_t subid)
 {
-	cardList_t* entry = cardList;
+	cardList_t *entry = cardList;
 	while(entry)
 	{		
 		if((entry->id == id) && (entry->subid == subid))
@@ -108,12 +108,16 @@
 void fill_card_list(void) 
 {
 	unsigned int	i, count;
-	TagPtr NVDIATag;                           
-	char *model_name = NULL, *match_id = NULL, *sub_id = NULL, *vram_size = NULL;	
-	uint32_t dev_id = 0, subdev_id = 0;
-	uint64_t  VramSize = 0;	
+	TagPtr		NVDIATag;
+	char		*model_name = NULL;
+	char		*match_id = NULL;
+	char		*sub_id = NULL;
+	char		*vram_size = NULL;
+	uint32_t	dev_id = 0;
+	uint32_t	subdev_id = 0;
+	uint64_t	VramSize = 0;
 	
-	if ((NVDIATag = XMLCastArray(XMLGetProperty(bootInfo->chameleonConfig.dictionary, (const char*)"NVIDIA"))))
+	if ((NVDIATag = XMLCastArray(XMLGetProperty(bootInfo->chameleonConfig.dictionary, (const char *)"NVIDIA"))))
 	{
 		count = XMLTagCount(NVDIATag);
 		
@@ -127,15 +131,18 @@
 				model_name  = XMLCastString(XMLGetProperty(element, (const char*)"Chipset Name"));
 				vram_size  = XMLCastString(XMLGetProperty(element, (const char*)"VRam Size"));
 				
-				if (match_id) {
+				if (match_id)
+				{
 					dev_id = strtoul(match_id, NULL, 16);
 				}
 				
-				if (sub_id) {
+				if (sub_id)
+				{
 					subdev_id = strtoul(sub_id, NULL, 16);
 				}
 				
-				if (vram_size) {
+				if (vram_size)
+				{
 					VramSize = strtoul(vram_size, NULL, 10);
 				}
 				
Index: trunk/i386/libsaio/pci.c
===================================================================
--- trunk/i386/libsaio/pci.c	(revision 2581)
+++ trunk/i386/libsaio/pci.c	(revision 2582)
@@ -14,7 +14,7 @@
 #endif
 
 #if DEBUG_PCI
-#define DBG(x...)		printf(x)
+#define DBG(x...)	printf(x)
 #else
 #define DBG(x...)
 #endif
@@ -213,7 +213,7 @@
 	while (current) {
 		printf("%02x:%02x.%x [%04x%02x] [%04x:%04x] (subsys [%04x:%04x]):: %s\n", 
 			current->dev.bits.bus, current->dev.bits.dev, current->dev.bits.func, 
-			current->class_id, 0 /* FIXME: what should this be? */,
+			current->class_id, current->progif,
 			current->vendor_id, current->device_id,
 			current->subsys_id.subsys.vendor_id, current->subsys_id.subsys.device_id, 
 			get_pci_dev_path(current));
Index: trunk/i386/libsaio/md5c.c
===================================================================
--- trunk/i386/libsaio/md5c.c	(revision 2581)
+++ trunk/i386/libsaio/md5c.c	(revision 2582)
@@ -166,11 +166,14 @@
 		    partLen);
 		MD5Transform (context->state, context->buffer);
 
-		for (i = partLen; i + 63 < inputLen; i += 64) {
+		for (i = partLen; i + 63 < inputLen; i += 64)
+		{
 			MD5Transform (context->state, &((const unsigned char *)input)[i]);
 		}
 		index = 0;
-	} else {
+	}
+	else
+	{
 		i = 0;
 	}
 
Index: trunk/i386/boot2/graphics.c
===================================================================
--- trunk/i386/boot2/graphics.c	(revision 2581)
+++ trunk/i386/boot2/graphics.c	(revision 2582)
@@ -1120,8 +1120,8 @@
                             unsigned long numbers[],
                             unsigned long maxArrayCount )
 {
-	char		*propStr;
-	unsigned long	count = 0;
+	char            *propStr;
+	unsigned long   count       = 0;
 
 	propStr = newStringForKey((char *)propKey , &bootInfo->chameleonConfig);
 
Index: trunk/i386/boot2/drivers.c
===================================================================
--- trunk/i386/boot2/drivers.c	(revision 2581)
+++ trunk/i386/boot2/drivers.c	(revision 2582)
@@ -740,11 +740,12 @@
 //==========================================================================
 // MatchLibraries
 
-static long
-MatchLibraries( void )
+static long MatchLibraries( void )
 {
-	TagPtr     prop, prop2;
-	ModulePtr  module, module2;
+	TagPtr     prop;
+	TagPtr     prop2;
+	ModulePtr  module;
+	ModulePtr  module2;
 	long       done;
 
 	do {
@@ -798,8 +799,7 @@
 // FindModule
 
 #if NOTDEF
-static ModulePtr
-FindModule( char * name )
+static ModulePtr FindModule( char *name )
 {
 	ModulePtr module;
 	TagPtr    prop;
@@ -825,15 +825,14 @@
 //==========================================================================
 // ParseXML
 
-static long
-ParseXML( char * buffer, ModulePtr * module, TagPtr * personalities )
+static long ParseXML( char *buffer, ModulePtr *module, TagPtr *personalities )
 {
-	long       length, pos;
-	TagPtr     moduleDict, required;
-	ModulePtr  tmpModule;
-  
-	pos = 0;
-  
+	long		length;
+	long		pos = 0;
+	TagPtr		moduleDict;
+	TagPtr		required;
+	ModulePtr	tmpModule;
+
 	while (1)
 	{
 		length = XMLParseNextTag(buffer + pos, &moduleDict);
Index: trunk/i386/boot2/resume.c
===================================================================
--- trunk/i386/boot2/resume.c	(revision 2581)
+++ trunk/i386/boot2/resume.c	(revision 2582)
@@ -54,6 +54,7 @@
 	dst   = (unsigned long *) (header->restore1CodePhysPage << 12);
 	count = header->restore1PageCount;
 	proc  = (header->restore1CodeOffset + ((uint32_t) dst));
+
 	newSP = header->restore1StackOffset + (header->restore1CodePhysPage << 12);
 
 	src  = (unsigned long *) (((u_int32_t) &header->fileExtentMap[0]) 
Index: trunk/i386/boot2/boot.c
===================================================================
--- trunk/i386/boot2/boot.c	(revision 2581)
+++ trunk/i386/boot2/boot.c	(revision 2582)
@@ -425,9 +425,9 @@
 	bool	 		firstRun = true;
 	bool	 		instantMenu;
 	bool	 		rescanPrompt;
-	int				status;
-	unsigned int	allowBVFlags = kBVFlagSystemVolume | kBVFlagForeignBoot;
-	unsigned int	denyBVFlags = kBVFlagEFISystem;
+	int			status;
+	unsigned int		allowBVFlags = kBVFlagSystemVolume | kBVFlagForeignBoot;
+	unsigned int		denyBVFlags = kBVFlagEFISystem;
 
 	// Set reminder to unload the PXE base code. Neglect to unload
 	// the base code will result in a hang or kernel panic.
Index: trunk/i386/boot2/boot.h
===================================================================
--- trunk/i386/boot2/boot.h	(revision 2581)
+++ trunk/i386/boot2/boot.h	(revision 2582)
@@ -119,13 +119,13 @@
 #define kEHCIhard			"EHCIhard"		/* usb.c */
 #define kDefaultPartition		"Default Partition"	/* sys.c */
 
-/* Zenith432: added this */
+/* Zenith432: added this key */
 #define kXHCILegacyOff			"XHCILegacyOff"		/* usb.c */
 
-/* Duvel300: added this */
+/* Duvel300: added this key */
 #define kRestartFix			"RestartFix"		/* acpi_patcher.c */
 
-/* Slice: added this */
+/* Slice: added these keys */
 #define kPS2RestartFix			"PS2RestartFix"		/* acpi_patcher.c */
 #define kUseIntelHDMI			"UseIntelHDMI"		/* ati.c && nvidia.c && gma.c */
 
@@ -154,7 +154,7 @@
 #define kDcfg0				"display_0"			/* nvidia.c */
 #define kDcfg1				"display_1"			/* nvidia.c */
 
-/* Marchrius: added these keys */
+/* Marchrius: added this key */
 #define kEnableBacklight		"EnableBacklight"		/* nvidia.c */
 
 /* Kabyl: added these keys */
@@ -180,10 +180,10 @@
 #define kHDEFLayoutID			"HDEFLayoutID"			/* hda.c */
 #define kHDAULayoutID			"HDAULayoutID"			/* hda.c */
 
-/* Karas: added these keys */
+/* Karas: added this key */
 #define kMemFullInfo			"ForceFullMemInfo"		/* smbios.c */
 
-/* Bungo: added these keys */
+/* Bungo: added this key */
 #define kPrivateData			"PrivateData"			/* smbios_decode.c */
 
 
Index: trunk/i386/boot2/gui.c
===================================================================
--- trunk/i386/boot2/gui.c	(revision 2581)
+++ trunk/i386/boot2/gui.c	(revision 2582)
@@ -13,6 +13,16 @@
 #include "appleboot.h"
 #include "vers.h"
 
+#ifndef DEBUG_GUI
+#define DEBUG_GUI 0
+#endif
+
+#if DEBUG_GUI
+#define DBG(x...)	printf(x)
+#else
+#define DBG(x...)
+#endif
+
 #define IMG_REQUIRED -1
 #define THEME_NAME_DEFAULT	"Default"
 static const char *theme_name = THEME_NAME_DEFAULT;
@@ -456,6 +466,8 @@
 	initFont( &font_console, &images[iFontConsole]);
 	initFont( &font_small, &images[iFontSmall]);
 
+//	DBG("Graphic objects successfully loaded !!\n",theme_name);
+
 	return 0;
 }
 
@@ -524,13 +536,18 @@
 int createBackBuffer( window_t *window )
 {
 	gui.backbuffer = malloc(sizeof(pixmap_t));
-	if(!gui.backbuffer) {
+	if(!gui.backbuffer)
+	{
+//		DBG("Unable to allocate memory for gui.backbuffer");
 		return 1;
 	}
+
 	gui.backbuffer->pixels = malloc( window->width * window->height * 4 );
-	if(!gui.backbuffer->pixels) {
+	if(!gui.backbuffer->pixels)
+	{
 		free(gui.backbuffer);
 		gui.backbuffer = 0;
+//		DBG("Unable to allocate memory for gui.backbuffer->pixels");
 		return 1;
 	}
 	
@@ -545,14 +562,18 @@
 int createWindowBuffer( window_t *window )
 {
 	window->pixmap = malloc(sizeof(pixmap_t));
-	if(!window->pixmap) {
+	if(!window->pixmap)
+	{
+//		DBG("Unable to allocate memory for window->pixmap");
 		return 1;
 	}
 
 	window->pixmap->pixels = malloc( window->width * window->height * 4 );
-	if(!window->pixmap->pixels) {
+	if(!window->pixmap->pixels)
+	{
 		free(window->pixmap);
 		window->pixmap = 0;
+//		DBG("Unable to allocate memory for window->pixmap->pixels");
 		return 1;
 	}
 	
@@ -566,11 +587,13 @@
 
 int freeWindowBuffer( window_t *window )
 {
-	if (window->pixmap && window->pixmap->pixels) {
+	if (window->pixmap && window->pixmap->pixels)
+	{
 		free(window->pixmap->pixels);
 		free(window->pixmap);
 		return 0;
 	}
+
 	return 1;
 }
 
@@ -620,18 +643,22 @@
 	int val, len;
 	const char *string;	
 
-	if(getIntForKey("devices_max_visible", &val, theme )) {
+	if(getIntForKey("devices_max_visible", &val, theme ))
+	{
 		gui.maxdevices = MIN( val, gDeviceCount );
 	}
 
-	if(getIntForKey("devices_iconspacing", &val, theme )) {
+	if(getIntForKey("devices_iconspacing", &val, theme ))
+	{
 		gui.devicelist.iconspacing = val;
 	}
 
 	// check layout for horizontal or vertical
 	gui.layout = HorizontalLayout;
-	if(getValueForKey( "devices_layout", &string, &len, theme)) {
-		if (!strcmp (string, "vertical")) {
+	if(getValueForKey( "devices_layout", &string, &len, theme))
+	{
+		if (!strcmp (string, "vertical"))
+		{
 			gui.layout = VerticalLayout;
 		}
 	}
@@ -756,7 +783,7 @@
 		gui.countdown.pos.y = pixel;
 	}
 
-    /*
+	/*
 	 * Parse devicelist parameters
 	 */
 	setupDeviceList(theme);
@@ -907,7 +934,11 @@
 	return 1;
 	}
 #else
+
+//		DBG("Unable to load %s theme plist.\n",theme_name);
+
 		return 1;
+
 #endif
 	}
 	// parse display size parameters
@@ -931,23 +962,32 @@
 	gui.screen.height = screen_params[1];
 
 	// load graphics otherwise fail and return
-	if (loadGraphics() == 0) {
+	if (loadGraphics() == 0)
+	{
 		loadThemeValues(&bootInfo->themeConfig);
 		colorFont(&font_small, gui.screen.font_small_color);
 		colorFont(&font_console, gui.screen.font_console_color);
 
 		// create the screen & window buffers
-		if (createBackBuffer(&gui.screen) == 0) {
-			if (createWindowBuffer(&gui.screen) == 0) {
-				if (createWindowBuffer(&gui.devicelist) == 0) {
-					if (createWindowBuffer(&gui.bootprompt) == 0) {
-						if (createWindowBuffer(&gui.infobox) == 0) {
-							if (createWindowBuffer(&gui.menu) == 0) {
+		if (createBackBuffer(&gui.screen) == 0)
+		{
+			if (createWindowBuffer(&gui.screen) == 0)
+			{
+				if (createWindowBuffer(&gui.devicelist) == 0)
+				{
+					if (createWindowBuffer(&gui.bootprompt) == 0)
+					{
+						if (createWindowBuffer(&gui.infobox) == 0)
+						{
+							if (createWindowBuffer(&gui.menu) == 0)
+							{
 								gui.logo.draw = true;
 								drawBackground();
 								// lets copy the screen into the back buffer
 								memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );
+
 								setVideoMode( GRAPHICS_MODE, 0 );
+
 								gui.initialised = true;
 								return 0;
 							}
@@ -958,15 +998,17 @@
 		}
 	}
 
-    // not available memory, freeing resources
-    freeWindowBuffer(&gui.menu);
-    freeWindowBuffer(&gui.infobox);
-    freeWindowBuffer(&gui.bootprompt);
-    freeWindowBuffer(&gui.devicelist);
-    freeWindowBuffer(&gui.screen);
-    freeBackBuffer(&gui.screen);
-    unloadGraphics();
+	DBG("Loading error occurred, reseting...\n",theme_name);
 
+	// not available memory, freeing resources
+	freeWindowBuffer(&gui.menu);
+	freeWindowBuffer(&gui.infobox);
+	freeWindowBuffer(&gui.bootprompt);
+	freeWindowBuffer(&gui.devicelist);
+	freeWindowBuffer(&gui.screen);
+	freeBackBuffer(&gui.screen);
+	unloadGraphics();
+
 	return 1;
 }
 
@@ -1130,7 +1172,8 @@
 	}
 	
 	// draw visible device icons
-	for (i = 0; i < gui.maxdevices; i++) {
+	for (i = 0; i < gui.maxdevices; i++)
+	{
 		BVRef param = menuItems[start + i].param;
 
 		bool isSelected = ((start + i) == selection) ? true : false;
@@ -1172,10 +1215,12 @@
 		
 		drawDeviceIcon( param, gui.devicelist.pixmap, p, isSelected);
 		
-		if (gui.layout == HorizontalLayout) {
+		if (gui.layout == HorizontalLayout)
+		{
 			p.x += images[iSelection].image->width + gui.devicelist.iconspacing; 
 		}
-		if (gui.layout == VerticalLayout) {
+		if (gui.layout == VerticalLayout)
+		{
 			p.y += ( images[iSelection].image->height + font_console.chars[0]->height + gui.devicelist.iconspacing ); 
 		}
 	}
@@ -1203,7 +1248,8 @@
 	//prompt_pos=0;
 
 	
-	if( gui.bootprompt.draw == true ) {
+	if(gui.bootprompt.draw == true )
+	{
 		gui.bootprompt.draw = false;
 		gui.redraw = true;
 		// this causes extra frames to be drawn
@@ -1245,17 +1291,25 @@
 static inline
 void vramwrite (void *data, int width, int height)
 {
-	if (VIDEO (depth) == 32 && VIDEO (rowBytes) == gui.backbuffer->width * 4) {
+	if (VIDEO (depth) == 32 && VIDEO (rowBytes) == gui.backbuffer->width * 4)
+	{
 		memcpy((uint8_t *)vram, gui.backbuffer->pixels, VIDEO (rowBytes)*VIDEO (height));
-	} else {
-		uint32_t r, g, b;
+	}
+	else
+	{
+		uint32_t r;
+		uint32_t g;
+		uint32_t b;
 		int i, j;
-		for (i = 0; i < VIDEO (height); i++) {
-			for (j = 0; j < VIDEO (width); j++) {
+		for (i = 0; i < VIDEO (height); i++)
+		{
+			for (j = 0; j < VIDEO (width); j++)
+			{
 				b = ((uint8_t *) data)[4*i*width + 4*j];
 				g = ((uint8_t *) data)[4*i*width + 4*j + 1];
 				r = ((uint8_t *) data)[4*i*width + 4*j + 2];
-				switch (VIDEO (depth)) {
+				switch (VIDEO (depth))
+				{
 					case 32:
 						*(uint32_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*4) = (b&0xff) | ((g&0xff)<<8) | ((r&0xff)<<16);
 						break;
@@ -1270,6 +1324,8 @@
 					case 15:
 						*(uint16_t *)(((uint8_t *)vram)+i*VIDEO (rowBytes) + j*2) = ((b&0xf8)>>3) | ((g&0xf8)<<2) | ((r&0xf8)<<7);
 						break;	
+					default:
+						break;
 				}
 			}
 		}
@@ -1280,24 +1336,30 @@
 
 void updateVRAM()
 {
-	if (gui.redraw) {
-		if (gui.devicelist.draw) {
+	if (gui.redraw)
+	{
+		if (gui.devicelist.draw)
+		{
 			blend( gui.devicelist.pixmap, gui.backbuffer, gui.devicelist.pos );
 		}
-		if (gui.bootprompt.draw) {
+		if (gui.bootprompt.draw)
+		{
 			blend( gui.bootprompt.pixmap, gui.backbuffer, gui.bootprompt.pos );
 		}
-		if (gui.menu.draw) {
-			blend( gui.menu.pixmap, gui.backbuffer, gui.menu.pos );
+		if (gui.menu.draw)
+		{
+		blend( gui.menu.pixmap, gui.backbuffer, gui.menu.pos );
 		}
-		if (gui.infobox.draw) {
+		if (gui.infobox.draw)
+		{
 			blend( gui.infobox.pixmap, gui.backbuffer, gui.infobox.pos );
 		}
 	}
 
 	vramwrite ( gui.backbuffer->pixels, gui.backbuffer->width, gui.backbuffer->height );
 
-	if (gui.redraw) {
+	if (gui.redraw)
+	{
 		memcpy( gui.backbuffer->pixels, gui.screen.pixmap->pixels, gui.backbuffer->width * gui.backbuffer->height * 4 );
 		gui.redraw = false;
 	}
@@ -1316,8 +1378,10 @@
 static int
 sputc(int c, struct putc_info * pi) //Azi: same as above
 {
-	if (pi->last_str) {
-		if (pi->str == pi->last_str) {
+	if (pi->last_str)
+	{
+		if (pi->str == pi->last_str)
+		{
 			*(pi->str) = '\0';
 			return 0;
 		}
@@ -1333,10 +1397,11 @@
 	char *formattedtext;
 
 	va_list ap;
-	
+
 	struct putc_info pi;
 
-	if ((formattedtext = malloc(1024)) != NULL) {
+	if ((formattedtext = malloc(1024)) != NULL)
+	{
 		// format the text
 		va_start(ap, fmt);
 		pi.str = formattedtext;
@@ -1360,42 +1425,49 @@
 
 		font_t *font = &font_console;
 
-		for( i=0; i< strlen(formattedtext); i++ ) {
+		for( i=0; i< strlen(formattedtext); i++ )
+		{
 			character = formattedtext[i];
 			
 			character -= 32;
 
 			// newline ?
-			if( formattedtext[i] == '\n' ) {
+			if( formattedtext[i] == '\n' )
+			{
 				cursor.x = window->hborder;
 				cursor.y += font->height;
 
-				if ( cursor.y > bounds.y ) {
+				if ( cursor.y > bounds.y )
+				{
 					cursor.y = origin.y;
 				}
 				continue;
 			}
 
 			// tab ?
-			if( formattedtext[i] == '\t' ) {
+			if( formattedtext[i] == '\t' )
+			{
 				cursor.x += ( font->chars[0]->width * 5 );
 			}
 
 			// draw the character
-			if( font->chars[character]) {
+			if( font->chars[character])
+			{
 				blend(font->chars[character], window->pixmap, cursor);
 			}
 
 			cursor.x += font->chars[character]->width;
 
 			// check x pos and do newline
-			if ( cursor.x > bounds.x ) {
+			if ( cursor.x > bounds.x )
+			{
 				cursor.x = origin.x;
 				cursor.y += font->height;
 			}
 			
 			// check y pos and reset to origin.y
-			if ( cursor.y > bounds.y ) {
+			if ( cursor.y > bounds.y )
+			{
 				cursor.y = origin.y;
 			}
 		}
@@ -1417,12 +1489,13 @@
 	char *formattedtext;
 	
 	va_list ap;
-	
+
 	//window = &gui.debug;
 	
 	struct putc_info pi;
-	
-	if ((formattedtext = malloc(1024)) != NULL) {
+
+	if ((formattedtext = malloc(1024)) != NULL)
+	{
 		// format the text
 		va_start(ap, fmt);
 		pi.str = formattedtext;
@@ -1432,10 +1505,10 @@
 		va_end(ap);
 		
 		position_t	origin, cursor, bounds;
-		
+
 		int i;
 		int character;
-		
+
 		origin.x = MAX( gui.debug.cursor.x, window->hborder );
 		origin.y = MAX( gui.debug.cursor.y, window->vborder );
 		
@@ -1446,40 +1519,47 @@
 		
 		font_t *font = &font_console;
 		
-		for( i=0; i< strlen(formattedtext); i++ ) {
+		for( i=0; i< strlen(formattedtext); i++ )
+		{
 			character = formattedtext[i];
 			
 			character -= 32;
 			
 			// newline ?
-			if( formattedtext[i] == '\n' ) {
+			if( formattedtext[i] == '\n' )
+			{
 				cursor.x = window->hborder;
 				cursor.y += font->height;
 				
-				if ( cursor.y > bounds.y ) {
+				if ( cursor.y > bounds.y )
+				{
 					cursor.y = origin.y;
 				}
 				continue;
 			}
 			
 			// tab ?
-			if( formattedtext[i] == '\t' ) {
+			if( formattedtext[i] == '\t' )
+			{
 				cursor.x += ( font->chars[0]->width * 5 );
 			}
 			// draw the character
-			if( font->chars[character]) {
+			if( font->chars[character])
+			{
 				blend(font->chars[character], gui.backbuffer, cursor);
 			}
 			cursor.x += font->chars[character]->width;
 			
 			// check x pos and do newline
-			if ( cursor.x > bounds.x ) {
+			if ( cursor.x > bounds.x )
+			{
 				cursor.x = origin.x;
 				cursor.y += font->height;
 			}
 			
 			// check y pos and reset to origin.y
-			if ( cursor.y > bounds.y ) {
+			if ( cursor.y > bounds.y )
+			{
 				cursor.y = origin.y;
 			}
 		}
@@ -1509,7 +1589,8 @@
 	position_t	origin, cursor, bounds;
 	font_t *font = &font_console;
 	
-	if ((formattedtext = malloc(1024)) != NULL) {
+	if ((formattedtext = malloc(1024)) != NULL)
+	{
 		// format the text
 		pi.str = formattedtext;
 		pi.last_str = 0;
@@ -1522,15 +1603,18 @@
 		bounds.y = ( window->height - ( window->vborder * 2 ) );
 		cursor = origin;
 
-		for( i=0; i< strlen(formattedtext); i++ ) {
+		for( i=0; i< strlen(formattedtext) ; i++ )
+		{
 			character = formattedtext[i];
 			character -= 32;
 			
 			// newline ?
-			if( formattedtext[i] == '\n' ) {
+			if( formattedtext[i] == '\n' )
+			{
 				cursor.x = window->hborder;
 				cursor.y += font->height;
-				if ( cursor.y > bounds.y ) {
+				if ( cursor.y > bounds.y )
+				{
 					gui.redraw = true;
 					updateVRAM();
 					cursor.y = window->vborder;
@@ -1540,26 +1624,30 @@
 			}
 
 			// tab ?
-			if( formattedtext[i] == '\t' ) {
+			if( formattedtext[i] == '\t' )
+			{
 				cursor.x = ( cursor.x / ( font->chars[0]->width * 8 ) + 1 ) * ( font->chars[0]->width * 8 );
 				continue;
 			}
 			cursor.x += font->chars[character]->width;
 			
 			// check x pos and do newline
-			if ( cursor.x > bounds.x ) {
+			if ( cursor.x > bounds.x )
+			{
 				cursor.x = origin.x;
 				cursor.y += font->height;
 			}
 
 			// check y pos and reset to origin.y
-			if ( cursor.y > ( bounds.y + font->chars[0]->height) ) {
+			if ( cursor.y > ( bounds.y + font->chars[0]->height) )
+			{
 				gui.redraw = true;
 				updateVRAM();
 				cursor.y = window->vborder;
 			}
 			// draw the character
-			if( font->chars[character]) {
+			if( font->chars[character])
+			{
 				blend(font->chars[character], gui.backbuffer, cursor);
 			}
 		}
@@ -1574,9 +1662,11 @@
 
 // ====================================================================
 
-pixmap_t* charToPixmap(unsigned char ch, font_t *font) {
+pixmap_t *charToPixmap(unsigned char ch, font_t *font)
+{
 	unsigned int cha = (unsigned int)ch - 32;
-	if (cha >= font->count) {
+	if (cha >= font->count)
+	{
 		// return ? if the font for the char doesn't exists
 		cha = '?' - 32;
 	}
@@ -1585,12 +1675,16 @@
 
 // ====================================================================
 
-position_t drawChar(unsigned char ch, font_t *font, pixmap_t *blendInto, position_t p) {
+position_t drawChar(unsigned char ch, font_t *font, pixmap_t *blendInto, position_t p)
+{
 	pixmap_t* pm = charToPixmap(ch, font);
-	if (pm && ((p.x + pm->width) < blendInto->width)) {
+	if (pm && ((p.x + pm->width) < blendInto->width))
+	{
 		blend(pm, blendInto, p);
 		return pos(p.x + pm->width, p.y);
-	} else {
+	}
+	else
+	{
 		return p;
 	}
 }
@@ -1602,16 +1696,19 @@
 	int i=0;
 	position_t current_pos = pos(p.x, p.y);
 	
-	for (i=0; i < strlen(ch); i++) {
+	for (i=0; i < strlen(ch); i++)
+	{
 		// newline ?
-		if ( ch[i] == '\n' ) {
+		if ( ch[i] == '\n' )
+		{
 			current_pos.x = p.x;
 			current_pos.y += font->height;
 			continue;
 		}
 		
 		// tab ?
-		if ( ch[i] == '\t' ) {
+		if ( ch[i] == '\t' )
+		{
 			current_pos.x += TAB_PIXELS_WIDTH;
 			continue;
 		}
@@ -1630,19 +1727,27 @@
 	int height = font->height;
 
 	// calculate the width in pixels
-	for (i=0; i < strlen(text); i++) {
-		if (text[i] == '\n') {
+	for (i=0; i < strlen(text); i++)
+	{
+		if (text[i] == '\n')
+		{
 			width = 0;
 			height += font->height;
-		} else if (text[i] == '\t') {
+		}
+		else if (text[i] == '\t')
+		{
 			width += TAB_PIXELS_WIDTH;
-		} else {
+		}
+		else
+		{
 			pixmap_t* pm = charToPixmap(text[i], font);
-			if (pm)	{
+			if (pm)
+			{
 				width += pm->width;
 			}
 		}
-		if (width > max_width) {
+		if (width > max_width)
+		{
 			max_width = width;
 		}
 	}
@@ -1658,9 +1763,12 @@
 int destroyFont(font_t *font)
 {
 	int i;
-	for (i = 0; i < CHARACTERS_COUNT; i++) {
-		if (font->chars[i]) {
-			if (font->chars[i]->pixels) {
+	for (i = 0; i < CHARACTERS_COUNT; i++)
+	{
+		if (font->chars[i])
+		{
+			if (font->chars[i]->pixels)
+			{
 				free (font->chars[i]->pixels);
 			}
 			free (font->chars[i]);
@@ -1682,44 +1790,53 @@
 	
 	font->height = data->image->height;
 
-	for( x = 0; x < data->image->width && count < CHARACTERS_COUNT; x++) {
+	for( x = 0; x < data->image->width && count < CHARACTERS_COUNT; x++)
+	{
 		start = end;
 
 		// if the pixel is red we've reached the end of the char
-		if( pixel( data->image, x, 0 ).value == 0xFFFF0000) {
+		if( pixel( data->image, x, 0 ).value == 0xFFFF0000)
+		{
 			end = x + 1;
 
-			if( (font->chars[count] = malloc(sizeof(pixmap_t)) ) ) {
+			if( (font->chars[count] = malloc(sizeof(pixmap_t)) ) )
+			{
 				font->chars[count]->width = ( end - start) - 1;
 				font->chars[count]->height = font->height;
-			
-				if ( ( font->chars[count]->pixels = malloc( font->chars[count]->width * data->image->height * 4) ) ) {
+
+				if ( ( font->chars[count]->pixels = malloc( font->chars[count]->width * data->image->height * 4) ) )
+				{
 					space += ( font->chars[count]->width * data->image->height * 4 );
 					// we skip the first line because there are just the red pixels for the char width
-					for( y = 1; y< (font->height); y++) {
-						for( x2 = start, x3 = 0; x2 < end; x2++, x3++) {
+					for( y = 1; y< (font->height); y++)
+					{
+						for( x2 = start, x3 = 0; x2 < end; x2++, x3++)
+						{
 							pixel( font->chars[count], x3, y ) = pixel( data->image, x2, y );
 						}	
 					}
-					
+
 					// check if font is monospaced
-					if( ( count > 0 ) && ( font->width != font->chars[count]->width ) ) {
+					if( ( count > 0 ) && ( font->width != font->chars[count]->width ) )
+					{
 						monospaced = true;
 					}
 
 					font->width = font->chars[count]->width;
-					
+
 					count++;
 				}
 			}
 		}
 	}
 
-	for (x = count; x < CHARACTERS_COUNT; x++) {
+	for (x = count; x < CHARACTERS_COUNT; x++)
+	{
 		font->chars[x] = NULL;
 	}
 
-	if(monospaced) {
+	if(monospaced)
+	{
 		font->width = 0;
 	}
 
@@ -1732,7 +1849,8 @@
 
 void colorFont(font_t *font, uint32_t color)
 {
-	if( !color ) {
+	if( !color )
+	{
 		return;
 	}
 
@@ -1740,13 +1858,17 @@
 	int count = 0;
 	pixel_t *buff;
 	
-	while( font->chars[count++] ) {
+	while( font->chars[count++] )
+	{
 		width = font->chars[count-1]->width;
 		height = font->chars[count-1]->height;
-		for( y = 0; y < height; y++ ) {
-			for( x = 0; x < width; x++ ) {
+		for( y = 0; y < height; y++ )
+		{
+			for( x = 0; x < width; x++ )
+			{
 				buff = &(pixel( font->chars[count-1], x, y ));
-				if( buff->ch.a ) {
+				if( buff->ch.a )
+				{
 					buff->ch.r = (color & 0xFFFF0000) >> 16;
 					buff->ch.g = (color & 0xFF00FF00) >> 8;
 					buff->ch.b = (color & 0xFF0000FF);
@@ -1781,10 +1903,13 @@
 	
 	uint8_t alpha=0;
 	
-	for( y=0; y<10; y++) {
-		for( x=0; x<10; x++) {
+	for( y=0; y<10; y++)
+	{
+		for( x=0; x<10; x++)
+		{
 			// skip if the pixel should be visible
-			if(roundedCorner[y][x] != 0xFF)	{ 
+			if(roundedCorner[y][x] != 0xFF)
+			{ 
 				alpha = ( roundedCorner[y][x] ? (uint8_t) (roundedCorner[y][x] * pixel(p, x, y).ch.a) / 255 : 0 );
 				// Upper left corner
 				pixel(p, x, y).ch.a = alpha;
@@ -1845,23 +1970,32 @@
 	visiblelines = ( ( gui.infobox.height - ( gui.infobox.vborder * 2 ) ) / font_console.height ) - 1;
 	
 	// lets display the text and allow scroll thru using up down / arrows
-	while(1) {
+	while(1)
+	{
 		// move to current line in text
-		for( offset = 0, i = 0; offset < strlen(text); offset++ ) {
-			if( currentline == i) {
+		for( offset = 0, i = 0; offset < strlen(text); offset++ )
+		{
+			if( currentline == i)
+			{
 				break;
 			}
-			if( text[offset] =='\n') {
+
+			if( text[offset] =='\n')
+			{
 				i++;
 			}
 		}
 
 		// find last visible line in text and place \0
-		for( i = offset, cnt = 0; i < strlen(text); i++) {
-			if(text[i]=='\n') {
+		for( i = offset, cnt = 0; i < strlen(text); i++)
+		{
+			if(text[i]=='\n')
+			{
 				cnt++;
 			}
-			if ( cnt == visiblelines ) {
+
+			if ( cnt == visiblelines )
+			{
 				text[i]='\0';
 				break;
 			}
@@ -1885,12 +2019,14 @@
 		position_t pos_indicator =  pos( gui.infobox.width - ( images[iTextScrollPrev].image->width - ( gui.infobox.vborder / 2) ), pos_text.y );
 		
 		// draw prev indicator
-		if(offset) {
+		if(offset)
+		{
 			blend( images[iTextScrollPrev].image, gui.infobox.pixmap, centeredAt( images[iTextScrollPrev].image, pos_indicator ));
 		}
 		
 		// draw next indicator
-		if( lines > ( currentline + visiblelines ) ) {
+		if( lines > ( currentline + visiblelines ) )
+		{
 			pos_indicator.y = ( gui.infobox.height - ( ( images[iTextScrollNext].image->width + gui.infobox.vborder ) / 2 ) );
 			blend( images[iTextScrollNext].image, gui.infobox.pixmap, centeredAt( images[iTextScrollNext].image, pos_indicator ) );
 		}
@@ -1902,7 +2038,7 @@
 		updateVRAM();
 		
 		key = getchar();
-			
+
 		if( key == KEY_UP ) {
 			if( currentline > 0 ) {
 				currentline--;
@@ -1940,7 +2076,8 @@
 {
 	int y;
 	
-	if( time18() > lasttime) {
+	if( time18() > lasttime)
+	{
 		lasttime = time18();
 
 		pixmap_t *buffBar = images[iProgressBar].image;
@@ -2130,6 +2267,8 @@
 				return buff;
 			}
 			break;
+		default:
+			break;
 	}
 	return DO_NOT_BOOT;
 }
@@ -2151,7 +2290,8 @@
 
 	char dirspec[256];
 
-	if ((strlen(theme_name) + 24) > sizeof(dirspec)) {
+	if ((strlen(theme_name) + 24) > sizeof(dirspec))
+	{
 		usePngImage = false; 
 		return;
 	}
Index: trunk/i386/boot2/options.c
===================================================================
--- trunk/i386/boot2/options.c	(revision 2581)
+++ trunk/i386/boot2/options.c	(revision 2582)
@@ -194,7 +194,7 @@
 		{
 			multi--; 
 			lasttime=time18();
-		}		
+		}
   
 		if ( (ch = readKeyboardStatus()) )
 			break;
@@ -413,7 +413,7 @@
 
     gMenuStart		= 0;
     gMenuEnd	    = MIN( count, gui.maxdevices ) - 1;
-	
+
 	// If the selected item is not visible, shift the list down.
 
     if ( gMenuSelection > gMenuBottom )
@@ -451,38 +451,38 @@
 
 static int updateMenu( int key, void ** paramPtr )
 {
-    int moved = 0;
+	int moved = 0;
 
-    union {
-        struct {
-            unsigned int
-                selectionUp   : 1,
-                selectionDown : 1,
-                scrollUp      : 1,
-                scrollDown    : 1;
-        } f;
-        unsigned int w;
-    } draw = {{0}};
+	union {
+		struct {
+			unsigned int
+			selectionUp   : 1,
+			selectionDown : 1,
+			scrollUp      : 1,
+			scrollDown    : 1;
+		} f;
+		unsigned int w;
+	} draw = {{0}};
 
-    if ( gMenuItems == NULL )
+	if ( gMenuItems == NULL )
 		return 0;
 
 	if( bootArgs->Video.v_display != VGA_TEXT_MODE )
 	{
 		int res;
-		
+
 		// set navigation keys for horizontal layout as defaults
 		int previous	= 0x4B00;		// left arrow
 		int subsequent	= 0x4D00;		// right arrow
-		int menu		= 0x5000;		// down arrow
-		
+		int menu	= 0x5000;		// down arrow
+
 		if ( gui.layout == VerticalLayout )
 		{
 			// set navigation keys for vertical layout
 			previous	= 0x4800;		// up arrow
 			subsequent	= 0x5000;		// down arrow
 			menu		= 0x4B00;		// right arrow
-		} 
+		}
 
 		if ( key == previous )
 		{
@@ -490,7 +490,7 @@
 				draw.f.selectionUp = 1;
 			else if ( gMenuTop > 0 )
 				draw.f.scrollDown = 1;
-			
+
 		}
 		
 		else if ( key ==  subsequent )
@@ -518,7 +518,7 @@
 			else
 			{
 				shouldboot = ( res != DO_NOT_BOOT );
-				
+
 				if ( shouldboot )
 					gui.menu.draw = false;
 
@@ -528,31 +528,33 @@
 						gVerboseMode = false;
 						gBootMode = kBootModeNormal;
 						break;
-						
+
 					case BOOT_VERBOSE:
 						gVerboseMode = true;
 						gBootMode = kBootModeNormal;
 						addBootArg(kVerboseModeFlag);
 						break;
-						
+
 					case BOOT_IGNORECACHE:
 						gVerboseMode = false;
 						gBootMode = kBootModeNormal;
 						addBootArg(kIgnoreCachesFlag);
 						break;
-						
+
 					case BOOT_SINGLEUSER:
 						gVerboseMode = true;
 						gBootMode = kBootModeNormal;
 						addBootArg(kSingleUserModeFlag);
 						break;
 				}
-				
+
 			}
-			
-		}	
-			
-	} else {
+
+		}
+
+	}
+	else
+	{
 		switch ( key )
 		{
         	case 0x4800:  // Up Arrow
@@ -571,31 +573,30 @@
 		}
 	}
 
-    if ( draw.w )
-    {
-        if ( draw.f.scrollUp )
-        {
-            scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, 1);
-            gMenuTop++; gMenuBottom++;
+	if ( draw.w )
+	{
+		if ( draw.f.scrollUp )
+		{
+			scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, 1);
+			gMenuTop++; gMenuBottom++;
 			gMenuStart++; gMenuEnd++;
-            draw.f.selectionDown = 1;
-        }
+			draw.f.selectionDown = 1;
+		}
 
-        if ( draw.f.scrollDown )
-        {
-            scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, -1);
-            gMenuTop--; gMenuBottom--;
-            gMenuStart--; gMenuEnd--;
-            draw.f.selectionUp = 1;
-        }
+		if ( draw.f.scrollDown )
+		{
+			scollPage(0, gMenuRow, 40, gMenuRow + gMenuHeight - 1, 0x07, 1, -1);
+			gMenuTop--; gMenuBottom--;
+			gMenuStart--; gMenuEnd--;
+			draw.f.selectionUp = 1;
+		}
 
-        if ( draw.f.selectionUp || draw.f.selectionDown )
-        {
-
+		if ( draw.f.selectionUp || draw.f.selectionDown )
+		{
 			CursorState cursorState;
 
 			// Set cursor at current position, and clear inverse video.
-	
+
 			if( bootArgs->Video.v_display == VGA_TEXT_MODE )
 			{
 				changeCursor( 0, gMenuRow + gMenuSelection - gMenuTop, kCursorTypeHidden, &cursorState );
@@ -610,32 +611,35 @@
 					gMenuStart--;
 					gMenuEnd--;
 				}
-				
-			} else {
-			gMenuSelection++;
-			if(( gMenuSelection - ( gui.maxdevices - 1) - gMenuStart) > 0 )
+
+			}
+			else
 			{
-				gMenuStart++;
-				gMenuEnd++;
+				gMenuSelection++;
+				if(( gMenuSelection - ( gui.maxdevices - 1) - gMenuStart) > 0 )
+				{
+					gMenuStart++;
+					gMenuEnd++;
+				}
 			}
-	    }
 
-		if( bootArgs->Video.v_display == VGA_TEXT_MODE )
-	    {
-			moveCursor( 0, gMenuRow + gMenuSelection - gMenuTop );
-			printMenuItem( &gMenuItems[gMenuSelection], 1 );
-			restoreCursor( &cursorState );
+			if( bootArgs->Video.v_display == VGA_TEXT_MODE )
+			{
+				moveCursor( 0, gMenuRow + gMenuSelection - gMenuTop );
+				printMenuItem( &gMenuItems[gMenuSelection], 1 );
+				restoreCursor( &cursorState );
 
-	    } else
+			}
+			else
+			{
+				drawDeviceList (gMenuStart, gMenuEnd, gMenuSelection);
+			}
+		}
 
-			drawDeviceList (gMenuStart, gMenuEnd, gMenuSelection);
-
+		*paramPtr = gMenuItems[gMenuSelection].param;
+		moved = 1;
 	}
 
-        *paramPtr = gMenuItems[gMenuSelection].param;        
-        moved = 1;
-    }
-
 	return moved;
 }
 
@@ -750,7 +754,8 @@
 
 void lspci(void)
 {
-	if (bootArgs->Video.v_display == VGA_TEXT_MODE) { 
+	if (bootArgs->Video.v_display == VGA_TEXT_MODE)
+	{
 		setActiveDisplayPage(1);
 		clearScreenRows(0, 24);
 		setCursorPosition(0, 0, 1);
@@ -760,7 +765,8 @@
 
 	pause();
 
-	if (bootArgs->Video.v_display == VGA_TEXT_MODE) {
+	if (bootArgs->Video.v_display == VGA_TEXT_MODE)
+	{
 		setActiveDisplayPage(0);
 	}
 }
@@ -1156,6 +1162,7 @@
 		clearScreenRows(kMenuTopRow, kScreenLastRow);
 		changeCursor(0, kMenuTopRow, kCursorTypeUnderline, 0);
 	}
+
 	shouldboot = false;
 	gui.menu.draw = false;
 	if (menuItems) {
@@ -1200,6 +1207,7 @@
 	*argP += cnt;
 	*argP[0] = ' ';
 	(*argP)++;
+
 	*cntRemainingP -= len;
 
 	return true;
@@ -1243,15 +1251,15 @@
 
 int processBootOptions()
 {
-	const char *cp  = gBootArgs;
-	const char *val = 0;
-	const char *kernel;
-	int         cnt;
-	int         userCnt;
-	int         cntRemaining;
-	char       *argP;
-	char       *configKernelFlags;
-	char       *valueBuffer;
+	const char	*cp  = gBootArgs;
+	const char	*val = 0;
+	const char	*kernel;
+	int		cnt;
+	int		userCnt;
+	int		cntRemaining;
+	char		*argP;
+	char		*configKernelFlags;
+	char		*valueBuffer;
 
 	valueBuffer = malloc(VALUE_SIZE);
     
Index: trunk/i386/boot2/graphic_utils.c
===================================================================
--- trunk/i386/boot2/graphic_utils.c	(revision 2581)
+++ trunk/i386/boot2/graphic_utils.c	(revision 2582)
@@ -78,7 +78,8 @@
 	
 	uint32_t x;
 	register uint8_t tempB;
-	for (x = 0; x < (p->height) * (p->width) ; x++) {
+	for (x = 0; x < (p->height) * (p->width) ; x++)
+	{
 		tempB = (p->pixels[x]).ch.b;
 		(p->pixels[x]).ch.b = (p->pixels[x]).ch.r;
 		(p->pixels[x]).ch.r = tempB;
Index: trunk/i386/modules/Keylayout/Keylayout.c
===================================================================
--- trunk/i386/modules/Keylayout/Keylayout.c	(revision 2581)
+++ trunk/i386/modules/Keylayout/Keylayout.c	(revision 2582)
@@ -13,9 +13,20 @@
 #include "Keylayout.h"
 #include "bootstruct.h"
 
+#ifndef DEBUG_KLAYOUT
+#define DEBUG_KLAYOUT 0
+#endif
+
+#if DEBUG_KLAYOUT
+#define DBG(x...)	printf(x)
+#else
+#define DBG(x...)
+#endif
+
 #define kKeyboardLayout "KeyboardLayout"
 
 struct keyboard_layout *current_layout = NULL;
+int getchar_replacement();
 
 int getchar_replacement() {
 	int code   = bgetc();
@@ -50,46 +61,57 @@
 	return (code);
 }
 
-static uint32_t load_keyboard_layout_file(const char *filename) {
+static uint32_t load_keyboard_layout_file(const char *filename)
+{
 	int      fd;
 	char     magic[KEYBOARD_LAYOUTS_MAGIC_SIZE];
 	uint32_t version;
 	
-	if ((fd = open_bvdev("bt(0,0)", filename, 0)) < 0) {
+	if ((fd = open_bvdev("bt(0,0)", filename, 0)) < 0)
+	{
 		goto fail; // fail
 	}
 	
-	if (read(fd, magic, sizeof(magic)) != sizeof(magic)) {
+	if (read(fd, magic, sizeof(magic)) != sizeof(magic))
+	{
 		printf("Can't find magic in keyboard layout file: %s\n", filename);
 		goto fail;
 	}
 
-	if (memcmp (magic, KEYBOARD_LAYOUTS_MAGIC, KEYBOARD_LAYOUTS_MAGIC_SIZE) != 0) {
+	if (memcmp (magic, KEYBOARD_LAYOUTS_MAGIC, KEYBOARD_LAYOUTS_MAGIC_SIZE) != 0)
+	{
 		printf("Invalid magic code in keyboard layout file: %s\n", filename);
 		goto fail;
-    }
+	}
 
-	if (read(fd, (char*) &version, sizeof(version)) != sizeof(version)) {
+	if (read(fd, (char*) &version, sizeof(version)) != sizeof(version))
+	{
 		printf("Can't get version of keyboard layout file: %s\n", filename);
 		goto fail;
 	}
 	
-	if (version != KEYBOARD_LAYOUTS_VERSION) {
+	if (version != KEYBOARD_LAYOUTS_VERSION)
+	{
 		verbose("Bad version for keyboard layout file %s expected v%d found v%d\n",
-			   filename, KEYBOARD_LAYOUTS_VERSION, version);
+			filename, KEYBOARD_LAYOUTS_VERSION, version);
 		goto fail;
 	}
 	
 	if (current_layout)
+	{
 		free(current_layout);
-		
+	}
+
 	current_layout = malloc(sizeof(*current_layout));
 	if (!current_layout)
+	{
 		goto fail;
+	}
 
 	b_lseek(fd, KEYBOARD_LAYOUTS_MAP_OFFSET, 0);
 	
-	if (read(fd, (char*) current_layout, sizeof(*current_layout)) != sizeof(*current_layout)) {
+	if (read(fd, (char*) current_layout, sizeof(*current_layout)) != sizeof(*current_layout))
+	{
 		printf("Wrong keyboard layout file %s size\n", filename);
 		goto fail;
 	}
@@ -97,10 +119,11 @@
 	close(fd);
 	
 	return 1;
-		
-  fail:
+
+fail:
     
-	if (current_layout) {
+	if (current_layout)
+	{
 		free(current_layout);
 		current_layout = NULL;
 	}
@@ -113,17 +136,21 @@
 	const char	*val;
 	int			len;
 
-	if (getValueForKey("KeyLayout", &val, &len, &bootInfo->chameleonConfig)) {
+	if (getValueForKey("KeyLayout", &val, &len, &bootInfo->chameleonConfig))
+	{
 		sprintf(layoutPath, "/Extra/Keymaps/%s", val);
 		// Add the extension if needed
 		if (len <= 4 || strcmp(val+len-4,".lyt") != 0)
 			strncat(layoutPath, ".lyt", sizeof(layoutPath) - strlen(layoutPath) - 1);
 
-		if (!load_keyboard_layout_file(layoutPath)) {
-			printf("Can't load %s keyboard layout file. Keylayout will not be used !\n",
+		if (!load_keyboard_layout_file(layoutPath))
+		{
+			DBG("Can't load %s keyboard layout file. Keylayout will not be used !\n",
 				   layoutPath);
 			sleep(2);
-		} else if (!replace_function("_getchar", &getchar_replacement)) {
+		}
+		else if (!replace_function("_getchar", &getchar_replacement))
+		{
 			printf("Can't replace function getchar: Keylayout module can't be used !\n");
 			sleep(2);
 		}
Index: trunk/i386/modules/Makefile
===================================================================
--- trunk/i386/modules/Makefile	(revision 2581)
+++ trunk/i386/modules/Makefile	(revision 2582)
@@ -57,6 +57,10 @@
 #SUBDIRS += HDAEnabler
 #endif
 
+#ifdef CONFIG_GRAPHICSENABLER_MODULE
+#SUBDIRS += GraphicsEnabler
+#endif
+
 CFLAGS= -O3 $(MORECPP) -arch i386 -g -static
 DEFINES=
 CONFIG = hd
Index: trunk/i386/libsa/libsa.h
===================================================================
--- trunk/i386/libsa/libsa.h	(revision 2581)
+++ trunk/i386/libsa/libsa.h	(revision 2582)
@@ -2,7 +2,7 @@
  * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_LICENSE_HEADER_START@
- * 
+ *
  * Portions Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights
  * Reserved.  This file contains Original Code and/or Modifications of
  * Original Code as defined in and that are subject to the Apple Public
@@ -10,7 +10,7 @@
  * except in compliance with the License.  Please obtain a copy of the
  * License at http://www.apple.com/publicsource 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,
@@ -18,7 +18,7 @@
  * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT.  Please see the
  * License for the specific language governing rights and limitations
  * under the License.
- * 
+ *
  * @APPLE_LICENSE_HEADER_END@
  */
 
@@ -88,70 +88,70 @@
 #error bzero is defined.
 #endif
 
-extern void * memset(void * dst, int c, size_t n);
-extern void * memcpy(void * dst, const void * src, size_t len);
-extern int    memcmp(const void * p1, const void * p2, size_t len);
-extern int    strcmp(const char * s1, const char * s2);
-extern int    strncmp(const char * s1, const char * s2, size_t n);
-extern char * strcpy(char * s1, const char * s2);
-extern char * stpcpy(char * s1, const char * s2);
-extern char * strncpy(char * s1, const char * s2, size_t n);
-extern char * strpcpy(char * s1, const char * s2, size_t n);
-extern size_t strlcpy(char * s1, const char * s2, size_t n);
-extern char * strstr(const char *in, const char *str);
-extern int    atoi(const char * str);
-extern int    ptol(const char * str);
-extern size_t    strlen(const char * str);
-extern char * strcat(char * s1, const char * s2);
-extern char * strncat(char * s1, const char * s2, size_t n);
-extern char * strdup(const char *s1);
+extern void	*memset(void * dst, int c, size_t n);
+extern void	*memcpy(void * dst, const void * src, size_t len);
+extern int	memcmp(const void * p1, const void * p2, size_t len);
+extern int	strcmp(const char * s1, const char * s2);
+extern int	strncmp(const char * s1, const char * s2, size_t n);
+extern char	*strcpy(char * s1, const char * s2);
+extern char	*stpcpy(char * s1, const char * s2);
+extern char	*strncpy(char * s1, const char * s2, size_t n);
+extern char	*strpcpy(char * s1, const char * s2, size_t n);
+extern size_t	strlcpy(char * s1, const char * s2, size_t n);
+extern char	*strstr(const char *in, const char *str);
+extern int	atoi(const char * str);
+extern int	ptol(const char * str);
+extern size_t	strlen(const char * str);
+extern char	*strcat(char * s1, const char * s2);
+extern char	*strncat(char * s1, const char * s2, size_t n);
+extern char	*strdup(const char *s1);
 
 #if STRNCASECMP
 extern int strncasecmp(const char *s1, const char *s2, size_t n);
 #endif
 
-extern char * strchr(const char *str, int c);
-extern char * strbreak(const char *str, char **next, long *len);
+extern char *strchr(const char *str, int c);
+extern char *strbreak(const char *str, char **next, long *len);
 
 extern uint8_t checksum8( void * start, unsigned int length );
 
 /*
  * error.c
  */
-extern int    errno;
-extern char * strerror(int errnum);
+extern int	errno;
+extern char	*strerror(int errnum);
 
 /*
  * strtol.c
  */
-extern long strtol(const char * nptr, char ** endptr, int base);
-extern unsigned long strtoul(const char * nptr, char ** endptr, int base);
-extern unsigned long long strtouq(const char *nptr, char ** endptr, int base);
+extern long strtol(const char *nptr, char **endptr, int base);
+extern unsigned long strtoul(const char *nptr, char **endptr, int base);
+extern unsigned long long strtouq(const char *nptr, char **endptr, int base);
 
 /*
  * prf.c
  */
-extern void prf(const char * fmt, va_list ap, int (*putfn_p)(), void * putfn_arg);
+extern void prf(const char *fmt, va_list ap, int (*putfn_p)(), void *putfn_arg);
 
 /*
  * printf.c
  */
-extern int sprintf(char *s, const char * format, ...);
-extern int snprintf(char *s, size_t size, const char * format, ...);
-extern int slvprintf(char * buffer, int len, const char * fmt, va_list arg);
+extern int sprintf(char *s, const char *format, ...);
+extern int snprintf(char *s, size_t size, const char *format, ...);
+extern int slvprintf(char *buffer, int len, const char *fmt, va_list arg);
 
 /*
  * zalloc.c
  */
 #define malloc(size) safe_malloc(size, __FILE__, __LINE__)
-extern void   malloc_init(char * start, int size, int nodes, void (*malloc_error)(char *, size_t, const char *, int));
-extern void * safe_malloc(size_t size,const char *file, int line);
-extern void   free(void * start);
-extern void * realloc(void * ptr, size_t size);
+extern void	malloc_init(char *start, int size, int nodes, void (*malloc_error)(char *, size_t, const char *, int));
+extern void	*safe_malloc(size_t size,const char *file, int line);
+extern void	free(void *start);
+extern void	*realloc(void *ptr, size_t size);
 
 /*
  * getsegbyname.c
  */
-extern struct segment_command * getsegbynamefromheader(struct mach_header * mhp, char * segname);
+extern struct segment_command *getsegbynamefromheader(struct mach_header *mhp, char *segname);
 
 #endif /* !__BOOT_LIBSA_H */
Index: trunk/i386/libsa/string.c
===================================================================
--- trunk/i386/libsa/string.c	(revision 2581)
+++ trunk/i386/libsa/string.c	(revision 2582)
@@ -25,25 +25,25 @@
 
 #include "libsa.h"
 
-void * memset(void * dst, int val, size_t len)
+void *memset(void * dst, int val, size_t len)
 {
-    asm volatile ( "rep; stosb"
-       : "=c" (len), "=D" (dst)
-       : "0" (len), "1" (dst), "a" (val)
-       : "memory" );
+	asm volatile ( "rep; stosb"
+		: "=c" (len), "=D" (dst)
+		: "0" (len), "1" (dst), "a" (val)
+		: "memory" );
 
-    return dst;
+	return dst;
 }
 
 #if 0
 void * memcpy(void * dst, const void * src, size_t len)
 {
-    asm volatile ( "rep; movsb"
-       : "=c" (len), "=D" (dst), "=S" (src)
-       : "0" (len), "1" (dst), "2" (src)
-       : "memory" );
+	asm volatile ( "rep; movsb"
+		: "=c" (len), "=D" (dst), "=S" (src)
+		: "0" (len), "1" (dst), "2" (src)
+		: "memory" );
 
-    return dst;
+	return dst;
 }
 
 void bcopy(const void * src, void * dst, size_t len)
@@ -53,53 +53,53 @@
 
 void bzero(void * dst, size_t len)
 {
-    memset(dst, 0, len);
+	memset(dst, 0, len);
 }
 
 #else
 void * memcpy(void * dst, const void * src, size_t len)
 {
-    asm volatile ( "cld                  \n\t"
-         "movl %%ecx, %%edx    \n\t"
-         "shrl $2, %%ecx       \n\t"
-         "rep; movsl           \n\t"
-         "movl %%edx, %%ecx    \n\t"
-         "andl $3, %%ecx       \n\t"
-         "rep; movsb           \n\t"
-       : "=D" (dst)
-       : "c" (len), "D" (dst), "S" (src)
-       : "memory", "%edx" );
+	asm volatile ( "cld                  \n\t"
+		"movl %%ecx, %%edx    \n\t"
+		"shrl $2, %%ecx       \n\t"
+		"rep; movsl           \n\t"
+		"movl %%edx, %%ecx    \n\t"
+		"andl $3, %%ecx       \n\t"
+		"rep; movsb           \n\t"
+		: "=D" (dst)
+		: "c" (len), "D" (dst), "S" (src)
+		: "memory", "%edx" );
 
-    return dst;
+	return dst;
 }
 
 void bcopy(const void * src, void * dst, size_t len)
 {
-    asm volatile ( "cld                  \n\t"
-         "movl %%ecx, %%edx    \n\t"
-         "shrl $2, %%ecx       \n\t"
-         "rep; movsl           \n\t"
-         "movl %%edx, %%ecx    \n\t"
-         "andl $3, %%ecx       \n\t"
-         "rep; movsb           \n\t"
-       :
-       : "c" (len), "D" (dst), "S" (src)
-       : "memory", "%edx" );
+	asm volatile ( "cld                  \n\t"
+		"movl %%ecx, %%edx    \n\t"
+		"shrl $2, %%ecx       \n\t"
+		"rep; movsl           \n\t"
+		"movl %%edx, %%ecx    \n\t"
+		"andl $3, %%ecx       \n\t"
+		"rep; movsb           \n\t"
+		:
+		: "c" (len), "D" (dst), "S" (src)
+		: "memory", "%edx" );
 }
 
 void bzero(void * dst, size_t len)
 {
-    asm volatile ( "xorl %%eax, %%eax    \n\t"
-         "cld                  \n\t"
-         "movl %%ecx, %%edx    \n\t"
-         "shrl $2, %%ecx       \n\t"
-         "rep; stosl           \n\t"
-         "movl %%edx, %%ecx    \n\t"
-         "andl $3, %%ecx       \n\t"
-         "rep; stosb           \n\t"
-       : 
-       : "c" (len), "D" (dst)
-       : "memory", "%eax" );
+	asm volatile ( "xorl %%eax, %%eax    \n\t"
+		"cld                  \n\t"
+		"movl %%ecx, %%edx    \n\t"
+		"shrl $2, %%ecx       \n\t"
+		"rep; stosl           \n\t"
+		"movl %%edx, %%ecx    \n\t"
+		"andl $3, %%ecx       \n\t"
+		"rep; stosb           \n\t"
+		:
+		: "c" (len), "D" (dst)
+		: "memory", "%eax" );
 }
 #endif
 
@@ -157,8 +157,7 @@
 	return 0;
 }
 
-char *
-strcpy(char * s1, const char * s2)
+char *strcpy(char *s1, const char *s2)
 {
 	register char *ret = s1;
 	while ((*s1++ = *s2++))
@@ -166,8 +165,7 @@
 	return ret;
 }
 
-char *
-stpcpy(char * s1, const char * s2)
+char *stpcpy(char *s1, const char *s2)
 {
 	while ((*s1++ = *s2++))
 	{
@@ -176,8 +174,7 @@
 	return --s1;
 }
 
-char *
-strncpy(char * s1, const char * s2, size_t n)
+char *strncpy(char *s1, const char *s2, size_t n)
 {
 	register char *ret = s1;
 	while (n && (*s1++ = *s2++))
@@ -189,8 +186,7 @@
 	return ret;
 }
 
-char *
-stpncpy(char * s1, const char * s2, size_t n)
+char *stpncpy(char *s1, const char *s2, size_t n)
 {
 	while (n && (*s1++ = *s2++))
 		--n;
@@ -201,8 +197,7 @@
 	return s1;
 }
 
-char *
-strstr(const char *in, const char *str)
+char *strstr(const char *in, const char *str)
 {
     char c;
     size_t len;
@@ -225,8 +220,7 @@
     return (char *) (in - 1);
 }
 
-int
-ptol(const char *str)
+int ptol(const char *str)
 {
 	register int c = *str;
 
@@ -238,8 +232,7 @@
 	return c;
 }
 
-int
-atoi(const char *str)
+int atoi(const char *str)
 {
 	register int sum = 0;
 	while (*str == ' ' || *str == '\t')
@@ -287,7 +280,7 @@
 }
 #endif
 
-char* strchr(const char *str, int c)
+char *strchr(const char *str, int c)
 {
     do
     {
@@ -297,9 +290,9 @@
     while(*(str++));
     
     return 0;
-}        
-        
-char* strbreak(const char *str, char **next, long *len)
+}
+
+char *strbreak(const char *str, char **next, long *len)
 {
     char *start = (char*)str, *end;
     bool quoted = false;
@@ -337,13 +330,14 @@
 }
 
 /* COPYRIGHT NOTICE: checksum8 from AppleSMBIOS */
-uint8_t checksum8( void * start, unsigned int length )
+uint8_t checksum8( void *start, unsigned int length )
 {
     uint8_t   csum = 0;
     uint8_t * cp = (uint8_t *) start;
     unsigned int i;
 
-	for ( i = 0; i < length; i++) {
+	for ( i = 0; i < length; i++)
+	{
 		csum += *cp++;
 	}
 	return csum;