From 0ab69dd9f7b48237939e03b775fb7b41d3b2438d Mon Sep 17 00:00:00 2001 From: Jay Freeman Date: Mon, 27 Apr 2009 10:05:44 +0000 Subject: Starting factor of apt7. git-svn-id: http://svn.telesphoreo.org/trunk@606 514c082c-b64e-11dc-b46d-3d985efe055d --- data/_apt7/memrchr.diff | 195 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 data/_apt7/memrchr.diff (limited to 'data/_apt7/memrchr.diff') diff --git a/data/_apt7/memrchr.diff b/data/_apt7/memrchr.diff new file mode 100644 index 000000000..8913e1816 --- /dev/null +++ b/data/_apt7/memrchr.diff @@ -0,0 +1,195 @@ +diff -ru apt-0.7.20.2/ftparchive/cachedb.cc apt-0.7.20.2+iPhone/ftparchive/cachedb.cc +--- apt-0.7.20.2/ftparchive/cachedb.cc 2009-02-07 15:09:35.000000000 +0000 ++++ apt-0.7.20.2+iPhone/ftparchive/cachedb.cc 2009-04-14 16:10:02.000000000 +0000 +@@ -315,6 +315,14 @@ + } + } + ++void *memrchr(void *data, char value, int size) { ++ char *cdata = (char *) data; ++ for (int i = 0; i != size; ++i) ++ if (cdata[size - i - 1] == value) ++ return cdata + size - i - 1; ++ return NULL; ++} ++ + // CacheDB::GetMD5 - Get the MD5 hash /*{{{*/ + // --------------------------------------------------------------------- + /* */ +diff -ru apt-0.7.20.2/apt-pkg/deb/dpkgpm.cc apt-0.7.20.2+iPhone/apt-pkg/deb/dpkgpm.cc +--- apt-0.7.20.2/apt-pkg/deb/dpkgpm.cc 2009-02-07 15:09:35.000000000 +0000 ++++ apt-0.7.20.2+iPhone/apt-pkg/deb/dpkgpm.cc 2009-04-15 19:25:04.000000000 +0000 +@@ -501,6 +501,7 @@ + + // now move the unprocessed bits (after the final \n that is now a 0x0) + // to the start and update dpkgbuf_pos ++ void *memrchr(void const *, int, size_t); + p = (char*)memrchr(dpkgbuf, 0, dpkgbuf_pos); + if(p == NULL) + return; +@@ -974,3 +975,165 @@ + List.erase(List.begin(),List.end()); + } + /*}}}*/ ++ ++/* memrchr -- find the last occurrence of a byte in a memory block ++ ++ Copyright (C) 1991, 1993, 1996, 1997, 1999, 2000, 2003, 2004, 2005, ++ 2006, 2007, 2008 Free Software Foundation, Inc. ++ ++ Based on strlen implementation by Torbjorn Granlund (tege@sics.se), ++ with help from Dan Sahlin (dan@sics.se) and ++ commentary by Jim Blandy (jimb@ai.mit.edu); ++ adaptation to memchr suggested by Dick Karpinski (dick@cca.ucsf.edu), ++ and implemented by Roland McGrath (roland@ai.mit.edu). ++ ++ This program is free software: you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 3 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see . */ ++ ++#if defined _LIBC ++# include ++#else ++# include ++# define reg_char char ++#endif ++ ++#include ++#include ++ ++#undef __memrchr ++#ifdef _LIBC ++# undef memrchr ++#endif ++ ++#ifndef weak_alias ++# define __memrchr memrchr ++#endif ++ ++/* Search no more than N bytes of S for C. */ ++void * ++__memrchr (void const *s, int c_in, size_t n) ++{ ++ /* On 32-bit hardware, choosing longword to be a 32-bit unsigned ++ long instead of a 64-bit uintmax_t tends to give better ++ performance. On 64-bit hardware, unsigned long is generally 64 ++ bits already. Change this typedef to experiment with ++ performance. */ ++ typedef unsigned long int longword; ++ ++ const unsigned char *char_ptr; ++ const longword *longword_ptr; ++ longword repeated_one; ++ longword repeated_c; ++ unsigned reg_char c; ++ ++ c = (unsigned char) c_in; ++ ++ /* Handle the last few bytes by reading one byte at a time. ++ Do this until CHAR_PTR is aligned on a longword boundary. */ ++ for (char_ptr = (const unsigned char *) s + n; ++ n > 0 && (size_t) char_ptr % sizeof (longword) != 0; ++ --n) ++ if (*--char_ptr == c) ++ return (void *) char_ptr; ++ ++ longword_ptr = (const longword *) char_ptr; ++ ++ /* All these elucidatory comments refer to 4-byte longwords, ++ but the theory applies equally well to any size longwords. */ ++ ++ /* Compute auxiliary longword values: ++ repeated_one is a value which has a 1 in every byte. ++ repeated_c has c in every byte. */ ++ repeated_one = 0x01010101; ++ repeated_c = c | (c << 8); ++ repeated_c |= repeated_c << 16; ++ if (0xffffffffU < (longword) -1) ++ { ++ repeated_one |= repeated_one << 31 << 1; ++ repeated_c |= repeated_c << 31 << 1; ++ if (8 < sizeof (longword)) ++ { ++ size_t i; ++ ++ for (i = 64; i < sizeof (longword) * 8; i *= 2) ++ { ++ repeated_one |= repeated_one << i; ++ repeated_c |= repeated_c << i; ++ } ++ } ++ } ++ ++ /* Instead of the traditional loop which tests each byte, we will test a ++ longword at a time. The tricky part is testing if *any of the four* ++ bytes in the longword in question are equal to c. We first use an xor ++ with repeated_c. This reduces the task to testing whether *any of the ++ four* bytes in longword1 is zero. ++ ++ We compute tmp = ++ ((longword1 - repeated_one) & ~longword1) & (repeated_one << 7). ++ That is, we perform the following operations: ++ 1. Subtract repeated_one. ++ 2. & ~longword1. ++ 3. & a mask consisting of 0x80 in every byte. ++ Consider what happens in each byte: ++ - If a byte of longword1 is zero, step 1 and 2 transform it into 0xff, ++ and step 3 transforms it into 0x80. A carry can also be propagated ++ to more significant bytes. ++ - If a byte of longword1 is nonzero, let its lowest 1 bit be at ++ position k (0 <= k <= 7); so the lowest k bits are 0. After step 1, ++ the byte ends in a single bit of value 0 and k bits of value 1. ++ After step 2, the result is just k bits of value 1: 2^k - 1. After ++ step 3, the result is 0. And no carry is produced. ++ So, if longword1 has only non-zero bytes, tmp is zero. ++ Whereas if longword1 has a zero byte, call j the position of the least ++ significant zero byte. Then the result has a zero at positions 0, ..., ++ j-1 and a 0x80 at position j. We cannot predict the result at the more ++ significant bytes (positions j+1..3), but it does not matter since we ++ already have a non-zero bit at position 8*j+7. ++ ++ So, the test whether any byte in longword1 is zero is equivalent to ++ testing whether tmp is nonzero. */ ++ ++ while (n >= sizeof (longword)) ++ { ++ longword longword1 = *--longword_ptr ^ repeated_c; ++ ++ if ((((longword1 - repeated_one) & ~longword1) ++ & (repeated_one << 7)) != 0) ++ { ++ longword_ptr++; ++ break; ++ } ++ n -= sizeof (longword); ++ } ++ ++ char_ptr = (const unsigned char *) longword_ptr; ++ ++ /* At this point, we know that either n < sizeof (longword), or one of the ++ sizeof (longword) bytes starting at char_ptr is == c. On little-endian ++ machines, we could determine the first such byte without any further ++ memory accesses, just by looking at the tmp result from the last loop ++ iteration. But this does not work on big-endian machines. Choose code ++ that works in both cases. */ ++ ++ while (n-- > 0) ++ { ++ if (*--char_ptr == c) ++ return (void *) char_ptr; ++ } ++ ++ return NULL; ++} ++#ifdef weak_alias ++weak_alias (__memrchr, memrchr) ++#endif -- cgit v1.2.3