char[] outBuf = mBranchBuffer.getCurrentSegment(); int outPtr = mBranchBuffer.getCurrentSegmentSize(); outBuf = mBranchBuffer.finishCurrentSegment(); outPtr = 0; mBranchBuffer.setCurrentLength(outPtr); } else { mBranchBuffer.append(mBuffer, startOffset, pastEnd-startOffset);
public static TextBuffer createTemporaryBuffer() { return new TextBuffer(null); }
public void resetWithCopy(char[] buf, int start, int len) { mInputBuffer = null; mInputStart = -1; // indicates shared buffer not used mInputLen = 0; mResultString = null; mResultArray = null; // And then reset internal input buffers, if necessary: if (mHasSegments) { clearSegments(); } else { if (mCurrentSegment == null) { mCurrentSegment = allocBuffer(len); } mCurrentSize = mSegmentSize = 0; } append(buf, start, len); }
/** * Method called to make sure there is a non-shared segment to use, without * appending any content yet. */ public void resetInitialized() { resetWithEmpty(); if (mCurrentSegment == null) { mCurrentSegment = allocBuffer(0); } }
private TextBuffer getTextBuffer() { if (mTextBuffer == null) { mTextBuffer = TextBuffer.createTemporaryBuffer(); mTextBuffer.resetInitialized(); } else { mTextBuffer.resetWithEmpty(); } return mTextBuffer; }
tb = TextBuffer.createTemporaryBuffer(); tb.resetInitialized(); char[] outBuf = tb.getCurrentSegment(); int outLen = outBuf.length; outBuf = tb.finishCurrentSegment(); outPtr = 0; outBuf = tb.finishCurrentSegment(); outPtr = 0; outLen = outBuf.length; tb.setCurrentLength(outPtr); defVal.setValue(tb.contentsAsString()); mValueBuffer = tb;
tb = TextBuffer.createTemporaryBuffer(); tb.resetInitialized(); char[] outBuf = tb.getCurrentSegment(); int outPtr = tb.getCurrentSegmentSize(); outBuf = tb.finishCurrentSegment(); outPtr = 0; while (true) { if (outPtr >= outBuf.length) { // need more room? outBuf = tb.finishCurrentSegment(); outPtr = 0; outBuf = tb.finishCurrentSegment(); outPtr = 0; outBuf = tb.finishCurrentSegment(); outPtr = 0; tb.setCurrentLength(outPtr); throwDTDUnexpectedChar(c, "; expected closing '>' after ENTITY declaration"); char[] result = tb.contentsAsArray();
mCurrToken = END_ELEMENT; String result = mTextBuffer.contentsAsString(); int extra = 1 + (mTextBuffer.size() >> 1); // let's add 50% space StringBuffer sb = mTextBuffer.contentsAsStringBuffer(extra); int type; mTextBuffer.contentsToStringBuffer(sb); continue;
char[] outBuf = tb.getCurrentSegment(); int outPtr = 0; outBuf = tb.finishCurrentSegment(); outPtr = 0; outBuf = tb.finishCurrentSegment(); outPtr = 0; ? mInputBuffer[mInputPtr++] : dtdNextFromCurr(); tb.setCurrentLength(outPtr); String data = tb.contentsAsString(); mEventListener.dtdProcessingInstruction(target, data);
public char[] getCurrentSegment() { /* Since the intention of the caller is to directly add stuff into * buffers, we should NOT have anything in shared buffer... ie. may * need to unshare contents. */ if (mInputStart >= 0) { unshare(1); } else { char[] curr = mCurrentSegment; if (curr == null) { mCurrentSegment = allocBuffer(0); } else if (mCurrentSize >= curr.length) { // Plus, we better have room for at least one more char expand(1); } } return mCurrentSegment; }
public void resetWithCopy(char[] buf, int start, int len) { //System.out.println("[DEBUG] resetWithCopy, start "+start+", len "+len); mInputBuffer = null; mInputStart = -1; // indicates shared buffer not used mInputLen = 0; mResultString = null; mResultArray = null; // And then reset internal input buffers, if necessary: if (mSegments != null && mSegments.size() > 0) { /* Let's start using _last_ segment from list; for one, it's * the biggest one, and it's also most likely to be cached */ mCurrentSegment = (char[]) mSegments.get(mSegments.size() - 1); mSegments.clear(); } else { if (mCurrentSegment == null) { mCurrentSegment = allocBuffer(mInitialBufSize); } } mCurrentSize = mSegmentSize = 0; append(buf, start, len); }
if (mTextBuffer.size() > 0) { return CDATA; if (mTextBuffer.size() == 0 && readCDataSecondary(mCfgLazyParsing ? 1 : mShortestTextSegment)) { if (mTextBuffer.size() > 0) { tb.resetInitialized(); if (ch <= 0xFFFF) { tb.append((char) ch); } else { ch -= 0x10000; tb.append((char) ((ch >> 10) + 0xD800)); tb.append((char) ((ch & 0x3FF) + 0xDC00)); && mTextBuffer.size() >= mShortestTextSegment) { mTokenState = TOKEN_PARTIAL_SINGLE; } else {
/** * Internal method used by implementation */ private char[] getDTDInternalSubsetArray() { /* Note: no checks for current state, but only because it's * an internal method and callers are known to ensure it's ok * to call this */ return mTextBuffer.contentsAsArray(); }
public int getTextCharacters(int sourceStart, char[] target, int targetStart, int len) { if (((1 << mCurrToken) & MASK_GET_TEXT_XXX) == 0) { throwNotTextXxx(mCurrToken); } if (mTokenState < mStTextThreshold) { safeFinishToken(); } return mTextBuffer.contentsToArray(sourceStart, target, targetStart, len); }
public char[] contentsAsArray() { char[] result = mResultArray; if (result == null) { mResultArray = result = buildResultArray(); } return result; }
mTextBuffer.ensureNotShared(); if (!loadMore()) { mTextBuffer.ensureNotShared(); if (!ensureInput(3)) { break;
mTextBuffer = TextBuffer.createRecyclableBuffer(cfg);
mInputBuffer = buildResultArray(); mInputLen = mInputBuffer.length; clearSegments(); } else {
/** * @return Internal subset portion of the DOCTYPE declaration, if any; * empty String if none */ public String getDTDInternalSubset() { if (mCurrToken != DTD) { return null; } return mTextBuffer.contentsAsString(); }
if (expLen != size()) { return false; seg = contentsAsArray();