Disable bk EOLN_NATIVE conversions on all files in packages FILESPATHs, to prevent it screwing up patches.

BKrev: 4190111fA4MuVozAqwE7xOSL9fr-TA

1 files changed, 250 insertions, 0 deletions

diff --git a/linux-uml/linux-uml-2.6.7/Ghash.patch b/linux-uml/linux-uml-2.6.7/Ghash.patch
index e69de29bb2..3b376806c2 100644
--- a/linux-uml/linux-uml-2.6.7/Ghash.patch
+++ b/linux-uml/linux-uml-2.6.7/Ghash.patch
@@ -0,0 +1,250 @@
+
+Just for now and just for UML; it will go away.
+
+Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>
+---
+
+ uml-linux-2.6.7-paolo/include/linux/ghash.h |  236 ++++++++++++++++++++++++++++
+ 1 files changed, 236 insertions(+)
+
+diff -puN /dev/null include/linux/ghash.h
+--- /dev/null	1970-01-01 01:00:00.000000000 +0100
++++ uml-linux-2.6.7-paolo/include/linux/ghash.h	2004-06-29 21:03:00.575549872 +0200
+@@ -0,0 +1,236 @@
++/*
++ * include/linux/ghash.h -- generic hashing with fuzzy retrieval
++ *
++ * (C) 1997 Thomas Schoebel-Theuer
++ *
++ * The algorithms implemented here seem to be a completely new invention,
++ * and I'll publish the fundamentals in a paper.
++ */
++
++#ifndef _GHASH_H
++#define _GHASH_H
++/* HASHSIZE _must_ be a power of two!!! */
++
++
++#define DEF_HASH_FUZZY_STRUCTS(NAME,HASHSIZE,TYPE) \
++\
++struct NAME##_table {\
++	TYPE * hashtable[HASHSIZE];\
++	TYPE * sorted_list;\
++	int nr_entries;\
++};\
++\
++struct NAME##_ptrs {\
++	TYPE * next_hash;\
++	TYPE * prev_hash;\
++	TYPE * next_sorted;\
++	TYPE * prev_sorted;\
++};
++
++#define DEF_HASH_FUZZY(LINKAGE,NAME,HASHSIZE,TYPE,PTRS,KEYTYPE,KEY,KEYCMP,KEYEQ,HASHFN)\
++\
++LINKAGE void insert_##NAME##_hash(struct NAME##_table * tbl, TYPE * elem)\
++{\
++	int ix = HASHFN(elem->KEY);\
++	TYPE ** base = &tbl->hashtable[ix];\
++	TYPE * ptr = *base;\
++	TYPE * prev = NULL;\
++\
++	tbl->nr_entries++;\
++	while(ptr && KEYCMP(ptr->KEY, elem->KEY)) {\
++		base = &ptr->PTRS.next_hash;\
++		prev = ptr;\
++		ptr = *base;\
++	}\
++	elem->PTRS.next_hash = ptr;\
++	elem->PTRS.prev_hash = prev;\
++	if(ptr) {\
++		ptr->PTRS.prev_hash = elem;\
++	}\
++	*base = elem;\
++\
++	ptr = prev;\
++	if(!ptr) {\
++		ptr = tbl->sorted_list;\
++		prev = NULL;\
++	} else {\
++		prev = ptr->PTRS.prev_sorted;\
++	}\
++	while(ptr) {\
++		TYPE * next = ptr->PTRS.next_hash;\
++		if(next && KEYCMP(next->KEY, elem->KEY)) {\
++			prev = ptr;\
++			ptr = next;\
++		} else if(KEYCMP(ptr->KEY, elem->KEY)) {\
++			prev = ptr;\
++			ptr = ptr->PTRS.next_sorted;\
++		} else\
++			break;\
++	}\
++	elem->PTRS.next_sorted = ptr;\
++	elem->PTRS.prev_sorted = prev;\
++	if(ptr) {\
++		ptr->PTRS.prev_sorted = elem;\
++	}\
++	if(prev) {\
++		prev->PTRS.next_sorted = elem;\
++	} else {\
++		tbl->sorted_list = elem;\
++	}\
++}\
++\
++LINKAGE void remove_##NAME##_hash(struct NAME##_table * tbl, TYPE * elem)\
++{\
++	TYPE * next = elem->PTRS.next_hash;\
++	TYPE * prev = elem->PTRS.prev_hash;\
++\
++	tbl->nr_entries--;\
++	if(next)\
++		next->PTRS.prev_hash = prev;\
++	if(prev)\
++		prev->PTRS.next_hash = next;\
++	else {\
++		int ix = HASHFN(elem->KEY);\
++		tbl->hashtable[ix] = next;\
++	}\
++\
++	next = elem->PTRS.next_sorted;\
++	prev = elem->PTRS.prev_sorted;\
++	if(next)\
++		next->PTRS.prev_sorted = prev;\
++	if(prev)\
++		prev->PTRS.next_sorted = next;\
++	else\
++		tbl->sorted_list = next;\
++}\
++\
++LINKAGE TYPE * find_##NAME##_hash(struct NAME##_table * tbl, KEYTYPE pos)\
++{\
++	int ix = hashfn(pos);\
++	TYPE * ptr = tbl->hashtable[ix];\
++	while(ptr && KEYCMP(ptr->KEY, pos))\
++		ptr = ptr->PTRS.next_hash;\
++	if(ptr && !KEYEQ(ptr->KEY, pos))\
++		ptr = NULL;\
++	return ptr;\
++}\
++\
++LINKAGE TYPE * find_##NAME##_hash_fuzzy(struct NAME##_table * tbl, KEYTYPE pos)\
++{\
++	int ix;\
++	int offset;\
++	TYPE * ptr;\
++	TYPE * next;\
++\
++	ptr = tbl->sorted_list;\
++	if(!ptr || KEYCMP(pos, ptr->KEY))\
++		return NULL;\
++	ix = HASHFN(pos);\
++	offset = HASHSIZE;\
++	do {\
++		offset >>= 1;\
++		next = tbl->hashtable[(ix+offset) & ((HASHSIZE)-1)];\
++		if(next && (KEYCMP(next->KEY, pos) || KEYEQ(next->KEY, pos))\
++		   && KEYCMP(ptr->KEY, next->KEY))\
++			ptr = next;\
++	} while(offset);\
++\
++	for(;;) {\
++		next = ptr->PTRS.next_hash;\
++		if(next) {\
++			if(KEYCMP(next->KEY, pos)) {\
++				ptr = next;\
++				continue;\
++			}\
++		}\
++		next = ptr->PTRS.next_sorted;\
++		if(next && KEYCMP(next->KEY, pos)) {\
++			ptr = next;\
++			continue;\
++		}\
++		return ptr;\
++	}\
++	return NULL;\
++}
++
++/* LINKAGE - empty or "static", depending on whether you want the definitions to
++ *	be public or not
++ * NAME - a string to stick in names to make this hash table type distinct from
++ * 	any others
++ * HASHSIZE - number of buckets
++ * TYPE - type of data contained in the buckets - must be a structure, one 
++ * 	field is of type NAME_ptrs, another is the hash key
++ * PTRS - TYPE must contain a field of type NAME_ptrs, PTRS is the name of that
++ * 	field
++ * KEYTYPE - type of the key field within TYPE
++ * KEY - name of the key field within TYPE
++ * KEYCMP - pointer to function that compares KEYTYPEs to each other - the
++ * 	prototype is int KEYCMP(KEYTYPE, KEYTYPE), it returns zero for equal, 
++ * 	non-zero for not equal
++ * HASHFN - the hash function - the prototype is int HASHFN(KEYTYPE),
++ * 	it returns a number in the range 0 ... HASHSIZE - 1
++ * Call DEF_HASH_STRUCTS, define your hash table as a NAME_table, then call
++ * DEF_HASH.
++ */
++
++#define DEF_HASH_STRUCTS(NAME,HASHSIZE,TYPE) \
++\
++struct NAME##_table {\
++	TYPE * hashtable[HASHSIZE];\
++	int nr_entries;\
++};\
++\
++struct NAME##_ptrs {\
++	TYPE * next_hash;\
++	TYPE * prev_hash;\
++};
++
++#define DEF_HASH(LINKAGE,NAME,TYPE,PTRS,KEYTYPE,KEY,KEYCMP,HASHFN)\
++\
++LINKAGE void insert_##NAME##_hash(struct NAME##_table * tbl, TYPE * elem)\
++{\
++	int ix = HASHFN(elem->KEY);\
++	TYPE ** base = &tbl->hashtable[ix];\
++	TYPE * ptr = *base;\
++	TYPE * prev = NULL;\
++\
++	tbl->nr_entries++;\
++	while(ptr && KEYCMP(ptr->KEY, elem->KEY)) {\
++		base = &ptr->PTRS.next_hash;\
++		prev = ptr;\
++		ptr = *base;\
++	}\
++	elem->PTRS.next_hash = ptr;\
++	elem->PTRS.prev_hash = prev;\
++	if(ptr) {\
++		ptr->PTRS.prev_hash = elem;\
++	}\
++	*base = elem;\
++}\
++\
++LINKAGE void remove_##NAME##_hash(struct NAME##_table * tbl, TYPE * elem)\
++{\
++	TYPE * next = elem->PTRS.next_hash;\
++	TYPE * prev = elem->PTRS.prev_hash;\
++\
++	tbl->nr_entries--;\
++	if(next)\
++		next->PTRS.prev_hash = prev;\
++	if(prev)\
++		prev->PTRS.next_hash = next;\
++	else {\
++		int ix = HASHFN(elem->KEY);\
++		tbl->hashtable[ix] = next;\
++	}\
++}\
++\
++LINKAGE TYPE * find_##NAME##_hash(struct NAME##_table * tbl, KEYTYPE pos)\
++{\
++	int ix = HASHFN(pos);\
++	TYPE * ptr = tbl->hashtable[ix];\
++	while(ptr && KEYCMP(ptr->KEY, pos))\
++		ptr = ptr->PTRS.next_hash;\
++	return ptr;\
++}
++
++#endif
+_