TypedValue HHVM_FUNCTION(serialize_memoize_param, TypedValue param) {
// Memoize throws in the emitter if any function parameters are references, so
// we can just assert that the param is cell here
assertx(param.m_type != KindOfRef);
auto const type = param.m_type;
if (isStringType(type)) {
auto const str = param.m_data.pstr;
if (str->empty()) {
return make_tv<KindOfPersistentString>(s_emptyStrMemoKey.get());
} else if ((unsigned char)str->data()[0] < '~') {
// fb_compact_serialize always returns a string with the high-bit set in
// the first character. Furthermore, we use ~ to begin all our special
// constants, so anything less than ~ can't collide. There's no worry
// about int-like strings because we use dicts (which don't perform key
// coercion) to store the memoized values.
str->incRefCount();
return param;
}
} else if (isContainer(param) && getContainerSize(param) == 0) {
return make_tv<KindOfPersistentString>(s_emptyArrMemoKey.get());
} else if (type == KindOfUninit || type == KindOfNull) {
return make_tv<KindOfPersistentString>(s_nullMemoKey.get());
} else if (type == KindOfBoolean) {
return make_tv<KindOfPersistentString>(
param.m_data.num ? s_trueMemoKey.get() : s_falseMemoKey.get()
);
} else if (type == KindOfInt64) {
return param;
}
return tvReturn(
fb_compact_serialize(tvAsCVarRef(¶m),
FBCompactSerializeBehavior::MemoizeParam));
}
/*----------------------------------------------------------------------*/
static void showInstanceLocation(int ins, char *prefix) {
char buffer[1000];
if (admin[ins].location == 0)
return;
else {
output(prefix);
if (isALocation(admin[ins].location)) {
output("at");
say(admin[ins].location);
sprintf(buffer, "[%d]", admin[ins].location);
output(buffer);
} else if (isContainer(admin[ins].location)) {
if (isObject(admin[ins].location))
output("in");
else if (isActor(admin[ins].location))
output("carried by");
say(admin[ins].location);
sprintf(buffer, "[%d]", admin[ins].location);
output(buffer);
} else
output("Illegal location!");
}
}
Variant f_max(int _argc, const Variant& value,
const Variant& second /* = null_variant */,
const Array& _argv /* = null_array */) {
if (_argc == 1) {
const auto& cell_value = *value.asCell();
if (UNLIKELY(!isContainer(cell_value))) {
return value;
}
ArrayIter iter(cell_value);
if (!iter) {
return uninit_null();
}
Variant ret = iter.secondRefPlus();
++iter;
for (; iter; ++iter) {
Variant currVal = iter.secondRefPlus();
if (more(currVal, ret)) {
ret = currVal;
}
}
return ret;
} else if (_argc == 2) {
return more(second, value) ? second : value;
}
Variant ret = more(second, value) ? second : value;
for (ArrayIter iter(_argv); iter; ++iter) {
Variant currVal = iter.secondRef();
if (more(currVal, ret)) {
ret = currVal;
}
}
return ret;
}
Variant HHVM_FUNCTION(serialize_memoize_param, const Variant& param) {
// Memoize throws in the emitter if any function parameters are references, so
// we can just assert that the param is cell here
const auto& cell_param = *tvAssertCell(param.asTypedValue());
auto type = param.getType();
if (type == KindOfInt64) {
return param;
} else if (type == KindOfUninit || type == KindOfNull) {
return s_empty;
} else if (type == KindOfBoolean) {
return param.asBooleanVal() ? s_true : s_false;
} else if (type == KindOfString) {
auto str = param.asCStrRef();
if (str.empty()) {
return s_emptyStr;
} else if (str.charAt(0) > '9') {
// If it doesn't start with a number, then we know it can never collide
// with an int or any of our constants, so it's fine as is
return param;
}
} else if (isContainer(cell_param) && getContainerSize(cell_param) == 0) {
return s_emptyArr;
}
return fb_compact_serialize(param, FBCompactSerializeBehavior::MemoizeParam);
}
bool KML::isHandled(std::string const& elem) const
{
if( isLeaf(elem) || isFeature(elem) || isFeatureContainer(elem)
|| isContainer(elem) || isRest(elem) )
{
return true;
}
return false;
}
void Widget::setEnabled( bool bEnabled )
{
if( m_state.isEnabled() != bEnabled || isContainer() )
{
State s = m_state;
s.setEnabled(bEnabled);
_setState(s);
}
}
Variant f_array_combine(CVarRef keys, CVarRef values) {
const auto& cell_keys = *keys.asCell();
const auto& cell_values = *values.asCell();
if (UNLIKELY(!isContainer(cell_keys) || !isContainer(cell_values))) {
raise_warning("Invalid operand type was used: array_combine expects "
"arrays or collections");
return uninit_null();
}
if (UNLIKELY(getContainerSize(cell_keys) != getContainerSize(cell_values))) {
raise_warning("array_combine(): Both parameters should have an equal "
"number of elements");
return false;
}
Array ret = ArrayData::Create();
for (ArrayIter iter1(cell_keys), iter2(cell_values);
iter1; ++iter1, ++iter2) {
ret.lvalAt(iter1.secondRefPlus()).setWithRef(iter2.secondRefPlus());
}
return ret;
}
Variant invoke(const String& function, const Variant& params,
strhash_t hash /* = -1 */, bool tryInterp /* = true */,
bool fatal /* = true */) {
Func* func = Unit::loadFunc(function.get());
if (func && (isContainer(params) || params.isNull())) {
Variant ret;
g_context->invokeFunc(ret.asTypedValue(), func, params);
return ret;
}
return invoke_failed(function.c_str(), fatal);
}
bool REFERENCE::GetInventory(TES3MACHINE& machine, VPREFERENCE pref, VPLISTNODE& firststack)
{
firststack= 0;
VMPTR<TES3REFERENCE> ref(machine,pref);
VMPTR<TES3TEMPLATE> templ(machine,ref->templ);
if(isContainer(templ))
firststack= templ->inventory.first;
return true;
}
Variant f_array_values(CVarRef input) {
const auto& cell_input = *input.asCell();
if (!isContainer(cell_input)) {
raise_warning("array_values() expects parameter 1 to be an array "
"or collection");
return uninit_null();
}
PackedArrayInit ai(getContainerSize(cell_input));
for (ArrayIter iter(cell_input); iter; ++iter) {
ai.appendWithRef(iter.secondRefPlus());
}
return ai.toArray();
}
void RObject::markDataDirty () {
RK_TRACE (OBJECTS);
type |= NeedDataUpdate;
if (isContainer ()) {
RContainerObject* this_container = static_cast<RContainerObject*> (this);
RObjectMap children = this_container->childmap;
for (int i = children.size () - 1; i >= 0; --i) {
children[i]->markDataDirty ();
}
if (this_container->rownames_object) this_container->rownames_object->markDataDirty ();
}
}
Variant vm_call_user_func(const Variant& function, const Variant& params,
bool forwarding /* = false */) {
ObjectData* obj = nullptr;
HPHP::Class* cls = nullptr;
HPHP::JIT::CallerFrame cf;
StringData* invName = nullptr;
const HPHP::Func* f = vm_decode_function(function, cf(), forwarding,
obj, cls, invName);
if (f == nullptr || (!isContainer(params) && !params.isNull())) {
return uninit_null();
}
Variant ret;
g_context->invokeFunc((TypedValue*)&ret, f, params, obj, cls,
nullptr, invName, ExecutionContext::InvokeCuf);
return ret;
}
Variant invoke_static_method(const String& s, const String& method,
const Variant& params, bool fatal /* = true */) {
HPHP::Class* class_ = Unit::lookupClass(s.get());
if (class_ == nullptr) {
o_invoke_failed(s.data(), method.data(), fatal);
return uninit_null();
}
const HPHP::Func* f = class_->lookupMethod(method.get());
if (f == nullptr || !(f->attrs() & AttrStatic) ||
(!isContainer(params) && !params.isNull())) {
o_invoke_failed(s.data(), method.data(), fatal);
return uninit_null();
}
Variant ret;
g_context->invokeFunc((TypedValue*)&ret, f, params, nullptr, class_);
return ret;
}
String StringUtil::Implode(const Variant& items, const String& delim) {
if (!isContainer(items)) {
throw_param_is_not_container();
}
int size = getContainerSize(items);
if (size == 0) return "";
String* sitems = (String*)smart_malloc(size * sizeof(String));
int len = 0;
int lenDelim = delim.size();
int i = 0;
for (ArrayIter iter(items); iter; ++iter) {
new (&sitems[i]) String(iter.second().toString());
len += sitems[i].size() + lenDelim;
i++;
}
len -= lenDelim; // always one delimiter less than count of items
assert(i == size);
String s = String(len, ReserveString);
char *buffer = s.bufferSlice().ptr;
const char *sdelim = delim.data();
char *p = buffer;
for (int i = 0; i < size; i++) {
String &item = sitems[i];
if (i && lenDelim) {
memcpy(p, sdelim, lenDelim);
p += lenDelim;
}
int lenItem = item.size();
if (lenItem) {
memcpy(p, item.data(), lenItem);
p += lenItem;
}
sitems[i].~String();
}
smart_free(sitems);
assert(p - buffer == len);
s.setSize(len);
return s;
}
String StringUtil::Implode(const Variant& items, const String& delim,
const bool checkIsContainer /* = true */) {
if (checkIsContainer && !isContainer(items)) {
throw_param_is_not_container();
}
int size = getContainerSize(items);
if (size == 0) return empty_string();
req::vector<String> sitems;
sitems.reserve(size);
size_t len = 0;
size_t lenDelim = delim.size();
for (ArrayIter iter(items); iter; ++iter) {
sitems.emplace_back(iter.second().toString());
len += sitems.back().size() + lenDelim;
}
len -= lenDelim; // always one delimiter less than count of items
assert(sitems.size() == size);
String s = String(len, ReserveString);
char *buffer = s.mutableData();
const char *sdelim = delim.data();
char *p = buffer;
String &init_str = sitems[0];
int init_len = init_str.size();
memcpy(p, init_str.data(), init_len);
p += init_len;
for (int i = 1; i < size; i++) {
String &item = sitems[i];
memcpy(p, sdelim, lenDelim);
p += lenDelim;
int lenItem = item.size();
memcpy(p, item.data(), lenItem);
p += lenItem;
}
assert(p - buffer == len);
s.setSize(len);
return s;
}
void OverlayContainer::copyFromTemplate(OverlayElement* templateOverlay)
{
OverlayElement::copyFromTemplate(templateOverlay);
if (templateOverlay->isContainer() && isContainer())
{
OverlayContainer::ChildIterator it = static_cast<OverlayContainer*>(templateOverlay)->getChildIterator();
while (it.hasMoreElements())
{
OverlayElement* oldChildElement = it.getNext();
if (oldChildElement->isCloneable())
{
OverlayElement* newChildElement =
OverlayManager::getSingleton().createOverlayElement(
oldChildElement->getTypeName(),
mName+"/"+oldChildElement->getName());
newChildElement->copyFromTemplate(oldChildElement);
addChild(static_cast<OverlayContainer*>(newChildElement));
}
}
}
}
void BaseSet::addAllKeysOf(const Cell container) {
assert(isContainer(container));
decltype(cap()) oldCap = 0;
bool ok = IterateKV(
container,
[&](ArrayData* adata) {
auto sz = adata->size();
if (!sz) return true;
if (m_size) {
oldCap = cap(); // assume minimal collisions
}
reserve(m_size + sz);
mutateAndBump();
return false;
},
[this](const TypedValue* key, const TypedValue* value) {
addRaw(tvAsCVarRef(key));
},
[this](ObjectData* coll) {
if (!m_size && coll->collectionType() == CollectionType::Set) {
auto hc = static_cast<HashCollection*>(coll);
replaceArray(hc->arrayData());
setIntLikeStrKeys(BaseSet::intLikeStrKeys(hc));
return true;
}
if (coll->collectionType() == CollectionType::Pair) {
mutateAndBump();
}
return false;
});
if (UNLIKELY(!ok)) {
throw_invalid_collection_parameter();
}
// ... and shrink back if that was incorrect
if (oldCap) shrinkIfCapacityTooHigh(oldCap);
}
Variant f_array_keys(CVarRef input, CVarRef search_value /* = null_variant */,
bool strict /* = false */) {
const auto& cell_input = *input.asCell();
if (UNLIKELY(!isContainer(cell_input))) {
goto warn;
}
{
// We treat Sets differently. For Sets, we pretend the values are
// also the keys (similar to how Set::toArray() behaves).
bool isSetType =
cell_input.m_type == KindOfObject &&
cell_input.m_data.pobj->getCollectionType() == Collection::SetType;
if (UNLIKELY(isSetType)) {
return arrayKeysSetHelper(cell_input, search_value, strict);
}
ArrayIter iter(cell_input);
if (LIKELY(!search_value.isInitialized())) {
PackedArrayInit ai(getContainerSize(cell_input));
for (; iter; ++iter) {
ai.append(iter.first());
}
return ai.toArray();
}
Array ai = Array::attach(HphpArray::MakeReserve(0));
for (; iter; ++iter) {
if ((strict && HPHP::same(iter.secondRefPlus(), search_value)) ||
(!strict && HPHP::equal(iter.secondRefPlus(), search_value))) {
ai.append(iter.first());
}
}
return ai;
}
warn:
raise_warning("array_keys() expects parameter 1 to be an array "
"or collection");
return uninit_null();
}
bool QDesignerWidgetItem::check(const QLayout *layout, QWidget *w, Qt::Orientations *ptrToOrientations)
{
// Check for form-editor non-containerextension-containers (QFrame, etc)
// within laid-out form editor widgets. No check for managed() here as we
// want container pages and widgets in the process of being morphed as
// well. Avoid nested layouts (as the effective stretch cannot be easily
// computed and may mess things up). Won't work for Q3 Group boxes.
if (ptrToOrientations)
*ptrToOrientations = 0;
const QObject *layoutParent = layout->parent();
if (!layoutParent || !layoutParent->isWidgetType() || !WidgetFactory::isFormEditorObject(layoutParent))
return false;
QDesignerFormWindowInterface *fw = QDesignerFormWindowInterface::findFormWindow(w);
if (!fw || !isContainer(fw->core(), w))
return false;
// If it is a box, restrict to its orientation
if (ptrToOrientations)
*ptrToOrientations = layoutOrientation(layout);
return true;
}
AST_MATCHER(NamedDecl, stlContainer) {
return isContainer(Node.getQualifiedNameAsString());
}
void Component::paint(Graphics& g) const
{
g.pushMatrix();
g.translate(getBounds().x,getBounds().y);
if(rotation != 0.0f)
{
int x = getBounds().width /2;
int y = getBounds().height/2;
g.translate(x,y);
g.rotate(rotation);
g.translate(-x,-y);
}
// we only paint if its state is visible.
if(isVisible() && rec.width > 0 && rec.height > 0)
{
bool storeDepth = false;
if(isContainer())
{
// we need to store the current depth value,
// so that it affects all children of this Component.
storeDepth = g.pushDepth(depth);
}
// if this Component is currently not valid, validate it.
if(!isValid())
{
validate();
}
if(SelectionManager::getInstance().getRenderMode() == SelectionManager::NORMAL)
{
// we're in the normal render mode, so check for transparency,
// and paint everything
bool storeTransparency = false;
storeTransparency = g.pushTransparency(transparency);
//displayList = g.
//if(!isDisplayListCompiled)
//{
// util::DisplayList compile(displayList);
// first paint the background
paintComponent(g);
// then any custom painting,
// which can be done by overloading
// paintComponent.
// then paint the borders
paintBorder(g);
// isDisplayListCompiled = true;
//}
//else
//{
// util::DisplayList::call(displayList);
//}
// then paint the children
paintChildren(g);
if(storeTransparency)
{
// restore transparency
g.popTransparency();
}
}
else
{
// this is the Picking render mode, we only do special painting
// here, which helps to speed up this step.
if(hasMouseListener())
{
paintSelectionComponent(g);
}
paintChildren(g);
}
if(isContainer())
{
if(storeDepth)
{
// restore depth values
g.popDepth(depth);
}
}
}
g.popMatrix();
//g.translate(-getBounds().x,-getBounds().y);
}
String Symbol::toString(Flags<ToStringFlag> cursorInfoFlags,
Flags<Location::ToStringFlag> locationToStringFlags,
const std::shared_ptr<Project> &project) const
{
auto properties = [this]()
{
List<String> ret;
if (isDefinition())
ret << "Definition";
if (isContainer())
ret << "Container";
if ((flags & PureVirtualMethod) == PureVirtualMethod) {
ret << "Pure Virtual";
} else if (flags & VirtualMethod) {
ret << "Virtual";
}
if (flags & ConstMethod) {
ret << "Const";
} else if (flags & StaticMethod) {
ret << "Static";
}
if (flags & Variadic)
ret << "Variadic";
if (flags & Auto)
ret << "Auto";
if (flags & AutoRef)
ret << "AutoRef";
if (flags & MacroExpansion)
ret << "MacroExpansion";
if (flags & TemplateSpecialization)
ret << "TemplateSpecialization";
if (ret.isEmpty())
return String();
String joined = String::join(ret, ' ');
joined += '\n';
return joined;
};
List<String> bases;
if (project) {
extern String findSymbolNameByUsr(const std::shared_ptr<Project> &, const String &, const Location &location);
for (const auto &base : baseClasses) {
const String symbolName = findSymbolNameByUsr(project, base, location);
if (!symbolName.isEmpty()) {
bases << symbolName;
}
}
} else {
bases = baseClasses;
}
auto printTypeName = [this]() {
String str;
if (!typeName.isEmpty()) {
str = typeName;
} else if (type != CXType_Invalid) {
str = RTags::eatString(clang_getTypeKindSpelling(type));
} else {
return String();
}
return String::format<128>("Type: %s\n", str.constData());
};
String ret = String::format<1024>("SymbolName: %s\n"
"Kind: %s\n"
"%s" // type
"SymbolLength: %u\n"
"%s" // range
"%s" // enumValue
"%s" // linkage
"%s" // properties
"%s" // usr
"%s" // sizeof
"%s" // fieldoffset
"%s" // baseclasses
"%s" // briefComment
"%s", // xmlComment
symbolName.constData(),
kindSpelling().constData(),
printTypeName().constData(),
symbolLength,
startLine != -1 ? String::format<32>("Range: %d:%d-%d:%d\n", startLine, startColumn, endLine, endColumn).constData() : "",
#if CINDEX_VERSION_MINOR > 1
kind == CXCursor_EnumConstantDecl ? String::format<32>("Enum Value: %lld\n", enumValue).constData() :
#endif
"",
linkageSpelling(linkage),
properties().constData(),
usr.isEmpty() ? "" : String::format<64>("Usr: %s\n", usr.constData()).constData(),
size > 0 ? String::format<16>("sizeof: %d\n", size).constData() : "",
fieldOffset >= 0 ? String::format<32>("field offset (bits/bytes): %d/%d\n", fieldOffset, fieldOffset / 8).constData() : "",
alignment >= 0 ? String::format<32>("alignment (bytes): %d\n", alignment).constData() : "",
bases.isEmpty() ? "" : String::format<64>("BaseClasses: %s\n", String::join(bases, ", ").constData()).constData(),
briefComment.isEmpty() ? "" : String::format<1024>("Brief comment: %s\n", briefComment.constData()).constData(),
xmlComment.isEmpty() ? "" : String::format<16384>("Xml comment: %s\n", xmlComment.constData()).constData());
if (!(cursorInfoFlags & IgnoreTargets) && project) {
extern Set<Symbol> findTargets(const std::shared_ptr<Project> &, const Symbol &);
auto targets = findTargets(project, *this);
if (targets.size()) {
ret.append("Targets:\n");
auto best = RTags::bestTarget(targets);
ret.append(String::format<128>(" %s\n", best.location.toString(locationToStringFlags).constData()));
for (const auto &tit : targets) {
if (tit.location != best.location)
ret.append(String::format<128>(" %s\n", tit.location.toString(locationToStringFlags).constData()));
}
}
}
if (!(cursorInfoFlags & IgnoreReferences) && project && !isReference()) {
extern Set<Symbol> findCallers(const std::shared_ptr<Project> &, const Symbol &);
auto references = findCallers(project, *this);
if (references.size()) {
ret.append("References:\n");
for (const auto &r : references) {
ret.append(String::format<128>(" %s\n", r.location.toString(locationToStringFlags).constData()));
}
}
}
return ret;
}
static void createTag (tokenInfo *const token)
{
tagEntryInfo tag;
/* Do nothing it tag name is empty or tag kind is disabled */
if (vStringLength (token->name) == 0 || ! kindEnabled (token->kind))
{
return;
}
/* Create tag */
initTagEntryFull(
&tag,
vStringValue (token->name),
token->lineNumber,
getSourceLanguageName (),
token->filePosition,
getSourceFileTagPath (),
kindFromKind (token->kind)
);
verbose ("Adding tag %s (kind %d)", vStringValue (token->name), token->kind);
if (currentContext->kind != K_UNDEFINED)
{
verbose (" to context %s\n", vStringValue (currentContext->name));
currentContext->lastKind = token->kind;
tag.extensionFields.scopeKind = kindFromKind (currentContext->kind);
tag.extensionFields.scopeName = vStringValue (currentContext->name);
}
verbose ("\n");
if (vStringLength (token->inheritance) > 0)
{
tag.extensionFields.inheritance = vStringValue (token->inheritance);
verbose ("Class %s extends %s\n", vStringValue (token->name), tag.extensionFields.inheritance);
}
makeTagEntry (&tag);
if (Option.include.qualifiedTags && currentContext->kind != K_UNDEFINED)
{
vString *const scopedName = vStringNew ();
vStringCopy (scopedName, currentContext->name);
vStringCatS (scopedName, ".");
vStringCatS (scopedName, vStringValue (token->name));
tag.name = vStringValue (scopedName);
makeTagEntry (&tag);
vStringDelete (scopedName);
}
/* Push token as context if it is a container */
if (isContainer (token))
{
tokenInfo *newScope = newToken ();
vStringCopy (newScope->name, token->name);
newScope->kind = token->kind;
createContext (newScope);
}
/* Clear no longer required inheritance information */
vStringClear (token->inheritance);
}
String Symbol::toString(const std::shared_ptr<Project> &project,
const Flags<ToStringFlag> cursorInfoFlags,
Flags<Location::ToStringFlag> locationToStringFlags,
const Set<String> &pieceFilters) const
{
auto filterPiece = [&pieceFilters](const char *name) { return pieceFilters.isEmpty() || pieceFilters.contains(name); };
auto properties = [this, &filterPiece]() -> String {
List<String> ret;
if (isDefinition() && filterPiece("definition"))
ret << "Definition";
if (isContainer() && filterPiece("container"))
ret << "Container";
if ((flags & PureVirtualMethod) == PureVirtualMethod && filterPiece("purevirtual"))
ret << "Pure Virtual";
if (flags & VirtualMethod && filterPiece("virtual"))
ret << "Virtual";
if (flags & ConstMethod) {
if (filterPiece("constmethod"))
ret << "ConstMethod";
} else if (flags & StaticMethod && filterPiece("static")) {
ret << "Static";
}
if (flags & Variadic && filterPiece("variadic"))
ret << "Variadic";
if (flags & Auto && filterPiece("auto"))
ret << "Auto";
if (flags & MacroExpansion && filterPiece("macroexpansion"))
ret << "MacroExpansion";
if (flags & TemplateSpecialization && filterPiece("templatespecialization"))
ret << "TemplateSpecialization";
if (flags & TemplateReference && filterPiece("templatereference"))
ret << "TemplateReference";
if (ret.isEmpty())
return String();
return String::join(ret, ' ') + '\n';
};
List<String> bases;
List<String> args;
if (project) {
if (filterPiece("baseclasses")) {
for (const auto &base : baseClasses) {
bool found = false;
for (const auto &sym : project->findByUsr(base, location.fileId(), Project::ArgDependsOn)) {
bases << sym.symbolName;
found = true;
break;
}
if (!found) {
bases << base;
}
}
}
if (filterPiece("arguments")) {
for (const auto &arg : arguments) {
const String symName = project->findSymbol(arg.cursor).symbolName;
if (!symName.isEmpty()) {
args << symName;
} else {
args << arg.cursor.toString(locationToStringFlags & ~Location::ShowContext);
}
}
}
} else if (filterPiece("baseClasses")) {
bases = baseClasses;
}
String ret;
auto writePiece = [&ret, &filterPiece](const char *key, const char *filter, const String &piece) {
if (piece.isEmpty())
return;
if (!filterPiece(filter))
return;
if (key && strlen(key))
ret << key << ": ";
ret << piece << "\n";
};
writePiece(0, "location", location.toString(locationToStringFlags));
writePiece("SymbolName", "symbolname", symbolName);
writePiece("Kind", "kind", kindSpelling());
if (filterPiece("type")) {
if (!typeName.isEmpty()) {
ret += "Type: " + typeName + "\n";
} else if (type != CXType_Invalid) {
ret += "Type: " + RTags::eatString(clang_getTypeKindSpelling(type)) + "\n";
}
}
writePiece("SymbolLength", "symbollength", std::to_string(symbolLength));
if (startLine != -1)
writePiece("Range", "range", String::format<32>("%d:%d-%d:%d", startLine, startColumn, endLine, endColumn));
#if CINDEX_VERSION_MINOR > 1
if (kind == CXCursor_EnumConstantDecl)
writePiece("Enum Value", "enumvalue",
String::format<32>("%lld/0x%0llx", static_cast<long long>(enumValue), static_cast<long long>(enumValue)));
if (isDefinition() && RTags::isFunction(kind))
writePiece("Stack cost", "stackcost", std::to_string(stackCost));
#endif
writePiece(0, "linkage", linkageSpelling(linkage));
ret += properties();
writePiece("Usr", "usr", usr);
if (size)
writePiece("sizeof", "sizeof", std::to_string(size));
if (fieldOffset >= 0)
writePiece("Field offset (bits/bytes)", "fieldoffset",
String::format<32>("%d/%d", fieldOffset, fieldOffset / 8));
if (alignment >= 0)
writePiece("Alignment", "alignment", std::to_string(alignment));
if (!args.isEmpty())
writePiece("Arguments", "arguments", String::join(args, ", "));
if (!bases.isEmpty())
writePiece("Base classes", "baseclasses", String::join(bases, ", "));
writePiece("Brief comment", "briefcomment", briefComment);
writePiece("XML comment", "xmlcomment", xmlComment);
if ((cursorInfoFlags & IncludeParents && filterPiece("parent"))
|| (cursorInfoFlags & (IncludeContainingFunction) && filterPiece("cf"))
|| (cursorInfoFlags & (IncludeContainingFunctionLocation) && filterPiece("cfl"))) {
auto syms = project->openSymbols(location.fileId());
uint32_t idx = -1;
if (syms) {
idx = syms->lowerBound(location);
if (idx == std::numeric_limits<uint32_t>::max()) {
idx = syms->count() - 1;
}
}
const unsigned int line = location.line();
const unsigned int column = location.column();
while (idx-- > 0) {
const Symbol s = syms->valueAt(idx);
if (s.isDefinition()
&& s.isContainer()
&& comparePosition(line, column, s.startLine, s.startColumn) >= 0
&& comparePosition(line, column, s.endLine, s.endColumn) <= 0) {
if (cursorInfoFlags & IncludeContainingFunctionLocation)
writePiece("Containing function location", "cfl", s.location.toString(locationToStringFlags));
if (cursorInfoFlags & IncludeContainingFunction)
writePiece("Containing function", "cf", s.symbolName);
if (cursorInfoFlags & IncludeParents)
writePiece("Parent", "parent", s.location.toString(locationToStringFlags)); // redundant, this is a mess
break;
}
}
}
if (cursorInfoFlags & IncludeTargets && project && filterPiece("targets")) {
const auto targets = project->findTargets(*this);
if (targets.size()) {
ret.append("Targets:\n");
auto best = RTags::bestTarget(targets);
ret.append(String::format<128>(" %s\n", best.location.toString(locationToStringFlags).constData()));
for (const auto &tit : targets) {
if (tit.location != best.location)
ret.append(String::format<128>(" %s\n", tit.location.toString(locationToStringFlags).constData()));
}
}
}
if (cursorInfoFlags & IncludeReferences && project && !isReference() && filterPiece("references")) {
const auto references = project->findCallers(*this);
if (references.size()) {
ret.append("References:\n");
for (const auto &r : references) {
ret.append(String::format<128>(" %s\n", r.location.toString(locationToStringFlags).constData()));
}
}
}
return ret;
}
// TODO null signals function but are not printed out quite right
// because sometimes the parent's null signal is used and sometimes not
void MLProc::dumpProc(int indent)
{
int ins = getNumInputs();
int outs = getNumOutputs();
const MLSignal* pNullInput = &(getContext()->getNullInput());
const MLSignal* pNullOutput = &(getContext()->getNullOutput());
debug() << spaceStr(indent) << getName() << " (" << getClassName() << " " << (void *)&(*this) << ")";
if (isContainer())
{
std::string enabledStr = isEnabled() ? " [ENABLED] " : " [DISABLED] ";
debug() << enabledStr;
}
debug() << "\n";
debug() << spaceStr(indent) << "inputs: ";
if (ins)
{
for(int j = 1; j <= ins; ++j)
{
debug() << "[" << j << "] ";
const MLSignal* pIn = &getInput(j);
if (pIn == pNullInput)
{
debug() << "(null) ";
}
else
{
debug() << "(" << (void *)(pIn) << ") ";
}
}
}
else
{
debug() << "(none)";
}
debug() << "\n";
debug() << spaceStr(indent) << "outputs: ";
if (outs)
{
for(int j = 1; j <= outs; ++j)
{
debug() << "[" << j << "] ";
const MLSignal* pOut = &getOutput(j);
if(pOut == pNullOutput)
{
debug() << "(null) ";
}
else
{
// can no longer determine isConstant here because signals are shared.
debug() << "(" << (void *)(pOut) << ") ";
}
}
}
else
{
debug() << "(none)";
}
debug() << "\n";
}
static void createTag (tokenInfo *const token)
{
tagEntryInfo tag;
verilogKind kind;
/* Determine if kind is prototype */
if (currentContext->prototype)
{
kind = K_PROTOTYPE;
}
else
{
kind = token->kind;
}
/* Do nothing it tag name is empty or tag kind is disabled */
if (vStringLength (token->name) == 0 || ! kindEnabled (kind))
{
return;
}
/* Create tag */
initTagEntry (&tag,
vStringValue (token->name),
kindFromKind (kind));
tag.lineNumber = token->lineNumber;
tag.filePosition = token->filePosition;
verbose ("Adding tag %s (kind %d)", vStringValue (token->name), kind);
if (currentContext->kind != K_UNDEFINED)
{
verbose (" to context %s\n", vStringValue (currentContext->name));
currentContext->lastKind = kind;
tag.extensionFields.scopeKind = kindFromKind (currentContext->kind);
tag.extensionFields.scopeName = vStringValue (currentContext->name);
}
verbose ("\n");
if (vStringLength (token->inheritance) > 0)
{
tag.extensionFields.inheritance = vStringValue (token->inheritance);
verbose ("Class %s extends %s\n", vStringValue (token->name), tag.extensionFields.inheritance);
}
makeTagEntry (&tag);
if (isXtagEnabled(XTAG_QUALIFIED_TAGS) && currentContext->kind != K_UNDEFINED)
{
vString *const scopedName = vStringNew ();
vStringCopy (scopedName, currentContext->name);
vStringPut (scopedName, '.');
vStringCatS (scopedName, vStringValue (token->name));
tag.name = vStringValue (scopedName);
markTagExtraBit (&tag, XTAG_QUALIFIED_TAGS);
makeTagEntry (&tag);
vStringDelete (scopedName);
}
/* Push token as context if it is a container */
if (isContainer (token))
{
tokenInfo *newScope = newToken ();
vStringCopy (newScope->name, token->name);
newScope->kind = kind;
createContext (newScope);
}
/* Clear no longer required inheritance information */
vStringClear (token->inheritance);
}
String Symbol::toString(Flags<ToStringFlag> cursorInfoFlags,
Flags<Location::ToStringFlag> locationToStringFlags,
const std::shared_ptr<Project> &project) const
{
auto properties = [this]()
{
List<String> ret;
if (isDefinition())
ret << "Definition";
if (isContainer())
ret << "Container";
if ((flags & PureVirtualMethod) == PureVirtualMethod) {
ret << "Pure Virtual";
} else if (flags & VirtualMethod) {
ret << "Virtual";
}
if (flags & ConstMethod) {
ret << "Const";
} else if (flags & StaticMethod) {
ret << "Static";
}
if (flags & Variadic)
ret << "Variadic";
if (flags & Auto)
ret << "Auto";
if (flags & AutoRef)
ret << "AutoRef";
if (flags & MacroExpansion)
ret << "MacroExpansion";
if (flags & TemplateSpecialization)
ret << "TemplateSpecialization";
if (ret.isEmpty())
return String();
String joined = String::join(ret, ' ');
joined += '\n';
return joined;
};
List<String> bases;
List<String> args;
if (project) {
for (const auto &base : baseClasses) {
bool found = false;
for (const auto &sym : project->findByUsr(base, location.fileId(), Project::ArgDependsOn, location)) {
bases << sym.symbolName;
found = true;
break;
}
if (!found) {
bases << base;
}
}
for (const auto &arg : arguments) {
const String symName = project->findSymbol(arg.cursor).symbolName;
if (!symName.isEmpty()) {
args << symName;
} else {
args << arg.cursor.toString(locationToStringFlags & ~Location::ShowContext);
}
}
} else {
bases = baseClasses;
}
auto printTypeName = [this]() {
String str;
if (!typeName.isEmpty()) {
str = typeName;
} else if (type != CXType_Invalid) {
str = RTags::eatString(clang_getTypeKindSpelling(type));
} else {
return String();
}
return String::format<128>("Type: %s\n", str.constData());
};
String ret = String::format<1024>("%s\n"
"SymbolName: %s\n"
"Kind: %s\n"
"%s" // type
"SymbolLength: %u\n"
"%s" // range
"%s" // enumValue/stackCost
"%s" // linkage
"%s" // properties
"%s" // usr
"%s" // sizeof
"%s" // fieldoffset
"%s" // alignment
"%s" // arguments
"%s" // baseclasses
"%s" // briefComment
"%s", // xmlComment
location.toString(locationToStringFlags).constData(),
symbolName.constData(),
kindSpelling().constData(),
printTypeName().constData(),
symbolLength,
startLine != -1 ? String::format<32>("Range: %d:%d-%d:%d\n", startLine, startColumn, endLine, endColumn).constData() : "",
#if CINDEX_VERSION_MINOR > 1
(kind == CXCursor_EnumConstantDecl
? String::format<32>("Enum Value: %lld/0x%0llx\n",
static_cast<long long>(enumValue),
static_cast<long long>(enumValue)).constData()
: (isDefinition() && RTags::isFunction(kind)
? String::format<32>("Stack cost: %d\n", stackCost).constData()
: "")),
#else
"",
#endif
linkageSpelling(linkage),
properties().constData(),
usr.isEmpty() ? "" : String::format<64>("Usr: %s\n", usr.constData()).constData(),
size > 0 ? String::format<16>("sizeof: %d\n", size).constData() : "",
fieldOffset >= 0 ? String::format<32>("field offset (bits/bytes): %d/%d\n", fieldOffset, fieldOffset / 8).constData() : "",
alignment >= 0 ? String::format<32>("alignment (bytes): %d\n", alignment).constData() : "",
args.isEmpty() ? "" : String::format<1024>("Arguments: %s\n", String::join(args, ", ").constData()).constData(),
bases.isEmpty() ? "" : String::format<64>("BaseClasses: %s\n", String::join(bases, ", ").constData()).constData(),
briefComment.isEmpty() ? "" : String::format<1024>("Brief comment: %s\n", briefComment.constData()).constData(),
xmlComment.isEmpty() ? "" : String::format<16384>("XML comment: %s\n", xmlComment.constData()).constData());
if (cursorInfoFlags & IncludeTargets && project) {
const auto targets = project->findTargets(*this);
if (targets.size()) {
ret.append("Targets:\n");
auto best = RTags::bestTarget(targets);
ret.append(String::format<128>(" %s\n", best.location.toString(locationToStringFlags).constData()));
for (const auto &tit : targets) {
if (tit.location != best.location)
ret.append(String::format<128>(" %s\n", tit.location.toString(locationToStringFlags).constData()));
}
}
}
if (cursorInfoFlags & IncludeReferences && project && !isReference()) {
const auto references = project->findCallers(*this);
if (references.size()) {
ret.append("References:\n");
for (const auto &r : references) {
ret.append(String::format<128>(" %s\n", r.location.toString(locationToStringFlags).constData()));
}
}
}
return ret;
}
void KMLVector::findLayers(KMLNode* poNode, int bKeepEmptyContainers)
{
bool bEmpty = true;
// Start with the trunk
if( nullptr == poNode )
{
nNumLayers_ = 0;
poNode = poTrunk_;
}
if( isFeature(poNode->getName())
|| isFeatureContainer(poNode->getName())
|| ( isRest(poNode->getName())
&& poNode->getName().compare("kml") != 0 ) )
{
return;
}
else if( isContainer(poNode->getName()) )
{
for( int z = 0; z < (int) poNode->countChildren(); z++ )
{
if( isContainer(poNode->getChild(z)->getName()) )
{
findLayers(poNode->getChild(z), bKeepEmptyContainers);
}
else if( isFeatureContainer(poNode->getChild(z)->getName()) )
{
bEmpty = false;
}
}
if( bKeepEmptyContainers && poNode->getName() == "Folder" )
{
if (!bEmpty)
poNode->eliminateEmpty(this);
}
else if(bEmpty)
{
return;
}
Nodetype nodeType = poNode->getType();
if( bKeepEmptyContainers ||
isFeature(Nodetype2String(nodeType)) ||
nodeType == Mixed ||
nodeType == MultiGeometry || nodeType == MultiPoint ||
nodeType == MultiLineString || nodeType == MultiPolygon)
{
poNode->setLayerNumber(nNumLayers_++);
papoLayers_ = static_cast<KMLNode**>(
CPLRealloc(papoLayers_, nNumLayers_ * sizeof(KMLNode*)) );
papoLayers_[nNumLayers_ - 1] = poNode;
}
else
{
CPLDebug( "KML", "We have a strange type here for node %s: %s",
poNode->getName().c_str(),
Nodetype2String(poNode->getType()).c_str() );
}
}
else
{
CPLDebug( "KML",
"There is something wrong! Define KML_DEBUG to see details");
if( CPLGetConfigOption("KML_DEBUG", nullptr) != nullptr )
print();
}
}
