fBase
: fBase(base),
void SetBase(addr_t base) { fBase = base; }
addr_t Base() const { return fBase; }
addr_t fBase;
addr_t fBase;
addr_t Base() const { return fBase; }
size_t Size() const { return fEndAddress - fBase + 1; }
addr_t Base() const { return fBase; }
{ return address >= fBase
&& address <= fBase + (fSize - 1); }
void SetBase(addr_t base) { fBase = base; }
addr_t fBase;
fBase(base),
fBase->SetParent(this);
if (!fBase->GetName(buffer))
return fBase != beforeNode
? fBase->GetUnqualifiedNode(beforeNode) : this;
return fBase->IsNoReturnValueFunction();
return fBase->ObjectType();
return fBase->PrefixType();
Node* fBase;
uint8 fBase; // base - default value of register
float base = Info.fBase >> Info.fOff;
Control.id |= (Info.fBase << baseShift);
Info.fBase, Info.fMask, Info.fMult);
float r = powf(M_E, cosf(fBase)) - 2 * cosf(4 * fBase)
- powf(sinf(fBase / 12), 5);
BPoint p(sinf(fBase * 1.01f) * r + cosf(fBase * 1.02f) * 0.2f,
cosf(fBase * 1.01f) * r + sinf(fBase * 1.02f) * 0.2f);
fBase += 0.05f;
fBase = drand48() * 2 * M_PI * 1000;
view->SetHighColor(_HueToColor(fBase * 15));
float fBase;
fBase(kHexBase),
line += sprintf(line, fBase == kHexBase ? "%0*" B_PRIxOFF": " : "%0*"
if (fBase == type)
fBase = type;
base_type fBase;
base_type Base() const { return fBase; }
base_type Base() const { return fBase; }
base_type fBase;
fBase(kHexBase),
snprintf(buffer, bufferSize, fBase == kHexBase ? "0x%" B_PRIxOFF : "%"
if (fBase == type)
fBase = type;
if (sClonedAreaMemoryAllocator.AddArea(area, fClonedArea, fBase, 0, false) != B_OK)
return fBase + fOffset;
uint8* fBase;
fBase(base) {};
virtual addr_t Base() { return fBase; };
addr_t fBase;
areaInfo->fBase = area->Base();
return fBase;
addr_t fBase;
if (fBase[index].size - size >= 2) {
uint32 nextNext = index + 1 + fBase[index].size;
fBase[next].size = fBase[index].size - size - 1;
fBase[next].previous = index;
fBase[index].size = size;
fBase[nextNext].previous = next;
return &fBase[index + 1];
if (((addr_t)address & 7) != 0 || address <= fBase + 1
|| address >= fBase + fEnd) {
uint32 index = header - fBase;
if (index > 1 && fBase[header->previous].free) {
fBase[previous].size += 1 + header->size;
fBase[next].previous = previous;
header = fBase + index;
if (next < fEnd && fBase[next].free) {
header->size += 1 + fBase[next].size;
fBase[nextNext].previous = index;
uint32 size = fBase[index].size;
while (next != 0 && size > fBase[next].size)
next = ((free_entry*)&fBase[next])->next_free;
previous = ((free_entry*)&fBase[next])->previous_free;
((free_entry*)&fBase[next])->previous_free = index;
((free_entry*)&fBase[previous])->next_free = index;
((free_entry*)&fBase[index])->previous_free = previous;
((free_entry*)&fBase[index])->next_free = next;
fBase[index].free = true;
uint32 previous = ((free_entry*)&fBase[index])->previous_free;
uint32 next = ((free_entry*)&fBase[index])->next_free;
((free_entry*)&fBase[previous])->next_free = next;
((free_entry*)&fBase[next])->previous_free = previous;
fBase[index].free = false;
allocation_header* fBase; // actually base - 1, so that index 0 is
fBase = (allocation_header*)heap - 1;
fBase[1].size = size - 1;
fBase[1].previous = 0;
if (fLastFree == 0 || fBase[fLastFree].size < 2) {
allocation_header* header = &fBase[fLastFree];
fParent->Free(fBase + 1);
while (index != 0 && fBase[index].size < size)
index = ((free_entry*)&fBase[index])->next_free;
uint32 Base() const { return fBase; };
uint8 ReadReg(uint32 reg) { return in8(fBase + reg); };
void WriteReg(uint32 reg, uint8 v) { out8(v, fBase + reg); };
uint32 fBase;
uint32 Base() const { return fBase; };
void WriteReg(uint32 reg, uint8 v) { out8((uint8)reg,fBase+1); out8(v,fBase+3); };
uint32 fBase;
fBase = base;
fBase = base;
out8(0x0a, fBase+1);
while((in8(fBase+3) & 0x80) && --waitTime);
out8((uint8)reg,fBase+1);
return in8(fBase+3);
kprintf("base: %#" B_PRIxADDR "\n", fBase);
fBase(base),
waiter->base = fBase;
fOldBase, fBase);
off_t fBase;
size_t size = fEndAddress - fBase + 1;
Range* range = new(fRangesObjectCache, 0) Range(fBase, size,
" - %#" B_PRIxADDR ", free lists: %d\n", fBase, fEndAddress,
address = fBase;
start = fBase;
size_t spaceSize = fEndAddress - fBase + 1;
addr_t nextBase = fBase;
if (range->size > spaceSize - (range->base - fBase)) {
searchBase = std::max(fBase, (addr_t)addressRestrictions->address);
searchBase = std::max(fBase, (addr_t)USER_BASE_ANY);
if (start < fBase || size == 0 || end > fEndAddress
uint8* fBase;