summaryrefslogtreecommitdiff
path: root/db/mork/src/morkStream.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'db/mork/src/morkStream.cpp')
-rw-r--r--db/mork/src/morkStream.cpp859
1 files changed, 859 insertions, 0 deletions
diff --git a/db/mork/src/morkStream.cpp b/db/mork/src/morkStream.cpp
new file mode 100644
index 0000000000..26c6f443e5
--- /dev/null
+++ b/db/mork/src/morkStream.cpp
@@ -0,0 +1,859 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef _MDB_
+#include "mdb.h"
+#endif
+
+#ifndef _MORK_
+#include "mork.h"
+#endif
+
+#ifndef _MORKNODE_
+#include "morkNode.h"
+#endif
+
+#ifndef _MORKFILE_
+#include "morkFile.h"
+#endif
+
+#ifndef _MORKENV_
+#include "morkEnv.h"
+#endif
+
+#ifndef _MORKSTREAM_
+#include "morkStream.h"
+#endif
+
+//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
+
+// ````` ````` ````` ````` `````
+// { ===== begin morkNode interface =====
+
+/*public virtual*/ void
+morkStream::CloseMorkNode(morkEnv* ev) // CloseStream() only if open
+{
+ if ( this->IsOpenNode() )
+ {
+ this->MarkClosing();
+ this->CloseStream(ev);
+ this->MarkShut();
+ }
+}
+
+/*public virtual*/
+morkStream::~morkStream() // assert CloseStream() executed earlier
+{
+ MORK_ASSERT(mStream_ContentFile==0);
+ MORK_ASSERT(mStream_Buf==0);
+}
+
+/*public non-poly*/
+morkStream::morkStream(morkEnv* ev, const morkUsage& inUsage,
+ nsIMdbHeap* ioHeap,
+ nsIMdbFile* ioContentFile, mork_size inBufSize, mork_bool inFrozen)
+: morkFile(ev, inUsage, ioHeap, ioHeap)
+, mStream_At( 0 )
+, mStream_ReadEnd( 0 )
+, mStream_WriteEnd( 0 )
+
+, mStream_ContentFile( 0 )
+
+, mStream_Buf( 0 )
+, mStream_BufSize( inBufSize )
+, mStream_BufPos( 0 )
+, mStream_Dirty( morkBool_kFalse )
+, mStream_HitEof( morkBool_kFalse )
+{
+ if ( ev->Good() )
+ {
+ if ( inBufSize < morkStream_kMinBufSize )
+ mStream_BufSize = inBufSize = morkStream_kMinBufSize;
+ else if ( inBufSize > morkStream_kMaxBufSize )
+ mStream_BufSize = inBufSize = morkStream_kMaxBufSize;
+
+ if ( ioContentFile && ioHeap )
+ {
+ // if ( ioContentFile->FileFrozen() ) // forced to be readonly?
+ // inFrozen = morkBool_kTrue; // override the input value
+
+ nsIMdbFile_SlotStrongFile(ioContentFile, ev, &mStream_ContentFile);
+ if ( ev->Good() )
+ {
+ mork_u1* buf = 0;
+ ioHeap->Alloc(ev->AsMdbEnv(), inBufSize, (void**) &buf);
+ if ( buf )
+ {
+ mStream_At = mStream_Buf = buf;
+
+ if ( !inFrozen )
+ {
+ // physical buffer end never moves:
+ mStream_WriteEnd = buf + inBufSize;
+ }
+ else
+ mStream_WriteEnd = 0; // no writing is allowed
+
+ if ( inFrozen )
+ {
+ // logical buffer end starts at Buf with no content:
+ mStream_ReadEnd = buf;
+ this->SetFileFrozen(inFrozen);
+ }
+ else
+ mStream_ReadEnd = 0; // no reading is allowed
+
+ this->SetFileActive(morkBool_kTrue);
+ this->SetFileIoOpen(morkBool_kTrue);
+ }
+ if ( ev->Good() )
+ mNode_Derived = morkDerived_kStream;
+ }
+ }
+ else ev->NilPointerError();
+ }
+}
+
+/*public non-poly*/ void
+morkStream::CloseStream(morkEnv* ev) // called by CloseMorkNode();
+{
+ if ( this->IsNode() )
+ {
+ nsIMdbFile_SlotStrongFile((nsIMdbFile*) 0, ev, &mStream_ContentFile);
+ nsIMdbHeap* heap = mFile_SlotHeap;
+ mork_u1* buf = mStream_Buf;
+ mStream_Buf = 0;
+
+ if ( heap && buf )
+ heap->Free(ev->AsMdbEnv(), buf);
+
+ this->CloseFile(ev);
+ this->MarkShut();
+ }
+ else
+ this->NonNodeError(ev);
+}
+
+// } ===== end morkNode methods =====
+// ````` ````` ````` ````` `````
+
+#define morkStream_kSpacesPerIndent 1 /* one space per indent */
+#define morkStream_kMaxIndentDepth 70 /* max indent of 70 space bytes */
+static const char morkStream_kSpaces[] // next line to ease length perception
+= " ";
+// 123456789_123456789_123456789_123456789_123456789_123456789_123456789_
+// morkStream_kSpaces above must contain (at least) 70 spaces (ASCII 0x20)
+
+mork_size
+morkStream::PutIndent(morkEnv* ev, mork_count inDepth)
+ // PutIndent() puts a linebreak, and then
+ // "indents" by inDepth, and returns the line length after indentation.
+{
+ mork_size outLength = 0;
+ nsIMdbEnv *mev = ev->AsMdbEnv();
+ if ( ev->Good() )
+ {
+ this->PutLineBreak(ev);
+ if ( ev->Good() )
+ {
+ outLength = inDepth;
+ mdb_size bytesWritten;
+ if ( inDepth )
+ this->Write(mev, morkStream_kSpaces, inDepth, &bytesWritten);
+ }
+ }
+ return outLength;
+}
+
+mork_size
+morkStream::PutByteThenIndent(morkEnv* ev, int inByte, mork_count inDepth)
+ // PutByteThenIndent() puts the byte, then a linebreak, and then
+ // "indents" by inDepth, and returns the line length after indentation.
+{
+ mork_size outLength = 0;
+ nsIMdbEnv *mev = ev->AsMdbEnv();
+
+ if ( inDepth > morkStream_kMaxIndentDepth )
+ inDepth = morkStream_kMaxIndentDepth;
+
+ this->Putc(ev, inByte);
+ if ( ev->Good() )
+ {
+ this->PutLineBreak(ev);
+ if ( ev->Good() )
+ {
+ outLength = inDepth;
+ mdb_size bytesWritten;
+ if ( inDepth )
+ this->Write(mev, morkStream_kSpaces, inDepth, &bytesWritten);
+ }
+ }
+ return outLength;
+}
+
+mork_size
+morkStream::PutStringThenIndent(morkEnv* ev,
+ const char* inString, mork_count inDepth)
+// PutStringThenIndent() puts the string, then a linebreak, and then
+// "indents" by inDepth, and returns the line length after indentation.
+{
+ mork_size outLength = 0;
+ mdb_size bytesWritten;
+ nsIMdbEnv *mev = ev->AsMdbEnv();
+
+ if ( inDepth > morkStream_kMaxIndentDepth )
+ inDepth = morkStream_kMaxIndentDepth;
+
+ if ( inString )
+ {
+ mork_size length = MORK_STRLEN(inString);
+ if ( length && ev->Good() ) // any bytes to write?
+ this->Write(mev, inString, length, &bytesWritten);
+ }
+
+ if ( ev->Good() )
+ {
+ this->PutLineBreak(ev);
+ if ( ev->Good() )
+ {
+ outLength = inDepth;
+ if ( inDepth )
+ this->Write(mev, morkStream_kSpaces, inDepth, &bytesWritten);
+ }
+ }
+ return outLength;
+}
+
+mork_size
+morkStream::PutString(morkEnv* ev, const char* inString)
+{
+ nsIMdbEnv *mev = ev->AsMdbEnv();
+ mork_size outSize = 0;
+ mdb_size bytesWritten;
+ if ( inString )
+ {
+ outSize = MORK_STRLEN(inString);
+ if ( outSize && ev->Good() ) // any bytes to write?
+ {
+ this->Write(mev, inString, outSize, &bytesWritten);
+ }
+ }
+ return outSize;
+}
+
+mork_size
+morkStream::PutStringThenNewline(morkEnv* ev, const char* inString)
+ // PutStringThenNewline() returns total number of bytes written.
+{
+ nsIMdbEnv *mev = ev->AsMdbEnv();
+ mork_size outSize = 0;
+ mdb_size bytesWritten;
+ if ( inString )
+ {
+ outSize = MORK_STRLEN(inString);
+ if ( outSize && ev->Good() ) // any bytes to write?
+ {
+ this->Write(mev, inString, outSize, &bytesWritten);
+ if ( ev->Good() )
+ outSize += this->PutLineBreak(ev);
+ }
+ }
+ return outSize;
+}
+
+mork_size
+morkStream::PutByteThenNewline(morkEnv* ev, int inByte)
+ // PutByteThenNewline() returns total number of bytes written.
+{
+ mork_size outSize = 1; // one for the following byte
+ this->Putc(ev, inByte);
+ if ( ev->Good() )
+ outSize += this->PutLineBreak(ev);
+ return outSize;
+}
+
+mork_size
+morkStream::PutLineBreak(morkEnv* ev)
+{
+#if defined(MORK_MAC)
+
+ this->Putc(ev, mork_kCR);
+ return 1;
+
+#else
+# if defined(MORK_WIN)
+
+ this->Putc(ev, mork_kCR);
+ this->Putc(ev, mork_kLF);
+ return 2;
+
+# else
+# ifdef MORK_UNIX
+
+ this->Putc(ev, mork_kLF);
+ return 1;
+
+# endif /* MORK_UNIX */
+# endif /* MORK_WIN */
+#endif /* MORK_MAC */
+}
+// ````` ````` ````` ````` ````` ````` ````` `````
+// public: // virtual morkFile methods
+
+
+NS_IMETHODIMP
+morkStream::Steal(nsIMdbEnv* mev, nsIMdbFile* ioThief)
+ // Steal: tell this file to close any associated i/o stream in the file
+ // system, because the file ioThief intends to reopen the file in order
+ // to provide the MDB implementation with more exotic file access than is
+ // offered by the nsIMdbFile alone. Presumably the thief knows enough
+ // from Path() in order to know which file to reopen. If Steal() is
+ // successful, this file should probably delegate all future calls to
+ // the nsIMdbFile interface down to the thief files, so that even after
+ // the file has been stolen, it can still be read, written, or forcibly
+ // closed (by a call to CloseMdbObject()).
+{
+ MORK_USED_1(ioThief);
+ morkEnv *ev = morkEnv::FromMdbEnv(mev);
+ ev->StubMethodOnlyError();
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkStream::BecomeTrunk(nsIMdbEnv* mev)
+ // If this file is a file version branch created by calling AcquireBud(),
+ // BecomeTrunk() causes this file's content to replace the original
+ // file's content, typically by assuming the original file's identity.
+{
+ morkEnv *ev = morkEnv::FromMdbEnv(mev);
+ ev->StubMethodOnlyError();
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+morkStream::AcquireBud(nsIMdbEnv* mev, nsIMdbHeap* ioHeap, nsIMdbFile **acqBud)
+ // AcquireBud() starts a new "branch" version of the file, empty of content,
+ // so that a new version of the file can be written. This new file
+ // can later be told to BecomeTrunk() the original file, so the branch
+ // created by budding the file will replace the original file. Some
+ // file subclasses might initially take the unsafe but expedient
+ // approach of simply truncating this file down to zero length, and
+ // then returning the same morkFile pointer as this, with an extra
+ // reference count increment. Note that the caller of AcquireBud() is
+ // expected to eventually call CutStrongRef() on the returned file
+ // in order to release the strong reference. High quality versions
+ // of morkFile subclasses will create entirely new files which later
+ // are renamed to become the old file, so that better transactional
+ // behavior is exhibited by the file, so crashes protect old files.
+ // Note that AcquireBud() is an illegal operation on readonly files.
+{
+ MORK_USED_1(ioHeap);
+ morkFile* outFile = 0;
+ nsIMdbFile* file = mStream_ContentFile;
+ morkEnv *ev = morkEnv::FromMdbEnv(mev);
+ if ( this->IsOpenAndActiveFile() && file )
+ {
+ // figure out how this interacts with buffering and mStream_WriteEnd:
+ ev->StubMethodOnlyError();
+ }
+ else this->NewFileDownError(ev);
+
+ *acqBud = outFile;
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+mork_pos
+morkStream::Length(morkEnv* ev) const // eof
+{
+ mork_pos outPos = 0;
+
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenAndActiveFile() && file )
+ {
+ mork_pos contentEof = 0;
+ file->Eof(ev->AsMdbEnv(), &contentEof);
+ if ( ev->Good() )
+ {
+ if ( mStream_WriteEnd ) // this stream supports writing?
+ {
+ // the local buffer might have buffered content past content eof
+ if ( ev->Good() ) // no error happened during Length() above?
+ {
+ mork_u1* at = mStream_At;
+ mork_u1* buf = mStream_Buf;
+ if ( at >= buf ) // expected cursor order?
+ {
+ mork_pos localContent = mStream_BufPos + (at - buf);
+ if ( localContent > contentEof ) // buffered past eof?
+ contentEof = localContent; // return new logical eof
+
+ outPos = contentEof;
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+ }
+ else
+ outPos = contentEof; // frozen files get length from content file
+ }
+ }
+ else this->NewFileDownError(ev);
+
+ return outPos;
+}
+
+void morkStream::NewBadCursorSlotsError(morkEnv* ev) const
+{ ev->NewError("bad stream cursor slots"); }
+
+void morkStream::NewNullStreamBufferError(morkEnv* ev) const
+{ ev->NewError("null stream buffer"); }
+
+void morkStream::NewCantReadSinkError(morkEnv* ev) const
+{ ev->NewError("cant read stream sink"); }
+
+void morkStream::NewCantWriteSourceError(morkEnv* ev) const
+{ ev->NewError("cant write stream source"); }
+
+void morkStream::NewPosBeyondEofError(morkEnv* ev) const
+{ ev->NewError("stream pos beyond eof"); }
+
+void morkStream::NewBadCursorOrderError(morkEnv* ev) const
+{ ev->NewError("bad stream cursor order"); }
+
+NS_IMETHODIMP
+morkStream::Tell(nsIMdbEnv* mdbev, mork_pos *aOutPos) const
+{
+ nsresult rv = NS_OK;
+ morkEnv *ev = morkEnv::FromMdbEnv(mdbev);
+
+ NS_ENSURE_ARG_POINTER(aOutPos);
+
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenAndActiveFile() && file )
+ {
+ mork_u1* buf = mStream_Buf;
+ mork_u1* at = mStream_At;
+
+ mork_u1* readEnd = mStream_ReadEnd; // nonzero only if readonly
+ mork_u1* writeEnd = mStream_WriteEnd; // nonzero only if writeonly
+
+ if ( writeEnd )
+ {
+ if ( buf && at >= buf && at <= writeEnd )
+ {
+ *aOutPos = mStream_BufPos + (at - buf);
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+ else if ( readEnd )
+ {
+ if ( buf && at >= buf && at <= readEnd )
+ {
+ *aOutPos = mStream_BufPos + (at - buf);
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+ }
+ else this->NewFileDownError(ev);
+
+ return rv;
+}
+
+NS_IMETHODIMP
+morkStream::Read(nsIMdbEnv* mdbev, void* outBuf, mork_size inSize, mork_size *aOutSize)
+{
+ NS_ENSURE_ARG_POINTER(aOutSize);
+ // First we satisfy the request from buffered bytes, if any. Then
+ // if additional bytes are needed, we satisfy these by direct reads
+ // from the content file without any local buffering (but we still need
+ // to adjust the buffer position to reflect the current i/o point).
+
+ morkEnv *ev = morkEnv::FromMdbEnv(mdbev);
+ nsresult rv = NS_OK;
+
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenAndActiveFile() && file )
+ {
+ mork_u1* end = mStream_ReadEnd; // byte after last buffered byte
+ if ( end ) // file is open for read access?
+ {
+ if ( inSize ) // caller wants any output?
+ {
+ mork_u1* sink = (mork_u1*) outBuf; // where we plan to write bytes
+ if ( sink ) // caller passed good buffer address?
+ {
+ mork_u1* at = mStream_At;
+ mork_u1* buf = mStream_Buf;
+ if ( at >= buf && at <= end ) // expected cursor order?
+ {
+ mork_num remaining = (mork_num) (end - at); // bytes left in buffer
+
+ mork_num quantum = inSize; // number of bytes to copy
+ if ( quantum > remaining ) // more than buffer content?
+ quantum = remaining; // restrict to buffered bytes
+
+ if ( quantum ) // any bytes left in the buffer?
+ {
+ MORK_MEMCPY(sink, at, quantum); // from buffer bytes
+
+ at += quantum; // advance past read bytes
+ mStream_At = at;
+ *aOutSize += quantum; // this much copied so far
+
+ sink += quantum; // in case we need to copy more
+ inSize -= quantum; // filled this much of request
+ mStream_HitEof = morkBool_kFalse;
+ }
+
+ if ( inSize ) // we still need to read more content?
+ {
+ // We need to read more bytes directly from the
+ // content file, without local buffering. We have
+ // exhausted the local buffer, so we need to show
+ // it is now empty, and adjust the current buf pos.
+
+ mork_num posDelta = (mork_num) (at - buf); // old buf content
+ mStream_BufPos += posDelta; // past now empty buf
+
+ mStream_At = mStream_ReadEnd = buf; // empty buffer
+
+ // file->Seek(ev, mStream_BufPos); // set file pos
+ // if ( ev->Good() ) // no seek error?
+ // {
+ // }
+
+ mork_num actual = 0;
+ nsIMdbEnv* menv = ev->AsMdbEnv();
+ file->Get(menv, sink, inSize, mStream_BufPos, &actual);
+ if ( ev->Good() ) // no read error?
+ {
+ if ( actual )
+ {
+ *aOutSize += actual;
+ mStream_BufPos += actual;
+ mStream_HitEof = morkBool_kFalse;
+ }
+ else if ( !*aOutSize )
+ mStream_HitEof = morkBool_kTrue;
+ }
+ }
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+ else this->NewNullStreamBufferError(ev);
+ }
+ }
+ else this->NewCantReadSinkError(ev);
+ }
+ else this->NewFileDownError(ev);
+
+ if ( ev->Bad() )
+ *aOutSize = 0;
+
+ return rv;
+}
+
+NS_IMETHODIMP
+morkStream::Seek(nsIMdbEnv * mdbev, mork_pos inPos, mork_pos *aOutPos)
+{
+ NS_ENSURE_ARG_POINTER(aOutPos);
+ morkEnv *ev = morkEnv::FromMdbEnv(mdbev);
+ *aOutPos = 0;
+ nsresult rv = NS_OK;
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenOrClosingNode() && this->FileActive() && file )
+ {
+ mork_u1* at = mStream_At; // current position in buffer
+ mork_u1* buf = mStream_Buf; // beginning of buffer
+ mork_u1* readEnd = mStream_ReadEnd; // nonzero only if readonly
+ mork_u1* writeEnd = mStream_WriteEnd; // nonzero only if writeonly
+
+ if ( writeEnd ) // file is mutable/writeonly?
+ {
+ if ( mStream_Dirty ) // need to commit buffer changes?
+ this->Flush(mdbev);
+
+ if ( ev->Good() ) // no errors during flush or earlier?
+ {
+ if ( at == buf ) // expected post flush cursor value?
+ {
+ if ( mStream_BufPos != inPos ) // need to change pos?
+ {
+ mork_pos eof = 0;
+ nsIMdbEnv* menv = ev->AsMdbEnv();
+ file->Eof(menv, &eof);
+ if ( ev->Good() ) // no errors getting length?
+ {
+ if ( inPos <= eof ) // acceptable new position?
+ {
+ mStream_BufPos = inPos; // new stream position
+ *aOutPos = inPos;
+ }
+ else this->NewPosBeyondEofError(ev);
+ }
+ }
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+ }
+ else if ( readEnd ) // file is frozen/readonly?
+ {
+ if ( at >= buf && at <= readEnd ) // expected cursor order?
+ {
+ mork_pos eof = 0;
+ nsIMdbEnv* menv = ev->AsMdbEnv();
+ file->Eof(menv, &eof);
+ if ( ev->Good() ) // no errors getting length?
+ {
+ if ( inPos <= eof ) // acceptable new position?
+ {
+ *aOutPos = inPos;
+ mStream_BufPos = inPos; // new stream position
+ mStream_At = mStream_ReadEnd = buf; // empty buffer
+ if ( inPos == eof ) // notice eof reached?
+ mStream_HitEof = morkBool_kTrue;
+ }
+ else this->NewPosBeyondEofError(ev);
+ }
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+
+ }
+ else this->NewFileDownError(ev);
+
+ return rv;
+}
+
+NS_IMETHODIMP
+morkStream::Write(nsIMdbEnv* menv, const void* inBuf, mork_size inSize, mork_size *aOutSize)
+{
+ mork_num outActual = 0;
+ morkEnv *ev = morkEnv::FromMdbEnv(menv);
+
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenActiveAndMutableFile() && file )
+ {
+ mork_u1* end = mStream_WriteEnd; // byte after last buffered byte
+ if ( end ) // file is open for write access?
+ {
+ if ( inSize ) // caller provided any input?
+ {
+ const mork_u1* source = (const mork_u1*) inBuf; // from where
+ if ( source ) // caller passed good buffer address?
+ {
+ mork_u1* at = mStream_At;
+ mork_u1* buf = mStream_Buf;
+ if ( at >= buf && at <= end ) // expected cursor order?
+ {
+ mork_num space = (mork_num) (end - at); // space left in buffer
+
+ mork_num quantum = inSize; // number of bytes to write
+ if ( quantum > space ) // more than buffer size?
+ quantum = space; // restrict to avail space
+
+ if ( quantum ) // any space left in the buffer?
+ {
+ mStream_Dirty = morkBool_kTrue; // to ensure later flush
+ MORK_MEMCPY(at, source, quantum); // into buffer
+
+ mStream_At += quantum; // advance past written bytes
+ outActual += quantum; // this much written so far
+
+ source += quantum; // in case we need to write more
+ inSize -= quantum; // filled this much of request
+ }
+
+ if ( inSize ) // we still need to write more content?
+ {
+ // We need to write more bytes directly to the
+ // content file, without local buffering. We have
+ // exhausted the local buffer, so we need to flush
+ // it and empty it, and adjust the current buf pos.
+ // After flushing, if the rest of the write fits
+ // inside the buffer, we will put bytes into the
+ // buffer rather than write them to content file.
+
+ if ( mStream_Dirty )
+ this->Flush(menv); // will update mStream_BufPos
+
+ at = mStream_At;
+ if ( at < buf || at > end ) // bad cursor?
+ this->NewBadCursorOrderError(ev);
+
+ if ( ev->Good() ) // no errors?
+ {
+ space = (mork_num) (end - at); // space left in buffer
+ if ( space > inSize ) // write to buffer?
+ {
+ mStream_Dirty = morkBool_kTrue; // ensure flush
+ MORK_MEMCPY(at, source, inSize); // copy
+
+ mStream_At += inSize; // past written bytes
+ outActual += inSize; // this much written
+ }
+ else // directly to content file instead
+ {
+ // file->Seek(ev, mStream_BufPos); // set pos
+ // if ( ev->Good() ) // no seek error?
+ // {
+ // }
+
+ mork_num actual = 0;
+ file->Put(menv, source, inSize, mStream_BufPos, &actual);
+ if ( ev->Good() ) // no write error?
+ {
+ outActual += actual;
+ mStream_BufPos += actual;
+ }
+ }
+ }
+ }
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+ else this->NewNullStreamBufferError(ev);
+ }
+ }
+ else this->NewCantWriteSourceError(ev);
+ }
+ else this->NewFileDownError(ev);
+
+ if ( ev->Bad() )
+ outActual = 0;
+
+ *aOutSize = outActual;
+ return ev->AsErr();
+}
+
+NS_IMETHODIMP
+morkStream::Flush(nsIMdbEnv* ev)
+{
+ morkEnv *mev = morkEnv::FromMdbEnv(ev);
+ nsresult rv = NS_ERROR_FAILURE;
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenOrClosingNode() && this->FileActive() && file )
+ {
+ if ( mStream_Dirty )
+ this->spill_buf(mev);
+
+ rv = file->Flush(ev);
+ }
+ else this->NewFileDownError(mev);
+ return rv;
+}
+
+// ````` ````` ````` ````` ````` ````` ````` `````
+// protected: // protected non-poly morkStream methods (for char io)
+
+int
+morkStream::fill_getc(morkEnv* ev)
+{
+ int c = EOF;
+
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenAndActiveFile() && file )
+ {
+ mork_u1* buf = mStream_Buf;
+ mork_u1* end = mStream_ReadEnd; // beyond buf after earlier read
+ if ( end > buf ) // any earlier read bytes buffered?
+ {
+ mStream_BufPos += ( end - buf ); // advance past old read
+ }
+
+ if ( ev->Good() ) // no errors yet?
+ {
+ // file->Seek(ev, mStream_BufPos); // set file pos
+ // if ( ev->Good() ) // no seek error?
+ // {
+ // }
+
+ nsIMdbEnv* menv = ev->AsMdbEnv();
+ mork_num actual = 0;
+ file->Get(menv, buf, mStream_BufSize, mStream_BufPos, &actual);
+ if ( ev->Good() ) // no read errors?
+ {
+ if ( actual > mStream_BufSize ) // more than asked for??
+ actual = mStream_BufSize;
+
+ mStream_At = buf;
+ mStream_ReadEnd = buf + actual;
+ if ( actual ) // any bytes actually read?
+ {
+ c = *mStream_At++; // return first byte from buffer
+ mStream_HitEof = morkBool_kFalse;
+ }
+ else
+ mStream_HitEof = morkBool_kTrue;
+ }
+ }
+ }
+ else this->NewFileDownError(ev);
+
+ return c;
+}
+
+void
+morkStream::spill_putc(morkEnv* ev, int c)
+{
+ this->spill_buf(ev);
+ if ( ev->Good() && mStream_At < mStream_WriteEnd )
+ this->Putc(ev, c);
+}
+
+void
+morkStream::spill_buf(morkEnv* ev) // spill/flush from buffer to file
+{
+ nsIMdbFile* file = mStream_ContentFile;
+ if ( this->IsOpenOrClosingNode() && this->FileActive() && file )
+ {
+ mork_u1* buf = mStream_Buf;
+ if ( mStream_Dirty )
+ {
+ mork_u1* at = mStream_At;
+ if ( at >= buf && at <= mStream_WriteEnd ) // order?
+ {
+ mork_num count = (mork_num) (at - buf); // bytes buffered
+ if ( count ) // anything to write to the string?
+ {
+ if ( count > mStream_BufSize ) // no more than max?
+ {
+ count = mStream_BufSize;
+ mStream_WriteEnd = buf + mStream_BufSize;
+ this->NewBadCursorSlotsError(ev);
+ }
+ if ( ev->Good() )
+ {
+ // file->Seek(ev, mStream_BufPos);
+ // if ( ev->Good() )
+ // {
+ // }
+ nsIMdbEnv* menv = ev->AsMdbEnv();
+ mork_num actual = 0;
+
+ file->Put(menv, buf, count, mStream_BufPos, &actual);
+ if ( ev->Good() )
+ {
+ mStream_BufPos += actual; // past bytes written
+ mStream_At = buf; // reset buffer cursor
+ mStream_Dirty = morkBool_kFalse;
+ }
+ }
+ }
+ }
+ else this->NewBadCursorOrderError(ev);
+ }
+ else
+ {
+#ifdef MORK_DEBUG
+ ev->NewWarning("stream:spill:not:dirty");
+#endif /*MORK_DEBUG*/
+ }
+ }
+ else this->NewFileDownError(ev);
+
+}
+
+
+//3456789_123456789_123456789_123456789_123456789_123456789_123456789_123456789
generated by cgit v1.2.3 (git 2.26.2) at 2024-11-14 06:50:28 +0000