OP_STATUS TempBuffer::AppendVFormat(const uni_char* format, va_list args) { CHECK_INVARIANTS(); #ifdef va_copy // One cannot assume (according to manual) that args will // remain unchanged after the call to OpPrintf::Format() va_list args_copy; va_copy(args_copy, args); OpPrintf printer(OpPrintf::PRINTF_UNICODE); int len = printer.Format(NULL, 0, format, args_copy); int current_length = Length(); va_end(args_copy); #else // va_copy OpPrintf printer(OpPrintf::PRINTF_UNICODE); int len = printer.Format(NULL, 0, format, args); int current_length = Length(); #endif // va_copy RETURN_IF_ERROR(Expand(current_length + len + 1)); uni_char* buf = GetStorage() + current_length; uni_vsnprintf(buf, len+1, format, args); cached_length = current_length + len; CHECK_INVARIANTS(); return OpStatus::OK; }
OP_STATUS TempBuffer::Append( const char *s, size_t n ) { CHECK_INVARIANTS(); if (s == NULL || n == 0) { return OpStatus::OK; } size_t len = 0; const char* q = s; while (len < n && *q) { ++q; ++len; } size_t used = Length()+1; size_t orig_len = len; RETURN_IF_ERROR( EnsureConstructed( used+len ) ); uni_char *p; for ( p=storage+used-1 ; len ; len-- ) *p++ = (uni_char)*s++; *p = 0; cached_length += orig_len; CHECK_INVARIANTS(); return OpStatus::OK; }
void TempBuffer::Clear() { CHECK_INVARIANTS(); if (storage) storage[0] = 0; cached_length = 0; CHECK_INVARIANTS(); }
OP_STATUS TempBuffer::Expand( size_t capacity ) { CHECK_INVARIANTS(); if (capacity == 0) capacity = 1; RETURN_IF_ERROR( EnsureConstructed( capacity ) ); CHECK_INVARIANTS(); return OpStatus::OK; }
errval_t mdb_remove(struct cte *target) { MDB_TRACE_ENTER(mdb_root, "%p", target); CHECK_INVARIANTS(mdb_root, target, true); #ifdef IN_KERNEL #ifdef MDB_TRACE_NO_RECURSIVE char prefix[50]; snprintf(prefix, 50, "mdb_remove.%d: ", my_core_id); print_cte(target, prefix); #endif #endif errval_t err = mdb_subtree_remove(target, &mdb_root, NULL); CHECK_INVARIANTS(mdb_root, target, false); MDB_TRACE_LEAVE_SUB_RET("%"PRIuPTR, err, mdb_root); }
TempBuffer* TempBuffer::Delete( size_t startp, size_t n ) { size_t len = Length(); if (startp >= len || n == 0) (void)0; //nop else if (startp + n >= len) { storage[startp] = 0; if (flags.cached_length_policy == TRUSTED) cached_length = startp; } else { uni_char *p = storage + startp; uni_char *q = p + n; size_t nmov = len - (startp + n); do *p++ = *q++; while (--nmov); *p = 0; if (flags.cached_length_policy == TRUSTED) cached_length = len - n; } CHECK_INVARIANTS(); return this; }
OP_STATUS TempBuffer::Append( const uni_char s ) { CHECK_INVARIANTS(); size_t used = Length()+1; RETURN_IF_ERROR( EnsureConstructed( used+1 ) ); uni_char *p; p=storage+used-1; *p++ = s; *p = 0; cached_length++; CHECK_INVARIANTS(); return OpStatus::OK; }
TempBuffer::TempBuffer() { cached_length = 0; storage = 0; allocated = 0; flags.expansion_policy = AGGRESSIVE; flags.cached_length_policy = TRUSTED; CHECK_INVARIANTS(); }
void TempBuffer::FreeStorage() { OP_DELETEA(storage); cached_length = 0; storage = 0; allocated = 0; flags.expansion_policy = AGGRESSIVE; flags.cached_length_policy = TRUSTED; CHECK_INVARIANTS(); }
OP_STATUS TempBuffer::EnsureConstructed( size_t capacity ) { OP_ASSERT(capacity > 0); if (storage && allocated >= capacity) return OpStatus::OK; if (GetExpansionPolicy() == AGGRESSIVE) capacity = MAX( capacity, allocated*2 ); size_t nallocated = (capacity + (alignment-1)) & ~(alignment-1); uni_char *nstorage = OP_NEWA( uni_char, nallocated ); CHECK_ALLOCATION( nstorage ); #ifdef _DEBUG // In debug mode, fill up the new space with the pattern "BUG!BUG!..." to // make printing of uninitialized memory easy to detect const uni_char *const bug = UNI_L("BUG!"); for (size_t i = 0; i < nallocated; ++i) nstorage[i] = bug[i % 4]; #ifdef VALGRIND // Even though the buffer has been "initialized" to "BUG!BUG!...", we still // want Valgrind to treat it as undefined op_valgrind_set_undefined(nstorage, sizeof(uni_char) * nallocated); #endif // VALGRIND #endif // _DEBUG if (storage) { OP_ASSERT(uni_strlen(storage) >= Length()); OP_ASSERT(uni_strlen(storage) < allocated); uni_strcpy( nstorage, storage ); OP_DELETEA(storage); } else nstorage[0] = 0; storage = nstorage; allocated = nallocated; // As a precaution, write a null terminator to the end of the newly // allocated memory. This could save us from running off the end in case // buggy code forgets to null-terminate the buffer. storage[nallocated - 1] = 0; CHECK_INVARIANTS(); return OpStatus::OK; }
errval_t mdb_insert(struct cte *new_node) { MDB_TRACE_ENTER(mdb_root, "%p", new_node); #ifdef IN_KERNEL #ifdef MDB_TRACE_NO_RECURSIVE char prefix[50]; snprintf(prefix, 50, "mdb_insert.%d: ", my_core_id); print_cte(new_node, prefix); #endif #endif errval_t ret = mdb_sub_insert(new_node, &mdb_root); CHECK_INVARIANTS(mdb_root, new_node, true); MDB_TRACE_LEAVE_SUB_RET("%"PRIuPTR, ret, mdb_root); }