Attachment 110754 Details for Bug 151951 – file.shar

file.shar

file.shar (text/plain), 45.92 KB, created by Tom Judge on 2010-11-04 20:00:24 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Tom Judge

Created: 2010-11-04 20:00:24 UTC

Size: 45.92 KB

patch

obsolete

># This is a shell archive.  Save it in a file, remove anything before
># this line, and then unpack it by entering "sh file".  Note, it may
># create directories; files and directories will be owned by you and
># have default permissions.
>#
># This archive contains:
>#
>#	clucene-contrib
>#	clucene-contrib/files
>#	clucene-contrib/files/patch-Makefile.in
>#	clucene-contrib/files/patch-src_CLucene_jstreams_substreamprovider.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_subinputstream.cpp
>#	clucene-contrib/files/patch-src_CLucene_jstreams_tarinputstream.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_Makefile.am
>#	clucene-contrib/files/patch-src_CLucene_jstreams_subinputstream.h
>#	clucene-contrib/files/patch-src_CLucene_highlighter_TokenSources.cpp
>#	clucene-contrib/files/patch-src_CLucene_jstreams_streambase.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_stringreader.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_inputstreamreader.cpp
>#	clucene-contrib/files/patch-src_CLucene_analysis_cjk_CJKAnalyzer.cpp
>#	clucene-contrib/files/patch-src_CLucene_highlighter_QueryTermExtractor.cpp
>#	clucene-contrib/files/patch-src_CLucene_jstreams_filereader.cpp
>#	clucene-contrib/files/patch-src_CLucene_jstreams_zipinputstream.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_bufferedstream.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_inputstreamreader.h
>#	clucene-contrib/files/patch-src_CLucene_analysis_cjk_CJKAnalyzer.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_filereader.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_inputstreambuffer.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_gzipinputstream.h
>#	clucene-contrib/files/patch-src_CLucene_jstreams_fileinputstream.cpp
>#	clucene-contrib/files/patch-src_CLucene_jstreams_fileinputstream.h
>#	clucene-contrib/files/patch-src_CLucene_analysis_Makefile.am
>#	clucene-contrib/distinfo
>#	clucene-contrib/pkg-descr
>#	clucene-contrib/pkg-plist
>#	clucene-contrib/Makefile
>#
>echo c - clucene-contrib
>mkdir -p clucene-contrib > /dev/null 2>&1
>echo c - clucene-contrib/files
>mkdir -p clucene-contrib/files > /dev/null 2>&1
>echo x - clucene-contrib/files/patch-Makefile.in
>sed 's/^X//' >clucene-contrib/files/patch-Makefile.in << 'b4aaea9e84598d493caab5f28dabaee5'
>X--- Makefile.in.orig	2010-06-23 03:47:21.000000000 +0000
>X+++ Makefile.in	2010-06-23 03:48:03.000000000 +0000
>X@@ -178,8 +178,8 @@
>X sysconfdir = @sysconfdir@
>X target_alias = @target_alias@
>X INCLUDES = -I$(top_srcdir)
>X-SUBDIRS = src test
>X-DIST_SUBDIRS = src test win32 .
>X+SUBDIRS = src
>X+DIST_SUBDIRS = src win32 .
>X ACLOCAL_AMFLAGS = -I $(top_srcdir)/m4
>X EXTRA_DIST = $(top_srcdir)/autogen.sh \
>X 		     $(top_srcdir)/HACKING \
>b4aaea9e84598d493caab5f28dabaee5
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_substreamprovider.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_substreamprovider.h << 'f92b4a3c1d3212775d5317c7c813189c'
>X--- src/CLucene/jstreams/substreamprovider.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/substreamprovider.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -16,8 +16,9 @@
>X     std::string filename;
>X     int32_t size;
>X     uint mtime;
>X-    enum Type {Dir, File};
>X+    enum Type {Unknown=0, Dir=1, File=2};
>X     Type type;
>X+    EntryInfo() :size(-1), mtime(0), type(Unknown) {}
>X };
>X 
>X class SubStreamProvider {
>X@@ -25,16 +26,18 @@
>X     StreamStatus status;
>X     std::string error;
>X     StreamBase<char> *input;
>X+    StreamBase<char> *entrystream;
>X     EntryInfo entryinfo;
>X public:
>X-    SubStreamProvider(StreamBase<char> *i) :status(Ok), input(i) {}
>X-    virtual ~SubStreamProvider() {}
>X+    SubStreamProvider(StreamBase<char> *i) :status(Ok), input(i), entrystream(0)
>X+        {}
>X+    virtual ~SubStreamProvider() { if (entrystream) delete entrystream; }
>X     StreamStatus getStatus() const { return status; }
>X     virtual StreamBase<char>* nextEntry() = 0;
>X+    StreamBase<char>* currentEntry() { return entrystream; }
>X     const EntryInfo &getEntryInfo() const {
>X         return entryinfo;
>X     }
>X-//    std::string getEntryFileName() const { return entryfilename; }
>X     const char* getError() const { return error.c_str(); }
>X };
>X 
>f92b4a3c1d3212775d5317c7c813189c
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_subinputstream.cpp
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_subinputstream.cpp << 'dd4d921a859e39b0e75f19915277c0f9'
>X--- src/CLucene/jstreams/subinputstream.cpp	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/subinputstream.cpp.orig	Fri Nov 24 13:42:02 2006
>X@@ -31,7 +31,7 @@
>X     }
>X     int32_t nread = input->read(start, min, max);
>X     if (nread < -1) {
>X-        printf("substream too short.\n");
>X+        fprintf(stderr, "substream too short.\n");
>X         status = Error;
>X         error = input->getError();
>X     } else if (nread < min) {
>X@@ -42,9 +42,9 @@
>X                 size = position;
>X             }
>X         } else {
>X-            printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! nread %i min %i max %i size %lli\n", nread, min, max, size);
>X-            printf("pos %lli parentpos %lli\n", position, input->getPosition());
>X-            printf("status: %i error: %s\n", input->getStatus(), input->getError());
>X+//            fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! nread %i min %i max %i size %lli\n", nread, min, max, size);
>X+//            fprintf(stderr, "pos %lli parentpos %lli\n", position, input->getPosition());
>X+//            fprintf(stderr, "status: %i error: %s\n", input->getStatus(), input->getError());
>X             // we expected data but didn't get enough so that's an error
>X             status = Error;
>X             error = "Premature end of stream\n";
>X@@ -59,21 +59,18 @@
>X     return nread;
>X }
>X int64_t
>X-SubInputStream::mark(int32_t readlimit) {
>X-    position = input->mark(readlimit) - offset;
>X-    return position;
>X-}
>X-int64_t
>X SubInputStream::reset(int64_t newpos) {
>X-    //printf("subreset pos: %lli newpos: %lli offset: %lli\n", position,
>X-    //    newpos, offset);
>X+    assert(newpos >= 0);
>X+//    fprintf(stderr, "subreset pos: %lli newpos: %lli offset: %lli\n", position,
>X+//        newpos, offset);
>X     position = input->reset(newpos + offset);
>X     if (position < offset) {
>X-        printf("###########\n");
>X+        fprintf(stderr, "########### position %lli newpos %lli\n", position, newpos);
>X         status = Error;
>X         error = input->getError();
>X     } else {
>X         position -= offset;
>X+        status = input->getStatus();
>X     }
>X     return position;
>X }
>dd4d921a859e39b0e75f19915277c0f9
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_tarinputstream.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_tarinputstream.h << 'ec8b66bdfc12a986d9ea8a3bbae1b8ac'
>X--- src/CLucene/jstreams/tarinputstream.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/tarinputstream.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -28,7 +28,6 @@
>X class TarInputStream : public SubStreamProvider {
>X private:
>X     // information relating to the current entry
>X-    StreamBase<char> *output;
>X     int32_t numPaddingBytes;
>X 
>X     void readFileName(int32_t len);
>X@@ -37,10 +36,13 @@
>X     int32_t readOctalField(const char *b, int32_t offset);
>X     void readLongLink(const char *b);
>X public:
>X-    TarInputStream(StreamBase<char> *input);
>X+    explicit TarInputStream(StreamBase<char> *input);
>X     ~TarInputStream();
>X     StreamBase<char>* nextEntry();
>X     static bool checkHeader(const char* data, int32_t datasize);
>X+    static SubStreamProvider* factory(StreamBase<char>* input) {
>X+        return new TarInputStream(input);
>X+    }
>X };
>X 
>X } // end namespace jstreams
>ec8b66bdfc12a986d9ea8a3bbae1b8ac
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_Makefile.am
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_Makefile.am << 'c207b1943466c20ad94855d94079e679'
>X--- src/CLucene/jstreams/Makefile.am	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/Makefile.am.orig	Mon Dec  4 18:09:03 2006
>X@@ -2,15 +2,15 @@
>X jstreamsdir = $(lsrcdir)/jstreams
>X jstreamshdir = $(includedir)/CLucene/jstreams
>X  
>X+libclucene_contrib_la_SOURCES  += $(jstreamsdir)/bz2inputstream.cpp
>X+libclucene_contrib_la_SOURCES  += $(jstreamsdir)/dostime.cpp
>X libclucene_contrib_la_SOURCES  += $(jstreamsdir)/fileinputstream.cpp
>X libclucene_contrib_la_SOURCES  += $(jstreamsdir)/filereader.cpp
>X+libclucene_contrib_la_SOURCES  += $(jstreamsdir)/gzipcompressstream.cpp
>X+libclucene_contrib_la_SOURCES  += $(jstreamsdir)/gzipinputstream.cpp
>X libclucene_contrib_la_SOURCES  += $(jstreamsdir)/inputstreamreader.cpp
>X libclucene_contrib_la_SOURCES  += $(jstreamsdir)/subinputstream.cpp
>X-
>X-#libclucene_contrib_la_SOURCES  += $(jstreamsdir)/dostime.c
>X-#libclucene_contrib_la_SOURCES  += $(jstreamsdir)/tarinputstream.cpp
>X-#libclucene_contrib_la_SOURCES  += $(jstreamsdir)/bz2inputstream.cpp
>X-#libclucene_contrib_la_SOURCES  += $(jstreamsdir)/gzipinputstream.cpp
>X-#libclucene_contrib_la_SOURCES  += $(jstreamsdir)/zipinputstream.cpp
>X+libclucene_contrib_la_SOURCES  += $(jstreamsdir)/tarinputstream.cpp
>X+libclucene_contrib_la_SOURCES  += $(jstreamsdir)/zipinputstream.cpp
>X 
>X jstreamsh_HEADERS = $(jstreamsdir)/*.h
>c207b1943466c20ad94855d94079e679
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_subinputstream.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_subinputstream.h << '0c91eb88e457cc04b3de94bd0ccbd56d'
>X--- src/CLucene/jstreams/subinputstream.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/subinputstream.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -18,7 +18,6 @@
>X public:
>X     SubInputStream(StreamBase<char> *input, int64_t size=-1);
>X     int32_t read(const char*& start, int32_t min, int32_t max);
>X-    int64_t mark(int32_t readlimit);
>X     int64_t reset(int64_t newpos);
>X     int64_t skip(int64_t ntoskip);
>X };
>0c91eb88e457cc04b3de94bd0ccbd56d
>echo x - clucene-contrib/files/patch-src_CLucene_highlighter_TokenSources.cpp
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_highlighter_TokenSources.cpp << '48f46d0197ee135c340852f1f5036028'
>X--- src/CLucene/highlighter/TokenSources.cpp	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/highlighter/TokenSources.cpp.orig	Sat Nov 25 11:08:10 2006
>X@@ -27,12 +27,7 @@
>X 		//to TermPositionVector, we take the token stream
>X 		//only if the cast works... should have a way of
>X 		//knowing what type this is
>X-		TermPositionVector* tmp = NULL;
>X-		try{
>X-			 tmp = (TermPositionVector*)tfv;
>X-		}catch(...){
>X-			//ignore
>X-		}
>X+		TermPositionVector* tmp = tfv->__asTermPositionVector();
>X 		if ( tmp != NULL )
>X 		    ts=getTokenStream(tmp);
>X 	}
>X@@ -73,24 +68,21 @@
>X     }     */   
>X     //code to reconstruct the original sequence of Tokens
>X     const TCHAR** terms=tpv->getTerms();          
>X-    const int32_t* freq=tpv->getTermFrequencies();
>X-	int32_t freqLen = tpv->size();
>X+    const Array<int32_t>* freq=tpv->getTermFrequencies();
>X 
>X     size_t totalTokens=0;
>X-	{
>X-		for (int32_t t = 0; t < freqLen; t++)
>X-			totalTokens+=freq[t];
>X-	}
>X+	for (int32_t i = 0; i < freq->length; i++)
>X+		totalTokens+=freq->values[i];
>X 
>X     Token** tokensInOriginalOrder=NULL;
>X 	CLSetList<Token*,Token::OrderCompare>* unsortedTokens = NULL;
>X-    for (int32_t t = 0; t < freqLen; t++)
>X+    for (int32_t t = 0; t < freq->length; t++)
>X     {
>X-        TermVectorOffsetInfo** offsets=tpv->getOffsets(t);
>X+        Array<TermVectorOffsetInfo>* offsets=tpv->getOffsets(t);
>X         if(offsets==NULL)
>X             return NULL;
>X         
>X-        int32_t* pos=NULL;
>X+        Array<int32_t>* pos=NULL;
>X 		int32_t posLen=0;
>X         if(tokenPositionsGuaranteedContiguous)
>X         {
>X@@ -107,11 +99,11 @@
>X             //tokens NOT stored with positions or not guaranteed contiguous - must add to list and sort later
>X             if(unsortedTokens==NULL)
>X                 unsortedTokens=_CLNEW CLSetList<Token*,Token::OrderCompare>(false);
>X-            for (int32_t tp=0; offsets[tp]!=NULL; tp++)
>X+            for (int32_t tp=0; tp < offsets->length; tp++)
>X             {
>X                 unsortedTokens->insert(_CLNEW Token(terms[t],
>X-                    offsets[tp]->getStartOffset(),
>X-                    offsets[tp]->getEndOffset()));
>X+                    (*offsets)[tp].getStartOffset(),
>X+                    (*offsets)[tp].getEndOffset()));
>X             }
>X         }
>X         else
>X@@ -124,9 +116,9 @@
>X             //tokens stored with positions - can use this to index straight into sorted array
>X             for (int32_t tp = 0; tp < posLen; tp++)
>X             {
>X-                tokensInOriginalOrder[pos[tp]]=_CLNEW Token(terms[t],
>X-                        offsets[tp]->getStartOffset(),
>X-                        offsets[tp]->getEndOffset());
>X+                tokensInOriginalOrder[(*pos)[tp]]=_CLNEW Token(terms[t],
>X+                        (*offsets)[tp].getStartOffset(),
>X+                        (*offsets)[tp].getEndOffset());
>X             }                
>X         }
>X     }
>X@@ -158,13 +150,10 @@
>X 
>X 	//todo:bad way of doing this...
>X 	TermPositionVector* tmp = NULL;
>X-	try{
>X-		tmp = (TermPositionVector*) tfv; //check to see if tfv is a Tpv
>X-	}catch(...){}
>X+	tmp = tfv->__asTermPositionVector();
>X 
>X 	if ( tmp != NULL ){
>X-		TermPositionVector* tpv=(TermPositionVector*)reader->getTermFreqVector(docId,field);
>X-	    return getTokenStream(tpv);	        
>X+	    return getTokenStream(tmp);	        
>X 	}else{
>X 		TCHAR buf[250];
>X 		_sntprintf(buf,250,_T("%s in doc #%d does not have any term position data stored"),field,docId);
>48f46d0197ee135c340852f1f5036028
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_streambase.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_streambase.h << 'dcb90563b194384ed991332c85f62666'
>X--- src/CLucene/jstreams/streambase.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/streambase.h.orig	Sat Nov 25 11:03:58 2006
>X@@ -17,13 +17,14 @@
>X 
>X /**
>X  * @short Base class for stream read access to many different file types.
>X- * 
>X+ *
>X  * This class is based on the interface java.io.InputStream. It allows
>X  * for uniform access to streamed resources.
>X  * The main difference with the java equivalent is a performance improvement.
>X  * When reading data, data is not copied into a buffer provided by the caller,
>X- * but a pointer to the read data is provided. This makes this interface especially
>X- * useful for deriving from it and implementing filterers or transformers.
>X+ * but a pointer to the read data is provided. This makes this interface
>X+ * especially useful for deriving from it and implementing filterers or
>X+ * transformers.
>X  */
>X // java mapping: long=int64, int=int32, byte=uint8_t
>X template <class T>
>X@@ -37,29 +38,24 @@
>X     StreamBase() :size(-1), position(0), status(Ok){ }
>X     virtual ~StreamBase(){}
>X     /**
>X-     * Return a string representation of the last error that has occurred.
>X+     * @brief  Return a string representation of the last error.
>X      * If no error has occurred, an empty string is returned.
>X      **/
>X     const char* getError() const { return error.c_str(); }
>X     StreamStatus getStatus() const { return status; }
>X+    /**
>X+     * @brief Get the current position in the stream.
>X+     * The value obtained from this function can be used to reset the stream.
>X+     **/
>X     int64_t getPosition() const { return position; }
>X-    int64_t getSize() const { return size; }
>X-    /** 
>X-     * @brief Reads @p ntoread characters from the stream and sets \a start to
>X-     * the first character that was read.
>X-     *
>X-     * If @p ntoread is @c 0, then at least one character will be read.
>X-     *
>X-     * @param start Pointer passed by reference that will be set to point to
>X-     *              the retrieved array of characters. If the end of the stream
>X-     *              is encountered or an error occurs, the value of @p start
>X-     *              is undefined.
>X-     * @return the number of characters that were read. If 0 is returned, the
>X-     *         end of the stream has been reached. If -1 is returned, an error
>X-     *         has occured.
>X+    /**
>X+     * @brief Return the size of the stream.
>X+     * If the size of the stream is unknown, -1
>X+     * is returned. If the end of the stream has been reached the size is
>X+     * always known.
>X      **/
>X- //   virtual int32_t read(const T*& start) = 0;
>X-    /** 
>X+    int64_t getSize() const { return size; }
>X+    /**
>X      * @brief Reads characters from the stream and sets \a start to
>X      * the first character that was read.
>X      *
>X@@ -73,61 +69,34 @@
>X      *                @p is @c 0 the stream reads at least 1 character.
>X      * @return the number of characters that were read. If -1 is returned, the
>X      *         end of the stream has been reached. If -2 is returned, an error
>X-     *         has occured.
>X+     *         has occurred.
>X      **/
>X     virtual int32_t read(const T*& start, int32_t min, int32_t max) = 0;
>X     /**
>X-     * Same as read(const T*& start, int32_t ntoread), but may read more.
>X-     **/
>X-//    virtual int32_t readAtLeast(const T*& start, int32_t ntoread) = 0;
>X-    /* the available value may be greater than the actual value if
>X-      the encoding is a variable one (such as utf8 or unicode) */
>X-    /**
>X      * Skip @param ntoskip bytes. Unless an error occurs or the end of file is
>X      * encountered, this amount of bytes is skipped.
>X-     * The optional @param skipped can be use to find out how many bites were skipped.
>X-     * If the end of stream is reached, Eof is returned.
>X-     * If an error occured, Error is returned.
>X+     * This function returns new position in the stream.
>X      **/
>X     virtual int64_t skip(int64_t ntoskip);
>X-     /**
>X-      * \short Marks the current position in this input stream.
>X-      * A subsequent call to the reset method repositions this stream at the
>X-      * last marked position so that subsequent reads re-read the same bytes.
>X-      *
>X-      * The readlimit arguments tells this input stream to allow that many
>X-      * bytes to be read before the mark position gets invalidated.
>X-      * The stream somehow remembers all the bytes read after the call to mark
>X-      * and stands ready to supply those same bytes again if and whenever the
>X-      * method reset is called. However, the stream is not required to remember
>X-      * any data at all if more than readlimit bytes are read from the stream
>X-      * before reset is called.
>X-      *
>X-      * When calling the method mark more than once at the same position in the
>X-      * stream, the call with the largest value for \p readlimit is defining.
>X-      **/
>X-    virtual int64_t mark(int32_t readlimit) = 0;
>X       /**
>X-       * \short Repositions this stream to given requested position.
>X-       * The general contract of reset is:
>X-       * - Reset is guaranteed to work after a successfull call to read(),
>X-       *   when new position is in the range of the data returned by read().
>X-       *   This means that @p pos must lie between than the position
>X-       *   corresponding to the @p start parameter (x) of the @r read function
>X-       *   and the position corresponding to the last position in the returned
>X-       *   buffer (x + @p nread).
>X-       * if If the method mark has not been called since the stream was created,
>X-       *   or the number of bytes read from the stream since mark was last
>X-       *   called is larger than the argument to mark at that last call, then
>X-       *   Error is returned.
>X-       * - Otherwise the stream is reset to a state such that all the bytes
>X-       *   read since the most recent call to mark (or since the start of the
>X-       *   file, if mark has not been called) will be resupplied to subsequent
>X-       *   callers of the read method, followed by any bytes that otherwise
>X-       *   would have been the next input data as of the time of the call to
>X-       *   reset.
>X+       * @brief Repositions this stream to given requested position.
>X+       * Reset is guaranteed to work after a successful call to read(),
>X+       * when the new position is in the range of the data returned by read().
>X+       * This means that @p pos must lie between than the position
>X+       * corresponding to the @p start parameter (x) of the @r read function
>X+       * and the position corresponding to the last position in the returned
>X+       * buffer (x + @p nread).
>X        **/
>X     virtual int64_t reset(int64_t pos) = 0;
>X+    /**
>X+     * deprecated function
>X+     **/
>X+    int64_t mark(int32_t readlimit) {
>X+        int64_t p = getPosition();
>X+        const T* ptr;
>X+        read(ptr, readlimit, -1);
>X+        return reset(p);
>X+    }
>X };
>X #define SKIPSTEP 1024
>X template <class T>
>dcb90563b194384ed991332c85f62666
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_stringreader.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_stringreader.h << 'cef0e34cbe7a4ddb8569b36b62ec1276'
>X--- src/CLucene/jstreams/stringreader.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/stringreader.h.orig	Sat Nov 25 11:03:58 2006
>X@@ -1,6 +1,18 @@
>X+/*------------------------------------------------------------------------------
>X+* Copyright (C) 2003-2006 Jos van den Oever
>X+* 
>X+* Distributable under the terms of either the Apache License (Version 2.0) or 
>X+* the GNU Lesser General Public License, as specified in the COPYING file.
>X+------------------------------------------------------------------------------*/
>X #ifndef STRINGREADER_H
>X #define STRINGREADER_H
>X 
>X+/**
>X+ * Author: Jos van den Oever
>X+ *         Ben van Klinken
>X+ **/
>X+
>X+
>X #include "streambase.h"
>X 
>X namespace jstreams {
>X@@ -18,18 +30,18 @@
>X     ~StringReader();
>X     int32_t read(const T*& start, int32_t min, int32_t max);
>X     int64_t skip(int64_t ntoskip);
>X-    int64_t mark(int32_t readlimit);
>X     int64_t reset(int64_t pos);
>X };
>X 
>X+typedef StringReader<char> StringInputStream;
>X+
>X template <class T>
>X StringReader<T>::StringReader(const T* value, int32_t length, bool copy)
>X         : markpt(0), dataowner(copy) {
>X     if (length < 0) {
>X-        if (sizeof(T) > 1) {
>X-            length = wcslen((const wchar_t*)value);
>X-        } else {
>X-            length = strlen((const char*)value);
>X+        length = 0;
>X+        while (value[length] != '\0') {
>X+            length++;
>X         }
>X     }
>X     StreamBase<T>::size = length;
>X@@ -71,12 +83,6 @@
>X StringReader<T>::skip(int64_t ntoskip) {
>X     const T* start;
>X     return read(start, ntoskip, ntoskip);
>X-}
>X-template <class T>
>X-int64_t
>X-StringReader<T>::mark(int32_t /*readlimit*/) {
>X-    markpt = StreamBase<T>::position;
>X-    return markpt;
>X }
>X template <class T>
>X int64_t
>cef0e34cbe7a4ddb8569b36b62ec1276
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_inputstreamreader.cpp
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_inputstreamreader.cpp << 'f26c57bd70267a2021920670efa00015'
>X--- src/CLucene/jstreams/inputstreamreader.cpp	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/inputstreamreader.cpp.orig	Fri Nov 24 13:42:02 2006
>X@@ -13,7 +13,7 @@
>X #ifndef ICONV_CONST
>X      //we try to guess whether the iconv function requires
>X      //a const char. We have no way of automatically figuring
>X-     //this out if we didnt use autoconf, so we guess based
>X+     //this out if we did not use autoconf, so we guess based
>X      //on certain parameters:
>X      #ifdef _LIBICONV_H
>X           #define ICONV_CONST const
>X@@ -49,7 +49,7 @@
>X         return;
>X     }
>X     charbuf.setSize(262);
>X-    mark(262);
>X+    //mark(262);
>X     charsLeft = 0;
>X }
>X InputStreamReader::~InputStreamReader() {
>X@@ -86,7 +86,7 @@
>X             nwritten = space;
>X             break;
>X         default:
>X-            exit(-1);
>X+            printf("InputStreamReader::error %d\n", errno);
>X         }
>X     } else { //input sequence was completely converted
>X         charbuf.readPos = charbuf.start;
>f26c57bd70267a2021920670efa00015
>echo x - clucene-contrib/files/patch-src_CLucene_analysis_cjk_CJKAnalyzer.cpp
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_analysis_cjk_CJKAnalyzer.cpp << 'dfb491023886e3520d1946e4ae5a0b72'
>X--- /work/a/ports/textproc/clucene-contrib/work/clucene-contrib-0.9.16a/src/CLucene/analysis/cjk/CJKAnalyzer.cpp.orig	2007-02-10 13:56:33.000000000 +0000
>X+++ /work/a/ports/textproc/clucene-contrib/work/clucene-contrib-0.9.16a/src/CLucene/analysis/cjk/CJKAnalyzer.cpp	2010-06-22 07:00:25.000000000 +0000
>X@@ -1,4 +1,5 @@
>X #include "CLucene/StdHeader.h"
>X+#include "CLucene/analysis/Analyzers.h"
>X #include "CJKAnalyzer.h"
>X 
>X CL_NS_DEF2(analysis,cjk)
>X@@ -180,4 +181,34 @@
>X 	return true;
>X }
>X 
>X+CJKAnalyzer::CJKAnalyzer() {
>X+    StopFilter::fillStopTable( &stopTable, CJKAnalyzer::STOP_WORDS);
>X+}
>X+
>X+CJKAnalyzer::CJKAnalyzer(const TCHAR** stopWords) {
>X+    StopFilter::fillStopTable(&stopTable, stopWords);
>X+}
>X+
>X+CJKAnalyzer::~CJKAnalyzer() {
>X+}
>X+
>X+const TCHAR* CJKAnalyzer::STOP_WORDS[]  = {
>X+    _T("a"), _T("and"), _T("are"), _T("as"), _T("at"), _T("be"),
>X+    _T("but"), _T("by"), _T("for"), _T("if"), _T("in"),
>X+    _T("into"), _T("is"), _T("it"), _T("no"), _T("not"),
>X+    _T("of"), _T("on"), _T("or"), _T("s"), _T("such"), _T("t"),
>X+    _T("that"), _T("the"), _T("their"), _T("then"),
>X+    _T("there"), _T("these"), _T("they"), _T("this"),
>X+    _T("to"), _T("was"), _T("will"), _T("with"),
>X+    _T("www"),
>X+    NULL
>X+};
>X+
>X+
>X+TokenStream* CJKAnalyzer::tokenStream(const TCHAR* fieldName, Reader* reader) {
>X+    TokenStream* ret = _CLNEW CJKTokenizer(reader);
>X+    ret = _CLNEW StopFilter(ret,true, &stopTable);
>X+    return ret;
>X+}
>X+
>X CL_NS_END2
>dfb491023886e3520d1946e4ae5a0b72
>echo x - clucene-contrib/files/patch-src_CLucene_highlighter_QueryTermExtractor.cpp
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_highlighter_QueryTermExtractor.cpp << 'ef685f8323c9ae628b6910434b559b28'
>X--- src/CLucene/highlighter/QueryTermExtractor.cpp	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/highlighter/QueryTermExtractor.cpp.orig	Mon Nov 20 13:35:09 2006
>X@@ -79,9 +79,9 @@
>X 
>X 	void QueryTermExtractor::getTermsFromBooleanQuery(const BooleanQuery * query, WeightedTermList * terms, bool prohibited)
>X 	{
>X-		// TODO: change Query to get the queryclauses and their number in one function call
>X-		BooleanClause** queryClauses = query->getClauses();
>X 		uint32_t numClauses = query->getClauseCount();
>X+		BooleanClause** queryClauses = _CL_NEWARRAY(BooleanClause*,numClauses);
>X+		query->getClauses(queryClauses);
>X 
>X 		for (uint32_t i = 0; i < numClauses; i++)
>X 		{
>ef685f8323c9ae628b6910434b559b28
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_filereader.cpp
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_filereader.cpp << 'c5b60685580e3f403f1b76c5f03c68d5'
>X--- src/CLucene/jstreams/filereader.cpp	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/filereader.cpp.orig	Sat Nov 25 11:03:58 2006
>X@@ -26,11 +26,6 @@
>X     return nread;
>X }
>X int64_t
>X-FileReader::mark(int32_t readlimit) {
>X-    int64_t mp = reader->mark(readlimit);
>X-    return mp;
>X-}
>X-int64_t
>X FileReader::reset(int64_t newpos) {
>X     position = reader->reset(newpos);
>X     if (position < -1) {
>c5b60685580e3f403f1b76c5f03c68d5
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_zipinputstream.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_zipinputstream.h << 'c2821f2813b04f7f47c55153db239dc0'
>X--- src/CLucene/jstreams/zipinputstream.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/zipinputstream.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -27,7 +27,6 @@
>X     // information relating to the current entry
>X     StreamBase<char>* compressedEntryStream;
>X     GZipInputStream *uncompressionStream;
>X-    StreamBase<char>* uncompressedEntryStream;
>X     int32_t entryCompressedSize;
>X     int32_t compressionMethod;
>X 
>X@@ -36,10 +35,13 @@
>X     static int32_t read2bytes(const unsigned char *b);
>X     static int32_t read4bytes(const unsigned char *b);
>X public:
>X-    ZipInputStream(StreamBase<char>* input);
>X+    explicit ZipInputStream(StreamBase<char>* input);
>X     ~ZipInputStream();
>X     StreamBase<char>* nextEntry();
>X     static bool checkHeader(const char* data, int32_t datasize);
>X+    static SubStreamProvider* factory(StreamBase<char>* input) {
>X+        return new ZipInputStream(input);
>X+    }
>X };
>X 
>X } // end namespace jstreams
>c2821f2813b04f7f47c55153db239dc0
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_bufferedstream.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_bufferedstream.h << '043bcb010e03118fa84149096c1dd77f'
>X--- src/CLucene/jstreams/bufferedstream.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/bufferedstream.h.orig	Sat Nov 25 11:03:58 2006
>X@@ -9,6 +9,7 @@
>X 
>X #include "streambase.h"
>X #include "inputstreambuffer.h"
>X+#include <cassert>
>X 
>X namespace jstreams {
>X 
>X@@ -32,10 +33,9 @@
>X     virtual int32_t fillBuffer(T* start, int32_t space) = 0;
>X     // this function might be useful if you want to reuse a bufferedstream
>X     void resetBuffer() {printf("implement 'resetBuffer'\n");}
>X-public:
>X     BufferedInputStream<T>();
>X+public:
>X     int32_t read(const T*& start, int32_t min, int32_t max);
>X-    int64_t mark(int32_t readlimit);
>X     int64_t reset(int64_t);
>X     virtual int64_t skip(int64_t ntoskip);
>X };
>X@@ -55,6 +55,7 @@
>X         space = buffer.makeSpace(missing);
>X         T* start = buffer.readPos + buffer.avail;
>X         nwritten = fillBuffer(start, space);
>X+        assert(StreamBase<T>::status != Eof);
>X         if (nwritten > 0) {
>X             buffer.avail += nwritten;
>X             missing = ntoread - buffer.avail;
>X@@ -75,15 +76,9 @@
>X         // do we have enough space in the buffer?
>X         writeToBuffer(min);
>X         if (StreamBase<T>::status == Error) return -2;
>X-        if (StreamBase<T>::status == Eof) return -1;
>X     }
>X 
>X     int32_t nread = buffer.read(start, max);
>X-/*    if (nread == 0) {
>X-        printf("bis: start %p min %i max %i nread %i avail %i bsize %i pos %lli size %lli\n",
>X-        start, min, max, nread, buffer.avail, buffer.size, BufferedInputStream<T>::position, BufferedInputStream<T>::size);
>X-        printf("buf: start %p readpos %p marpos %p\n", buffer.start, buffer.readPos, buffer.markPos);
>X-    }*/
>X 
>X     BufferedInputStream<T>::position += nread;
>X     if (BufferedInputStream<T>::position > BufferedInputStream<T>::size
>X@@ -97,6 +92,9 @@
>X     } else if (BufferedInputStream<T>::status == Ok && buffer.avail == 0
>X             && finishedWritingToBuffer) {
>X         BufferedInputStream<T>::status = Eof;
>X+        if (BufferedInputStream<T>::size == -1) {
>X+            BufferedInputStream<T>::size = BufferedInputStream<T>::position;
>X+        }
>X         // save one call to read() by already returning -1 if no data is there
>X         if (nread == 0) nread = -1;
>X     }
>X@@ -104,13 +102,8 @@
>X }
>X template <class T>
>X int64_t
>X-BufferedInputStream<T>::mark(int32_t readlimit) {
>X-    buffer.mark(readlimit);
>X-    return StreamBase<T>::position;
>X-}
>X-template <class T>
>X-int64_t
>X BufferedInputStream<T>::reset(int64_t newpos) {
>X+    assert(newpos >= 0);
>X     if (StreamBase<T>::status == Error) return -2;
>X     // check to see if we have this position
>X     int64_t d = BufferedInputStream<T>::position - newpos;
>043bcb010e03118fa84149096c1dd77f
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_inputstreamreader.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_inputstreamreader.h << 'c0fd8025b0680eace759a3827aaa0f6d'
>X--- src/CLucene/jstreams/inputstreamreader.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/inputstreamreader.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -29,7 +29,7 @@
>X     void readFromStream();
>X     int32_t decode(wchar_t* start, int32_t space);
>X public:
>X-    InputStreamReader(StreamBase<char> *i, const char *enc=0);
>X+    explicit InputStreamReader(StreamBase<char> *i, const char *enc=0);
>X     ~InputStreamReader();
>X     int32_t fillBuffer(wchar_t* start, int32_t space);
>X };
>c0fd8025b0680eace759a3827aaa0f6d
>echo x - clucene-contrib/files/patch-src_CLucene_analysis_cjk_CJKAnalyzer.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_analysis_cjk_CJKAnalyzer.h << 'c564ed504362b247946c9878b5c54da6'
>X--- src/CLucene/analysis/cjk/CJKAnalyzer.h	Fri Aug  1 17:55:43 2008
>X+++ src/CLucene/analysis/cjk/CJKAnalyzer.h.orig	Tue May 27 17:41:14 2008
>X@@ -52,7 +52,7 @@
>X      * character buffer, store the characters which are used to compose <br>
>X      * the returned Token
>X      */
>X-    TCHAR buffer[LUCENE_MAX_WORD_LEN];
>X+    TCHAR buffer[LUCENE_MAX_WORD_LEN+1];
>X 
>X     /**
>X      * I/O buffer, used to store the content of the input(one of the <br>
>X@@ -102,6 +102,33 @@
>X };
>X 
>X 
>X+/** Represents a CJK analyzer.
>X+ *
>X+ *  Filters CJKTokenizer with StopFilter.
>X+ *
>X+ *  @author Che, Dong 
>X+ */
>X+ 
>X+class CJKAnalyzer : public CL_NS(analysis)::Analyzer
>X+{
>X+    private:
>X+        CL_NS(util)::CLSetList<const TCHAR*> stopTable;
>X+    public:
>X+        /** Builds an analyzer.*/
>X+        CJKAnalyzer();
>X+
>X+        /** Builds an analyzer with the given stop words. */
>X+        CJKAnalyzer(const TCHAR** stopWords);
>X+
>X+        ~CJKAnalyzer();
>X+
>X+        /** get token stream from input **/
>X+        CL_NS(analysis)::TokenStream* tokenStream(const TCHAR* fieldName, CL_NS(util)::Reader* reader);
>X+
>X+        /** An array containing some common English words that are not usually useful for
>X+            searching and some double-byte interpunctions. */
>X+        static const TCHAR* STOP_WORDS[];
>X+};
>X 
>X CL_NS_END2
>X #endif
>c564ed504362b247946c9878b5c54da6
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_filereader.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_filereader.h << 'f1a213cb3dbb143a53b301114c7fe596'
>X--- src/CLucene/jstreams/filereader.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/filereader.h.orig	Sat Nov 25 11:03:58 2006
>X@@ -11,12 +11,11 @@
>X     FileInputStream* input;
>X     InputStreamReader* reader;
>X public:
>X-    FileReader(const char* fname, const char* encoding_scheme=NULL,
>X+    explicit FileReader(const char* fname, const char* encoding_scheme=NULL,
>X         const int32_t cachelen = 13,
>X         const int32_t cachebuff = 14 );
>X     ~FileReader();
>X     int32_t read(const wchar_t*& start, int32_t min, int32_t max);
>X-    int64_t mark(int32_t readlimit);
>X     int64_t reset(int64_t);
>X };
>X 
>f1a213cb3dbb143a53b301114c7fe596
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_inputstreambuffer.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_inputstreambuffer.h << 'bc945f00994300dd6b7477d4015f2394'
>X--- src/CLucene/jstreams/inputstreambuffer.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/inputstreambuffer.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -19,14 +19,10 @@
>X     int32_t size;
>X     T* readPos;
>X     int32_t avail;
>X-    T* markPos;
>X-    int32_t markLimit;
>X 
>X     InputStreamBuffer();
>X     ~InputStreamBuffer();
>X     void setSize(int32_t size);
>X-    void mark(int32_t readlimit);
>X-    void reset();
>X     int32_t read(const T*& start, int32_t max=0);
>X 
>X     /**
>X@@ -38,7 +34,7 @@
>X 
>X template <class T>
>X InputStreamBuffer<T>::InputStreamBuffer() {
>X-    markPos = readPos = start = 0;
>X+    readPos = start = 0;
>X     size = avail = 0;
>X }
>X template <class T>
>X@@ -50,7 +46,6 @@
>X InputStreamBuffer<T>::setSize(int32_t size) {
>X     // store pointer information
>X     int32_t offset = readPos - start;
>X-    int32_t markOffset = (markPos) ? markPos - start : -1;
>X 
>X     // allocate memory in the buffer
>X     start = (T*)realloc(start, size*sizeof(T));
>X@@ -58,52 +53,6 @@
>X 
>X     // restore pointer information
>X     readPos = start + offset;
>X-    markPos = (markOffset == -1) ?0 :start + markOffset;
>X-}
>X-template <class T>
>X-void
>X-InputStreamBuffer<T>::mark(int32_t limit) {
>X-    // if there's no buffer yet, allocate one now
>X-    if (start == 0) {
>X-        setSize(limit+1);
>X-    }
>X-    // if we had a larger limit defined for the same position, do nothing
>X-    if (readPos == markPos && limit <= markLimit) {
>X-        return;
>X-    }
>X-            
>X-    markLimit = limit;
>X-    // if we have enough room, only set the mark
>X-    int32_t offset = readPos - start;
>X-    if (size - offset >= limit) {
>X-        markPos = readPos;
>X-        return;
>X-    }
>X-
>X-    // if we don't have enough room start by
>X-    // moving memory to the start of the buffer
>X-    if (readPos != start) {
>X-        memmove(start, readPos, avail*sizeof(T));
>X-        readPos = start;
>X-    }
>X-
>X-    // if we have enough room now, finish
>X-    if (size >= limit) {
>X-        markPos = readPos;
>X-        return;
>X-    }
>X-
>X-    // last resort: increase buffer size
>X-    setSize(limit+1);
>X-    markPos = readPos;
>X-}
>X-template <class T>
>X-void
>X-InputStreamBuffer<T>::reset() {
>X-    if (markPos != 0) {
>X-        avail += readPos - markPos;
>X-        readPos = markPos;
>X-    }
>X }
>X template <class T>
>X int32_t
>X@@ -115,28 +64,16 @@
>X         return space;
>X     }
>X 
>X-    if (markPos && readPos - markPos <= markLimit) {
>X-        // move data to the start of the buffer while respecting the set mark
>X-        if (markPos != start) {
>X-//            printf("moving with mark\n");
>X-            int32_t n = avail + readPos - markPos;
>X-            memmove(start, markPos, n*sizeof(T));
>X-            readPos -= markPos - start;
>X-            space += markPos - start;
>X-            markPos = start;
>X-        }
>X-    } else if (avail) {
>X+    if (avail) {
>X         if (readPos != start) {
>X //            printf("moving\n");
>X             // move data to the start of the buffer
>X             memmove(start, readPos, avail*sizeof(T));
>X             space += readPos - start;
>X             readPos = start;
>X-            markPos = 0;
>X         }
>X     } else {
>X         // we may start writing at the start of the buffer
>X-        markPos = 0;
>X         readPos = start;
>X         space = size;
>X     }
>bc945f00994300dd6b7477d4015f2394
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_gzipinputstream.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_gzipinputstream.h << '037da4ef114feaa8cd77d724fdac6bc2'
>X--- src/CLucene/jstreams/gzipinputstream.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/gzipinputstream.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -24,7 +24,8 @@
>X     bool checkMagic();
>X public:
>X     enum ZipFormat { ZLIBFORMAT, GZIPFORMAT, ZIPFORMAT};
>X-    GZipInputStream(StreamBase<char>* input, ZipFormat format=GZIPFORMAT);
>X+    explicit GZipInputStream(StreamBase<char>* input,
>X+        ZipFormat format=GZIPFORMAT);
>X     ~GZipInputStream();
>X     int32_t fillBuffer(char* start, int32_t space);
>X };
>037da4ef114feaa8cd77d724fdac6bc2
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_fileinputstream.cpp
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_fileinputstream.cpp << 'e713db587153aab003573414ebb0744b'
>X--- src/CLucene/jstreams/fileinputstream.cpp	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/fileinputstream.cpp.orig	Fri Nov 24 13:42:02 2006
>X@@ -12,7 +12,6 @@
>X 
>X const int32_t FileInputStream::defaultBufferSize = 1048576;
>X FileInputStream::FileInputStream(const char *filepath, int32_t buffersize) {
>X-
>X     // try to open the file for reading
>X     file = fopen(filepath, "rb");
>X     this->filepath = filepath;
>X@@ -21,7 +20,7 @@
>X         error = "Could not read file '";
>X         error += filepath;
>X         error += "': ";
>X-	error += strerror(errno);
>X+        error += strerror(errno);
>X         status = Error;
>X         return;
>X     }
>X@@ -47,7 +46,8 @@
>X     }
>X 
>X     // allocate memory in the buffer
>X-    mark(buffersize);
>X+    int32_t bufsize = (size <= buffersize) ?size+1 :buffersize;
>X+    mark(bufsize);
>X }
>X FileInputStream::~FileInputStream() {
>X     if (file) {
>e713db587153aab003573414ebb0744b
>echo x - clucene-contrib/files/patch-src_CLucene_jstreams_fileinputstream.h
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_jstreams_fileinputstream.h << '0e68f4bd175f3ea2fa2bcd21f9b767de'
>X--- src/CLucene/jstreams/fileinputstream.h	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/jstreams/fileinputstream.h.orig	Fri Nov 24 13:42:02 2006
>X@@ -18,7 +18,8 @@
>X 
>X public:
>X     static const int32_t defaultBufferSize;
>X-    FileInputStream(const char *filepath, int32_t buffersize=defaultBufferSize);
>X+    explicit FileInputStream(const char *filepath,
>X+        int32_t buffersize=defaultBufferSize);
>X     ~FileInputStream();
>X     int32_t fillBuffer(char* start, int32_t space);
>X };
>0e68f4bd175f3ea2fa2bcd21f9b767de
>echo x - clucene-contrib/files/patch-src_CLucene_analysis_Makefile.am
>sed 's/^X//' >clucene-contrib/files/patch-src_CLucene_analysis_Makefile.am << 'b2757d491e6384e9e3df0addbdd4ac18'
>X--- src/CLucene/analysis/Makefile.am	Sat Feb 10 13:56:34 2007
>X+++ src/CLucene/analysis/Makefile.am.orig	Tue Dec  5 09:55:45 2006
>X@@ -2,6 +2,7 @@
>X analysisdir = $(lsrcdir)/analysis
>X analysishdir = $(includedir)/CLucene/analysis
>X  
>X+libclucene_contrib_la_SOURCES  += $(analysisdir)/LanguageBasedAnalyzer.cpp
>X libclucene_contrib_la_SOURCES  += $(analysisdir)/PorterStemmer.cpp
>X 
>X analysish_HEADERS = $(analysisdir)/*.h
>b2757d491e6384e9e3df0addbdd4ac18
>echo x - clucene-contrib/distinfo
>sed 's/^X//' >clucene-contrib/distinfo << '867032b7736936cd5ebdf5660f138123'
>XMD5 (clucene-contrib-0.9.16a.tar.bz2) = e521d56c8cade9db46e7709729412c0a 
>XSHA256 (clucene-contrib-0.9.16a.tar.bz2) = 5d0615ec2eda48366d248f84b402db4cfc5d7c65d0eafd2075babf778f41f3aa
>XSIZE (clucene-contrib-0.9.16a.tar.bz2) = 1304048
>867032b7736936cd5ebdf5660f138123
>echo x - clucene-contrib/pkg-descr
>sed 's/^X//' >clucene-contrib/pkg-descr << 'f61bcff486745a4410bc4c70674e8314'
>XCLucene is a C++ port of Lucene: the high-performance, 
>Xfull-featured text search engine written in Java. 
>XCLucene is faster than lucene as it is written in C++.
>X
>XWWW:	http://sourceforge.net/projects/clucene/
>f61bcff486745a4410bc4c70674e8314
>echo x - clucene-contrib/pkg-plist
>sed 's/^X//' >clucene-contrib/pkg-plist << '0d1636fd909061ccd662e0d377158108'
>Xinclude/CLucene/analysis/PorterStemmer.h
>Xinclude/CLucene/analysis/cjk/CJKAnalyzer.h
>Xinclude/CLucene/highlighter/Encoder.h
>Xinclude/CLucene/highlighter/Formatter.h
>Xinclude/CLucene/highlighter/Fragmenter.h
>Xinclude/CLucene/highlighter/HighlightScorer.h
>Xinclude/CLucene/highlighter/Highlighter.h
>Xinclude/CLucene/highlighter/QueryScorer.h
>Xinclude/CLucene/highlighter/QueryTermExtractor.h
>Xinclude/CLucene/highlighter/Scorer.h
>Xinclude/CLucene/highlighter/SimpleFragmenter.h
>Xinclude/CLucene/highlighter/SimpleHTMLEncoder.h
>Xinclude/CLucene/highlighter/SimpleHTMLFormatter.h
>Xinclude/CLucene/highlighter/TextFragment.h
>Xinclude/CLucene/highlighter/TokenGroup.h
>Xinclude/CLucene/highlighter/TokenSources.h
>Xinclude/CLucene/highlighter/WeightedTerm.h
>Xinclude/CLucene/jstreams/Reader.h
>Xinclude/CLucene/jstreams/bufferedstream.h
>Xinclude/CLucene/jstreams/bz2inputstream.h
>Xinclude/CLucene/jstreams/dostime.h
>Xinclude/CLucene/jstreams/fileinputstream.h
>Xinclude/CLucene/jstreams/filereader.h
>Xinclude/CLucene/jstreams/gzipinputstream.h
>Xinclude/CLucene/jstreams/inputstream.h
>Xinclude/CLucene/jstreams/inputstreambuffer.h
>Xinclude/CLucene/jstreams/inputstreamreader.h
>Xinclude/CLucene/jstreams/jstreamsconfig.h
>Xinclude/CLucene/jstreams/streambase.h
>Xinclude/CLucene/jstreams/streamreader.h
>Xinclude/CLucene/jstreams/stringreader.h
>Xinclude/CLucene/jstreams/subinputstream.h
>Xinclude/CLucene/jstreams/substreamprovider.h
>Xinclude/CLucene/jstreams/tarinputstream.h
>Xinclude/CLucene/jstreams/zipinputstream.h
>Xinclude/CLucene/snowball/SnowballAnalyzer.h
>Xinclude/CLucene/snowball/SnowballFilter.h
>Xinclude/CLucene/snowball/include/libstemmer.h
>Xinclude/CLucene/snowball/libstemmer.h
>Xinclude/CLucene/snowball/libstemmer/modules.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_danish.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_dutch.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_english.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_finnish.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_french.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_german.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_italian.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_norwegian.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_porter.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_portuguese.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_spanish.h
>Xinclude/CLucene/snowball/libstemmer/stem_ISO_8859_1_swedish.h
>Xinclude/CLucene/snowball/libstemmer/stem_KOI8_R_russian.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_danish.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_dutch.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_english.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_finnish.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_french.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_german.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_italian.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_norwegian.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_porter.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_portuguese.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_russian.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_spanish.h
>Xinclude/CLucene/snowball/libstemmer/stem_UTF_8_swedish.h
>Xinclude/CLucene/snowball/runtime/api.h
>Xinclude/CLucene/snowball/runtime/header.h
>Xlib/CLucene/clucene-config-contrib.h
>Xlib/libclucene-contrib.a
>Xlib/libclucene-contrib.la
>Xlib/libclucene-contrib.so
>Xlib/libclucene-contrib.so.0
>X@dirrm include/CLucene/snowball/runtime
>X@dirrm include/CLucene/snowball/libstemmer
>X@dirrm include/CLucene/snowball/include
>X@dirrm include/CLucene/snowball
>X@dirrm include/CLucene/jstreams
>X@dirrm include/CLucene/highlighter
>X@dirrm include/CLucene/analysis/cjk
>0d1636fd909061ccd662e0d377158108
>echo x - clucene-contrib/Makefile
>sed 's/^X//' >clucene-contrib/Makefile << '5c840af6376c9d035b924c56b5c65a5a'
>X# New ports collection makefile for:	clucene-contrib
>X# Date created:				2010-10-4
>X# Whom:					Tom Judge <tom@tomjudge.com>
>X#
>X# $FreeBSD$
>X#
>X
>XPORTNAME=	clucene-contrib
>XPORTVERSION=	0.9.16a
>XCATEGORIES=	textproc
>XMASTER_SITES=	SF/clucene/clucene-contribs-unstable/${PORTVERSION}
>XDISTNAME=	${PORTNAME}-${PORTVERSION}
>X
>XMAINTAINER=	tom@tomjudge.com
>XCOMMENT=	CLucene Contrib Code and Tools
>X
>XLIB_DEPENDS=	clucene.0:${PORTSDIR}/textproc/clucene
>XBUILD_DEPENDS=	${LOCALBASE}/include/iconv.h:${PORTSDIR}/converters/libiconv
>X
>XGNU_CONFIGURE=	yes
>XUSE_BZIP2=	yes
>XUSE_LDCONFIG=	yes
>XUSE_AUTOTOOLS=	libtool:22
>XUSE_DOS2UNIX=	yes
>X
>X.include <bsd.port.pre.mk>
>X
>X.if defined(WITH_ASCII_SUPPORT)
>XCONFIGURE_ARGS+=	--enable-ascii
>X.endif
>X
>X.include <bsd.port.post.mk>
>5c840af6376c9d035b924c56b5c65a5a
>exit

Actions: View

Attachments on bug 151951: 110754