std::string Property::getAsStringOrDefaultVal(const std::string& defaultVal) const { if (getAsString().length() > 0) { return getAsString(); } return defaultVal; }
void InfoControl::audioStreamChanged(){ bool exist = false; int row = audioStream.getActiveItem(exist); if(exist){ auto stream = actualMediaFile->getMediaInfo().getAudioStreams()[row]; audioCodec << getAsString(stream, "", MediaFile::AudioStream::CODEC); audioBitrate << getAsString(stream, "", MediaFile::AudioStream::BITRATE); samplerate << getAsString(stream, "", MediaFile::AudioStream::SAMPLERATE); channels << getAsString(stream, "", MediaFile::AudioStream::CHANNELS); } }
/*! * \brief This method creates a MockDataSet * \return Returns a mocked DataSet that has the required behavior for unittests */ te::da::MockDataSet* createMockDataSet() { te::da::MockDataSet* mockDataSet(new te::da::MockDataSet()); EXPECT_CALL(*mockDataSet, moveNext()).WillRepeatedly(::testing::Return(true)); EXPECT_CALL(*mockDataSet, getAsString(::testing::An<const std::string&>(),::testing::_)).WillRepeatedly(::testing::Return("")); EXPECT_CALL(*mockDataSet, getAsString(::testing::An<std::size_t>(),::testing::_)).WillRepeatedly(::testing::Return("")); EXPECT_CALL(*mockDataSet, isNull(std::string())).WillRepeatedly(::testing::Return(false)); EXPECT_CALL(*mockDataSet, getNumProperties()).WillRepeatedly(::testing::Return(0)); EXPECT_CALL(*mockDataSet, moveFirst()).WillRepeatedly(::testing::Return(true)); return mockDataSet; }
bool HTTPRequest::send() { // CREATE HTTP REQUEST std::string request = getAsString(); std::copy(request.begin(), request.end(), std::back_inserter(out_buffer)); // HINTS FOR SOCKET struct addrinfo hints; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; hints.ai_flags = 0; // SECURE CONNECTION? std::string port = "80"; if(is_secure) { port = "443"; } int r = uv_getaddrinfo(loop, &resolver_req, httpreq_on_resolved, host.c_str(), port.c_str(), &hints); if(r) { printf("ERROR: cannot resolve addres: %s\n", uv_err_name(uv_last_error(loop))); return false; } return true; }
void changeListenerCallback (ChangeBroadcaster* source) override { if (ColourSelector* cs = dynamic_cast<ColourSelector*> (source)) editor.applyNewValue (getAsString (cs->getCurrentColour(), true)); repaint(); }
double Property::getAsDoubleOrDefaultVal(double defaultVal) const { if (getAsString().length() > 0) { return getAsDouble(); } return defaultVal; }
bool Property::getAsBoolOrDefault(bool defaultVal) const { if (getAsString().length() > 0) { return getAsBool(); } return defaultVal; }
int Property::getAsIntOrDefaultVal(int defaultVal) const { if (getAsString().length() > 0) { return getAsInt(); } return defaultVal; }
bool LuaFileFormat::write(Project * project, const std::string & filename){ std::ofstream file(filename.c_str()); if (!file) { error_code = EFFE_IO_ERROR; return false; } file << getAsString(project); file.close(); return true; }
void MemsetZeroLengthCheck::check(const MatchFinder::MatchResult &Result) { const auto *Call = Result.Nodes.getNodeAs<CallExpr>("decl"); // Note, this is: // void *memset(void *buffer, int fill_char, size_t byte_count); // Arg1 is fill_char, Arg2 is byte_count. const Expr *Arg1 = Call->getArg(1); const Expr *Arg2 = Call->getArg(2); // Return if `byte_count` is not zero at compile time. llvm::APSInt Value1, Value2; if (Arg2->isValueDependent() || !Arg2->EvaluateAsInt(Value2, *Result.Context) || Value2 != 0) return; // Return if `fill_char` is known to be zero or negative at compile // time. In these cases, swapping the args would be a nop, or // introduce a definite bug. The code is likely correct. if (!Arg1->isValueDependent() && Arg1->EvaluateAsInt(Value1, *Result.Context) && (Value1 == 0 || Value1.isNegative())) return; // `byte_count` is known to be zero at compile time, and `fill_char` is // either not known or known to be a positive integer. Emit a warning // and fix-its to swap the arguments. auto D = diag(Call->getLocStart(), "memset of size zero, potentially swapped arguments"); SourceRange LHSRange = Arg1->getSourceRange(); SourceRange RHSRange = Arg2->getSourceRange(); StringRef RHSString = getAsString(Result, RHSRange); StringRef LHSString = getAsString(Result, LHSRange); if (LHSString.empty() || RHSString.empty()) return; D << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(LHSRange), RHSString) << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(RHSRange), LHSString); }
// get string representation (for %n and %N), foff is for multi-line formatting offset, -1 = no line breaks // if del is true, then the returned QoreString * should be deleted, if false, then it must not be // the ExceptionSink is only needed for QoreObject where a method may be executed // use the QoreNodeAsStringHelper class (defined in QoreStringNode.h) instead of using this function directly QoreString* QoreValueList::getAsString(bool &del, int foff, ExceptionSink* xsink) const { if (!priv->length && foff != FMT_YAML_SHORT) { del = false; return &EmptyListString; } TempString rv(new QoreString); if (getAsString(*(*rv), foff, xsink)) return 0; del = true; return rv.release(); }
void InfoControl::videoStreamChanged(){ bool exist = false; int row = videoStream.getActiveItem(exist); if(exist){ auto stream = actualMediaFile->getMediaInfo().getVideoStreams()[row]; videoCodec << getAsString(stream, "", MediaFile::VideoStream::CODEC); colorSpace << getAsString(stream, "", MediaFile::VideoStream::COLORSPACE); resolution << (getAsString(stream, "", MediaFile::VideoStream::RESX) + "x" + getAsString(stream, "", MediaFile::VideoStream::RESY)); fps << getAsString(stream, "", MediaFile::VideoStream::FPS); tbr << getAsString(stream, "", MediaFile::VideoStream::TBR); tbn << getAsString(stream, "", MediaFile::VideoStream::TBN); tbc << getAsString(stream, "", MediaFile::VideoStream::TBC); if(stream.isDefault()){ extra << DEFAULT_STREAM; }else{ extra << std::string(); } } }
IntVec IntVec::append(const IntVec& rhs){ IntVec new_vec(getAsString()); //base case if(!rhs.first){return new_vec;} Node* current = rhs.first; new_vec.last->next = new Node; new_vec.last = new_vec.last->next; new_vec.last->i = current->i; while(current->next){ current = current->next; new_vec.last->next = new Node; new_vec.last = new_vec.last->next; new_vec.last->i = current->i; } return new_vec; }
double Property::getAsDouble() const { return stringutil::StringToDouble(getAsString()); }
bool Property::getAsBool() const { return stringutil::StringToBool(getAsString()); }
void OpNewExprHandler::run(const clang::ast_matchers::MatchFinder::MatchResult &result) { const clang::ExplicitCastExpr* castExpr = result.Nodes.getNodeAs<clang::ExplicitCastExpr>("castExpr"); const clang::CallExpr* newExpr = result.Nodes.getNodeAs<clang::CallExpr>("newStmt"); if (nullptr == castExpr) { llvm::errs() << "Couldn't convert MatcherResult to ExplicitCastExpr!\n"; return; } if (nullptr == newExpr) { llvm::errs() << "Couldn't convert MatcherResult to CallExpr!\n"; return; } // Skipping substituted template types auto srcType = castExpr->getTypeInfoAsWritten()->getTypeLoc(); auto ptr = srcType.getType().getTypePtr()->getAs<clang::SubstTemplateTypeParmType>(); if (ptr) { // This is an automatic template specialization. // TODO: add additional checks that this condition is good! TBH I have no idea why it works, I should read more CLANG apidocs :) // I mean: // * partial template specialization // * why isn't a specialized template a substitution? (or maybe it's in the standard?) return; } std::string macroStart = "TYPEGRIND_LOG_OP_NEW"; macroStart += "("; // 1st paramter: name of the type. // Currently it is the concrete name if we can place it in the source without generating a template specialization // otherwise it's based on typeid, so we are missing a demangle function ... auto allocatedType = castExpr->getType()->getPointeeType(); if (allocatedType.getTypePtr()->isTemplateTypeParmType()) { // TODO: somehow add compiler specific demangle ... // We could generate a (manual) specialization for this function, but for now, this is enough // Let's just use type_info::name(), and demangle it somehow runtime... // or maybe create an initialization code dumping the mangled names for all affected specializations? (the ones skipped by the previous return) macroStart += "typeid(" + allocatedType.getAsString() + ").name()"; } else { macroStart += "\"" + allocatedType.getAsString() + "\""; // + (int)allocatedType.getTypePtr()->getAsTagDecl(); } macroStart += ", "; // 2nd parameter: source location. At least this is easy auto& sm = result.Context->getSourceManager(); auto ploc = sm.getPresumedLoc(newExpr->getLocEnd()); macroStart += "\""; macroStart += ploc.getFilename(); macroStart += ":"; macroStart += std::to_string(ploc.getLine()); macroStart += "\", "; // 3rd parameter: the new call. It's the expression itself clang::SourceLocation startLoc = newExpr->getLocStart(); mRewriter->InsertText(startLoc, macroStart); // 4th parameter: sizeof type std::string macroEnd; macroEnd += ", "; macroEnd += "sizeof("; macroEnd += allocatedType.getAsString(); macroEnd += ")"; // 5th argument: size, which is the first argument to the call // TODO: extract it to a variable! macroEnd += ", "; llvm::raw_string_ostream os(macroEnd); newExpr->getArg(0)->printPretty(os, nullptr, clang::PrintingPolicy(result.Context->getPrintingPolicy())); os.flush(); // end added function call macroEnd += ")"; clang::SourceLocation endLoc = newExpr->getLocEnd(); mRewriter->InsertTextAfterToken(endLoc, macroEnd); }
// if del is true, then the returned QoreString* should be deleted, if false, then it must not be QoreString* CallReferenceCallNode::getAsString(bool& del, int foff, ExceptionSink* xsink) const { del = true; QoreString* rv = new QoreString; getAsString(*rv, foff, xsink); return rv; }
const std::string JSONArray::getAsString(const int index, const std::string& defaultValue) const { const JSONString* jsString = getAsString(index); return (jsString == NULL) ? defaultValue : jsString->value(); }
Variable* getAsVariable(types::InternalType* _pIT) { Variable* pOut = NULL; switch (_pIT->getType()) { case types::InternalType::ScilabDouble : { return getAsDouble(_pIT); } case types::InternalType::ScilabString : { return getAsString(_pIT); } case types::InternalType::ScilabBool : { return getAsBoolean(_pIT); } case types::InternalType::ScilabSparse : { return getAsSparse(_pIT); } case types::InternalType::ScilabSparseBool : { //return getAsSparseBool(_pIT); return NULL; } case types::InternalType::ScilabHandle : { return getAsHandle(_pIT); } case types::InternalType::ScilabUserType : { return getAsPointer(_pIT); } case types::InternalType::ScilabList : { return getAsList(_pIT); } case types::InternalType::ScilabMList : { return getAsMList(_pIT); } case types::InternalType::ScilabTList : { return getAsTList(_pIT); } case types::InternalType::ScilabPolynom : { //return getAsPolynom(_pIT); return NULL; } case types::InternalType::ScilabStruct : { //return getAsStruct(_pIT); return NULL; } default: { return NULL; } } return NULL; }
// if del is true, then the returned QoreString * should be deleted, if false, then it must not be QoreString *RegexTransNode::getAsString(bool &del, int foff, ExceptionSink *xsink) const { del = true; QoreString *rv = new QoreString; getAsString(*rv, foff, xsink); return rv; }
/** * \a obj is an expression to a type of an QObject (or pointer to) that is the sender or the receiver * \a method is an expression like SIGNAL(....) or SLOT(....) * * This function try to find the matching signal or slot declaration, and register its use. */ void QtSupport::handleSignalOrSlot(clang::Expr* obj, clang::Expr* method) { if (!obj || !method) return; obj = obj->IgnoreImpCasts(); method = method->IgnoreImpCasts(); auto objType = obj->getType().getTypePtrOrNull(); if (!objType) return; const clang::CXXRecordDecl* objClass = objType->getPointeeCXXRecordDecl(); if (!objClass) { // It can be a non-pointer if called like: foo.connect(....); objClass = objType->getAsCXXRecordDecl(); if (!objClass) return; } const clang::StringLiteral *methodLiteral = clang::dyn_cast<clang::StringLiteral>(method); if (!methodLiteral) { // try qFlagLocation clang::CallExpr *flagLoc = clang::dyn_cast<clang::CallExpr>(method); if (!flagLoc || flagLoc->getNumArgs() != 1 || !flagLoc->getDirectCallee() || flagLoc->getDirectCallee()->getName() != "qFlagLocation") return; methodLiteral = clang::dyn_cast<clang::StringLiteral>(flagLoc->getArg(0)->IgnoreImpCasts()); if (!methodLiteral) return; } if (methodLiteral->getCharByteWidth() != 1) return; auto signature = methodLiteral->getString().trim(); if (signature.size() < 4) return; if (signature.find('\0') != signature.npos) { signature = signature.substr(0, signature.find('\0')).trim(); } auto lParenPos = signature.find('('); auto rParenPos = signature.find(')'); if (rParenPos == std::string::npos || rParenPos < lParenPos || lParenPos < 2) return; llvm::StringRef methodName = signature.slice(1 , lParenPos).trim(); // Try to find the method which match this name in the given class or bases. auto candidates = lookUpCandidates(objClass, methodName); clang::LangOptions lo; lo.CPlusPlus = true; lo.Bool = true; clang::PrintingPolicy policy(lo); policy.SuppressScope = true; auto argPos = lParenPos + 1; unsigned int arg = 0; while (argPos < signature.size() && !candidates.empty()) { // Find next comma to extract the next argument auto searchPos = argPos; while (searchPos < signature.size() && signature[searchPos] != ',' && signature[searchPos] != ')') { if (signature[searchPos] == '<') { int depth = 0; int templDepth = 0; searchPos++; while(searchPos < signature.size() && depth >= 0 && templDepth >= 0) { switch (signature[searchPos]) { case '(': case '[': case '{': depth++; break; case ')': case ']': case '}': depth--; break; case '>': if (depth == 0) templDepth--; break; case '<': if (depth == 0) templDepth++; break; } ++searchPos; } continue; } ++searchPos; } if (searchPos == signature.size()) return; llvm::StringRef argument = signature.substr(argPos, searchPos - argPos).trim(); // Skip the const at the beginning if (argument.startswith("const ") && argument.endswith("&")) argument = argument.slice(6, argument.size()-1).trim(); argPos = searchPos + 1; if (argument.empty() && signature[searchPos] == ')' && arg == 0) break; //No arguments //Now go over the candidates and prune the impossible ones. auto it = candidates.begin(); while (it != candidates.end()) { if ((*it)->getNumParams() < arg + 1) { // Not enough argument it = candidates.erase(it); continue; } auto type = (*it)->getParamDecl(arg)->getType(); // remove const or const & if (type->isReferenceType() && type.getNonReferenceType().isConstQualified()) type = type.getNonReferenceType(); type.removeLocalConst(); auto typeString_ = type.getAsString(policy); auto typeString = llvm::StringRef(typeString_).trim(); // Now compare the two string without mathcin spaces, auto sigIt = argument.begin(); auto parIt = typeString.begin(); while (sigIt != argument.end() && parIt != typeString.end()) { if (*sigIt == *parIt) { ++sigIt; ++parIt; } else if (*sigIt == ' ') { ++sigIt; } else if (*parIt == ' ') { ++parIt; } else if (*sigIt == 'n' && llvm::StringRef(sigIt, 9).startswith("nsigned ")) { // skip unsigned sigIt += 8; } else if (*parIt == 'n' && llvm::StringRef(parIt, 9).startswith("nsigned ")) { // skip unsigned parIt += 8; } else { break; } } if (sigIt != argument.end() || parIt != typeString.end()) { // Did not match. it = candidates.erase(it); continue; } ++it; } arg++; if (signature[searchPos] == ')') break; } if (argPos != signature.size()) return; // Remove candidates that needs more argument candidates.erase(std::remove_if(candidates.begin(), candidates.end(), [=](clang::CXXMethodDecl *it) { return it->getMinRequiredArguments() > arg && !(it->getNumParams() == arg+1 && it->getParamDecl(arg)->getType().getAsString(policy) == "QPrivateSignal"); }), candidates.end()); if (candidates.empty()) return; auto used = candidates.front(); clang::SourceRange range = methodLiteral->getSourceRange(); if (methodLiteral->getNumConcatenated() >= 2) { auto &sm = annotator.getSourceMgr(); // Goes two level up in the macro expension: First level is the # expansion, Second level is SIGNAL macro auto r = sm.getImmediateExpansionRange(methodLiteral->getStrTokenLoc(1)); #if CLANG_VERSION_MAJOR < 7 range = { sm.getImmediateExpansionRange(r.first).first, sm.getImmediateExpansionRange(r.second).second }; #else range = { sm.getImmediateExpansionRange(r.getBegin()).getBegin(), sm.getImmediateExpansionRange(r.getEnd()).getEnd() }; #endif // now remove the SIGNAL or SLOT macro from the range. auto skip = clang::Lexer::MeasureTokenLength(range.getBegin(), sm, annotator.getLangOpts()); range.setBegin(range.getBegin().getLocWithOffset(skip+1)); // remove the ')' while we are on it range.setEnd(range.getEnd().getLocWithOffset(-1)); } annotator.registerUse(used, range, Annotator::Call, currentContext, Annotator::Use_Address); }
//------------------------------------------------------------- void Value::fromBlob ( ValueType type, const Byte *blob ) { int i; // Set type setType( type ); if (blob==NULL) return; switch( type_m ) { case VT_Int: getAsInt() = *(int *) blob; break; case VT_IntList: { int len = *(int *) blob; int *data = ((int *) blob) + 1; IntList &ilist = getAsIntList(); ilist.resize( len ); for(i = 0; i < len; ++i) ilist[ i ] = *data++; break; } case VT_Double: getAsDouble() = *(double *) blob; break; case VT_Date: getAsDate() = *(double *) blob; break; case VT_DoubleList: { int len = *(int *) blob; double *data = (double *) (((int *) blob) + 1); DoubleList &dlist = getAsDoubleList(); dlist.resize( len ); for(i = 0; i < len; ++i) dlist[ i ] = *data++; break; } case VT_DateList: { int len = *(int *) blob; double *data = (double *) (((int *) blob) + 1); DoubleList &dlist = getAsDateList(); dlist.resize( len ); for(i = 0; i < len; ++i) dlist[ i ] = *data++; break; } case VT_String: getAsString() = (Byte *) blob; break; case VT_StringList: { int len = *(int *) blob; Byte *data = (Byte *) (((int *) blob) + 1); StringList &slist = getAsStringList(); slist.resize( len ); for(i = 0; i < len; ++i) { slist[ i ] = data; data += strlen( data ) + 1; } break; } case VT_Uid: getAsUid().fromMemory( (Byte *) blob ); break; case VT_UidList: { int len = *(int *) blob; Byte *data = (Byte *) (((int *) blob) + 1); UidList &slist = getAsUidList(); slist.resize( len ); for(i = 0; i < len; ++i) { slist[ i ].fromMemory( data ); data += Signature::length_scm; } break; } case VT_Reference: getAsReference().fromString( (Byte *) blob ); break; case VT_ReferenceList: { int len = *(int *) blob; Byte *data = (Byte *) (((int *) blob) + 1); ReferenceList &reflist = getAsReferenceList(); reflist.resize( len ); for(i = 0; i < len; ++i) { reflist[ i ].fromString( data ); data += strlen( data ) + 1; } break; } case VT_StringMap: { int len = *(int *) blob; Byte *data = (Byte *) (((int *) blob) + 1); Byte *kdata; StringMap &smap = getAsStringMap(); smap.clear(); for(i = 0; i < len; ++i) { kdata = data; data += strlen( data ) + 1; smap[kdata] = data; data += strlen( data ) + 1; } break; } } }
int Property::getAsInt() const { return stringutil::StringToInt(getAsString()); };
void getQuery(char* destination) { getAsString(ENTER_A_QUERY_IMAGE_OR_TO_TERMINATE, destination); }
// get string representation (for %n and %N), foff is for multi-line formatting offset, -1 = no line breaks // if del is true, then the returned QoreString* should be deleted, if false, then it must not be // the ExceptionSink is only needed for QoreObject where a method may be executed // use the QoreNodeAsStringHelper class (defined in QoreStringNode.h) instead of using this function directly QoreString* DateTimeNode::getAsString(bool& del, int foff, ExceptionSink* xsink) const { del = true; QoreString* str = new QoreString; getAsString(*str, foff, xsink); return str; }
void sliderValueChanged (Slider*) { editor.applyNewValue (isFloat ? getAsString ((double) slider.getValue(), editor.wasHex) : getAsString ((int64) slider.getValue(), editor.wasHex)); }
// if del is true, then the returned QoreString * should be deleted, if false, then it must not be QoreString *SelfVarrefNode::getAsString(bool &del, int foff, ExceptionSink *xsink) const { del = true; QoreString *rv = new QoreString(); getAsString(*rv, foff, xsink); return rv; }
void NonConstReferences::check(const MatchFinder::MatchResult &Result) { const auto *Parameter = Result.Nodes.getNodeAs<ParmVarDecl>("param"); const auto *Function = dyn_cast_or_null<FunctionDecl>(Parameter->getParentFunctionOrMethod()); if (Function == nullptr || Function->isImplicit()) return; if (!Function->isCanonicalDecl()) return; if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { // Don't warn on implementations of an interface using references. if (Method->begin_overridden_methods() != Method->end_overridden_methods()) return; // Don't warn on lambdas, as they frequently have to conform to the // interface defined elsewhere. if (Method->getParent()->isLambda()) return; } auto ReferencedType = *Result.Nodes.getNodeAs<QualType>("referenced_type"); // Don't warn on function references, they shouldn't be constant. if (ReferencedType->isFunctionProtoType()) return; // Don't warn on dependent types in templates. if (ReferencedType->isDependentType()) return; if (Function->isOverloadedOperator()) { switch (Function->getOverloadedOperator()) { case clang::OO_LessLess: case clang::OO_PlusPlus: case clang::OO_MinusMinus: case clang::OO_PlusEqual: case clang::OO_MinusEqual: case clang::OO_StarEqual: case clang::OO_SlashEqual: case clang::OO_PercentEqual: case clang::OO_LessLessEqual: case clang::OO_GreaterGreaterEqual: case clang::OO_PipeEqual: case clang::OO_CaretEqual: case clang::OO_AmpEqual: // Don't warn on the first parameter of operator<<(Stream&, ...), // operator++, operator-- and operation+assignment operators. if (Function->getParamDecl(0) == Parameter) return; break; case clang::OO_GreaterGreater: { auto isNonConstRef = [](clang::QualType T) { return T->isReferenceType() && !T.getNonReferenceType().isConstQualified(); }; // Don't warn on parameters of stream extractors: // Stream& operator>>(Stream&, Value&); // Both parameters should be non-const references by convention. if (isNonConstRef(Function->getParamDecl(0)->getType()) && (Function->getNumParams() < 2 || // E.g. member operator>>. isNonConstRef(Function->getParamDecl(1)->getType())) && isNonConstRef(Function->getReturnType())) return; break; } default: break; } } // Some functions use references to comply with established standards. if (Function->getDeclName().isIdentifier() && Function->getName() == "swap") return; // iostream parameters are typically passed by non-const reference. if (StringRef(ReferencedType.getAsString()).endswith("stream")) return; diag(Parameter->getLocation(), "non-const reference parameter '%0', make it const or use a pointer") << Parameter->getName(); }