void Archive::dump() const {
printf("Archive data %p len %zu, firstRegularData %p\n", data.data(),
data.size(), firstRegularData);
printf("Symbol table %p, len %u\n", symbolTable.data, symbolTable.len);
printf("string table %p, len %u\n", stringTable.data, stringTable.len);
const uint8_t* buf = symbolTable.data;
if (!buf) {
for (auto c = child_begin(), e = child_end(); c != e; ++c) {
printf("Child %p, len %u, name %s, size %u\n", c->data, c->len,
c->getName().c_str(), c->getSize());
}
return;
}
uint32_t symbolCount = read32be(buf);
printf("Symbol count %u\n", symbolCount);
buf += sizeof(uint32_t) + (symbolCount * sizeof(uint32_t));
uint32_t string_start_offset = buf - symbolTable.data;
Symbol sym = {0, string_start_offset};
while (sym.symbolIndex != symbolCount) {
printf("Symbol %u, offset %u\n", sym.symbolIndex, sym.stringIndex);
// get the member
uint32_t offset = read32be(symbolTable.data + sym.symbolIndex * 4);
auto* loc = (const uint8_t*)&data[offset];
child_iterator it;
it.child = Child(this, loc, &it.error);
printf("Child %p, len %u\n", it.child.data, it.child.len);
}
}
void stmt::destroyChildren(pParseContext &C) {
for (child_iterator i = child_begin(), e = child_end(); i != e; ) {
// NOTE: it's valid for some children to be NULL
if (stmt* child = *i++)
child->destroy(C);
}
}
clang::Stmt *stmtAt(std::vector<int> indices)
{
auto stmt = func->getDecl()->getBody();
for (auto index : indices)
stmt = *boost::next(stmt->child_begin(), index);
return stmt;
}
bool ParagraphComment::isWhitespaceNoCache() const {
for (child_iterator I = child_begin(), E = child_end(); I != E; ++I) {
if (const TextComment *TC = dyn_cast<TextComment>(*I)) {
if (!TC->isWhitespace())
return false;
} else
return false;
}
return true;
}
Archive::Archive(Buffer& b, bool& error) : data(b), symbolTable({nullptr, 0}), stringTable({nullptr, 0}), firstRegularData(nullptr) {
error = false;
if (data.size() < strlen(magic) ||
memcmp(data.data(), magic, strlen(magic))) {
error = true;
return;
}
// We require GNU format archives. So the first member may be named "/" and it
// points to the symbol table. The next member may optionally be "//" and
// point to a string table if a filename is too large to fit in the 16-char
// name field of the header.
child_iterator it = child_begin(false);
if (it.hasError()) {
error = true;
return;
}
child_iterator end = child_end();
if (it == end) return; // Empty archive.
const Child* c = &*it;
auto increment = [&]() {
++it;
error = it.hasError();
if (error) return true;
c = &*it;
return false;
};
std::string name = c->getRawName();
if (name == "/") {
symbolTable = c->getBuffer();
if (increment() || it == end) return;
name = c->getRawName();
}
if (name == "//") {
stringTable = c->getBuffer();
if (increment() || it == end) return;
setFirstRegular(*c);
return;
}
if (name[0] != '/') {
setFirstRegular(*c);
return;
}
// Not a GNU archive.
error = true;
}
void EventDispatcherBase<TDerived>::markDescendantsForEntry()
{
for (auto state = derived().begin(); state != derived().end(); ++state)
{
if (!(state->m_flags & state_type::InEnterSet))
{
state.skipChildren();
continue;
}
if (state->isCompound())
{
// Exactly one state of a compound state has to be marked for entry.
bool childMarked = false;
for (auto child = state.child_begin();
child != state.child_end(); ++child)
{
if (child->m_flags & state_type::InEnterSet)
{
childMarked = true;
break;
}
}
if (!childMarked)
{
if (state->m_flags
& (state_type::ShallowHistory | state_type::DeepHistory))
{
using history_state_type = ShallowHistoryState<TDerived>;
history_state_type* historyState
= static_cast<history_state_type*>(&*state);
if (historyState->m_latestActiveChild)
{
historyState->m_latestActiveChild->m_flags |= state_type::InEnterSet;
continue;
}
}
if (state_type* initialState = state->initialState())
{
do
{
initialState->m_flags |= state_type::InEnterSet;
initialState = initialState->parent();
} while (initialState != &*state);
}
else
{
state->m_children->m_flags |= state_type::InEnterSet;
}
}
}
else if (state->isParallel())
{
// All child states of a parallel state have to be marked for entry.
for (auto child = state.child_begin();
child != state.child_end(); ++child)
{
child->m_flags |= state_type::InEnterSet;
}
}
}
}
