void DeclareFunctionInScope(std::string name,
SgType *type,
SgScopeStatement *scope) {
// Return if already declared in scope
SgName sname(name);
if (scope->get_symbol_table()->find_any(sname, NULL, NULL)) {
return;
}
SgFunctionParameterTypeList *parms =
SageBuilder::buildFunctionParameterTypeList();
SgFunctionDeclaration *func =
SageBuilder::buildNondefiningFunctionDeclaration(
name,
type,
SageBuilder::buildFunctionParameterList(parms),
scope);
SageInterface::setExtern(func);
if (!debugHooks) {
func->unsetOutputInCodeGeneration();
}
return;
}
bool StatsSet::setUInt64( const char *name, unsigned long long int val )
{
std::string sname( name );
wchar_t wval[32];
swprintf( wval, 31, L"%I64u", val );
std::wstring v( wval );
m_map[name] = v;
return true;
}
bool StatsSet::setDouble( const char *name, double val )
{
std::string sname( name );
wchar_t wval[32];
swprintf( wval, 31, L"%0.20f", val );
std::wstring v( wval );
m_map[name] = v;
return true;
}
bool StatsSet::setInt( const char *name, int val )
{
std::string sname( name );
wchar_t wval[32];
swprintf( wval, 31, L"%d", val );
std::wstring v( wval );
m_map[name] = v;
return true;
}
result_t LruCache::get(const char *name, v8::Local<v8::Function> updater,
v8::Local<v8::Value> &retVal)
{
static _linkedNode newNode;
v8::Handle<v8::Object> o = wrap();
v8::Handle<v8::String> n = v8::String::NewFromUtf8(Isolate::now()->m_isolate, name);
std::string sname(name);
v8::Handle<v8::Value> a = n;
std::map<std::string, _linkedNode>::iterator find;
cleanup();
while (true)
{
obj_ptr<Event_base> e;
find = m_datas.find(sname);
if (find != m_datas.end())
break;
if (updater.IsEmpty())
return 0;
std::map<std::string, obj_ptr<Event_base> >::iterator padding;
padding = m_paddings.find(sname);
if (padding == m_paddings.end())
{
e = new Event();
padding = m_paddings.insert(std::pair<std::string, obj_ptr<Event_base> >(sname, e)).first;
v8::Local<v8::Value> v = updater->Call(o, 1, &a);
m_paddings.erase(padding);
e->set();
if (v.IsEmpty())
return CALL_E_JAVASCRIPT;
find = m_datas.insert(std::pair<std::string, _linkedNode>(sname, newNode)).first;
insert(find);
if (m_timeout > 0)
find->second.insert.now();
o->SetHiddenValue(n, v);
retVal = v;
return 0;
}
e = padding->second;
e->wait();
}
update(find);
retVal = o->GetHiddenValue(n);
return 0;
}
void HttpProtocol::DecodeCookies(Variant &variables, char *data) {
ASSERT(data && *data);
char *strtok_buf = NULL;
char *var = strtok_r(data, ";", &strtok_buf);
while (var) {
char *val = strchr(var, '=');
// Remove leading spaces from cookie names, needed for multi-cookie
// header where ; can be followed by a space */
while (isspace(*var)) {
var++;
}
if (var != val && *var != '\0') {
if (val) { /* have a value */
int len = val - var;
char *name = url_decode(var, len);
String sname(name, len, AttachString);
++val;
len = strlen(val);
char *value = url_decode(val, len);
if (RuntimeOption::EnableMagicQuotesGpc) {
char *slashedvalue = string_addslashes(value, len);
free(value);
value = slashedvalue;
}
String svalue(value, len, AttachString);
register_variable(variables, (char*)sname.data(), svalue, false);
} else {
int len = strlen(var);
char *name = url_decode(var, len);
String sname(name, len, AttachString);
register_variable(variables, (char*)sname.data(), "", false);
}
}
var = strtok_r(NULL, ";", &strtok_buf);
}
}
Variant InstanceOfExpression::eval(VariableEnvironment &env) const {
Variant obj(m_obj->eval(env));
String sname(m_name->get());
if (sname == "self") {
return instanceOf(obj, FrameInjection::GetClassName(false));
} else if (sname == "parent") {
return instanceOf(obj, FrameInjection::GetParentClassName(false));
}
String name(m_name->get(env));
return instanceOf(obj, name);
}
void HttpProtocol::DecodeParameters(Variant &variables, const char *data,
int size, bool post /* = false */) {
if (data == NULL || size == 0) {
return;
}
const char *s = data;
const char *e = s + size;
const char *p, *val;
while (s < e && (p = (const char *)memchr(s, '&', (e - s)))) {
last_value:
if ((val = (const char *)memchr(s, '=', (p - s)))) {
int len = val - s;
char *name = url_decode(s, len);
String sname(name, len, AttachString);
val++;
len = p - val;
char *value = url_decode(val, len);
if (RuntimeOption::EnableMagicQuotesGpc) {
char *slashedvalue = string_addslashes(value, len);
free(value);
value = slashedvalue;
}
String svalue(value, len, AttachString);
register_variable(variables, (char*)sname.data(), svalue);
} else if (!post) {
int len = p - s;
char *name = url_decode(s, len);
String sname(name, len, AttachString);
register_variable(variables, (char*)sname.data(), "");
}
s = p + 1;
}
if (s < e) {
p = e;
goto last_value;
}
}
IMPBENCHMARK_BEGIN_INTERNAL_NAMESPACE
std::string get_benchmarks_name(const char* name) {
std::string sname(name);
std::size_t loc = sname.rfind("benchmark_");
if (loc != std::string::npos) {
return std::string(name + loc + 10);
} else {
int sloc = sname.rfind("/");
return std::string(name + sloc);
}
}
//________________________________________________________________
Bool_t KVFAZIADetector::SetProperties()
{
// detector name are assumed to be defined as
// SI2-T2-Q2-B001
// CSI-T2-Q2-B001
// SI1-T1-Q1-B001
//
KVString tmp;
KVString sname(GetName());
sname.Begin("-");
SetLabel(sname.Next());
gFazia->AddDetectorLabel(GetLabel());
tmp = sname.Next(); tmp.ReplaceAll("T",""); fTelescope = tmp.Atoi();
tmp = sname.Next(); tmp.ReplaceAll("Q",""); fQuartet = tmp.Atoi();
tmp = sname.Next(); tmp.ReplaceAll("B",""); fBlock = tmp.Atoi();
KVSignal* sig=0;
//"QH1", "I1", "QL1", "Q2", "I2", "Q3
if (fSignals)
delete fSignals;
fSignals = new KVList(kTRUE);
KVString lsignals="";
if ( !strcmp(GetLabel(),"SI1") ) { lsignals="QH1,I1,QL1"; }
else if ( !strcmp(GetLabel(),"SI2" ) ) { lsignals="Q2,I2"; }
else if ( !strcmp(GetLabel(),"CSI" ) ) { lsignals="Q3"; }
else{
Warning("SetProperties","Unknown label \"%s\" for this detector : %s\n",GetLabel(),GetName());
lsignals="";
}
lsignals.Begin(",");
while ( !lsignals.End() )
{
KVString ssig = lsignals.Next();
if (ssig.BeginsWith("Q")){
sig = new KVChargeSignal(ssig.Data());
}
else if (ssig.BeginsWith("I")){
sig = new KVCurrentSignal(ssig.Data());
}
else{
Warning("unknown format signal detectorlabel=%s, signal=%s\n",GetLabel(),ssig.Data());
sig = new KVSignal(ssig.Data(),"unknown");
}
sig->LoadPSAParameters(GetLabel());
sig->SetDetectorName(GetName());
fSignals->Add(sig);
}
return kTRUE;
}
bool StatsSet::getWString( const char *name, std::wstring& val, std::wstring& defVal )
{
std::string sname( name );
std::map<std::string, std::wstring>::const_iterator iter = m_map.find( sname );
if( iter == m_map.end() )
{
val = defVal;
return true;
}
val = iter->second;
return true;
}
bool StatsSet::getWString( const char *name, std::wstring& val )
{
std::string sname( name );
std::map<std::string, std::wstring>::const_iterator iter = m_map.find( sname );
if( iter == m_map.end() )
{
throw Exception( "StatsSet: trying to get non-existent WString var [%s] with no default value!", name );
//return false; // warning C4702: unreachable code
}
val = iter->second;
return true;
}
bool StatsSet::setString( const char *name, std::string& val )
{
std::string sname( name );
wchar_t *wval = (wchar_t *)malloc( (val.size()+16) * sizeof(wchar_t) );
if( wval )
{
swprintf( wval, val.size()+1, L"%S", val.c_str() );
std::wstring v( wval );
m_map[sname] = v;
free( wval );
return true;
}
return false;
}
/**
* @brief Get the username of a friend
*/
QString Core::getFriendUsername(uint32_t friendnumber) const
{
size_t namesize = tox_friend_get_name_size(tox, friendnumber, nullptr);
if (namesize == SIZE_MAX) {
qWarning() << "getFriendUsername: Failed to get name size for friend " << friendnumber;
return QString();
}
uint8_t* name = new uint8_t[namesize];
tox_friend_get_name(tox, friendnumber, name, nullptr);
ToxString sname(name, namesize);
delete[] name;
return sname.getQString();
}
bool CMaxMesh::AddBoneInfluence(CSkeletonCandidate *pSkeletonCandidate, CVertexCandidate *pVertexCandidate, INode *pNode, float weight)
{
// get the bone id of the bone from the skeleton candidate
int boneId;
TCHAR const *tname = pNode->GetName();
std::string sname(tname, tname + _tcslen(tname));
boneId = pSkeletonCandidate->GetBoneId(sname.c_str());
if(boneId == -1) return false;
// add the influence to the vertex candidate
pVertexCandidate->AddInfluence(boneId, weight);
return true;
}
bool StatsSet::getBool( const char *name, bool *val, bool defVal )
{
std::wstring value;
std::string sname( name );
std::map<std::string, std::wstring>::const_iterator iter = m_map.find( sname );
if( iter == m_map.end() )
{
(*val) = defVal;
return true;
}
value = iter->second;
int i = 0;
swscanf( value.c_str(), L"%d", &i );
(*val) = (bool)(i != 0);
return true; // defVal funcs never return false and never throw exceptions
}
bool StatsSet::getBool( const char *name, bool *val )
{
std::wstring value;
std::string sname( name );
std::map<std::string, std::wstring>::const_iterator iter = m_map.find( sname );
if( iter == m_map.end() )
{
throw Exception( "StatsSet: trying to get non-existent Bool var [%s] with no default value!", name );
//return false; // warning C4702: unreachable code
}
value = iter->second;
int i = 0;
swscanf( value.c_str(), L"%d", &i );
(*val) = (bool)(i != 0);
return true;
}
int test_Factory_helper::dyncastMatrix(fei::Matrix* matrix,
const char* libname)
{
std::string sname(libname);
if (sname == "TEST_LSC") {
fei::Matrix_Impl<LinearSystemCore>* smatrix2 =
dynamic_cast<fei::Matrix_Impl<LinearSystemCore>*>(matrix);
if (smatrix2 == NULL) {
FEI_CERR << "dynamic_cast<fei::Matrix_Impl<LinearSystemCore>*> failed"<<FEI_ENDL;
ERReturn(-1);
}
}
if (sname == "Aztec") {
#ifdef HAVE_FEI_AZTECOO
fei::Matrix_Impl<LinearSystemCore>* smatrix =
dynamic_cast<fei::Matrix_Impl<LinearSystemCore>*>(matrix);
if (smatrix == NULL) {
FEI_CERR << "dynamic_cast<fei::Matrix_Impl<LinearSystemCore>*> failed"<<FEI_ENDL;
ERReturn(-1);
}
#else
FEI_CERR << "libname==Aztec but HAVE_FEI_AZTECOO not defined."<<FEI_ENDL;
ERReturn(-1);
#endif
}
if (sname == "Trilinos") {
#ifdef HAVE_FEI_EPETRA
fei::Matrix_Impl<Epetra_CrsMatrix>* smatrix =
dynamic_cast<fei::Matrix_Impl<Epetra_CrsMatrix>*>(matrix);
if (smatrix == NULL) {
FEI_CERR << "dynamic_cast<fei::Matrix_Impl<Epetra_CrsMatrix>*> failed"<<FEI_ENDL;
ERReturn(-1);
}
#else
FEI_CERR << "libname==Trilinos but HAVE_FEI_EPETRA not defined."<<FEI_ENDL;
ERReturn(-1);
#endif
}
return(0);
}
void CreateFile(const char *fname)
{
TFile *example = (TFile*)gROOT->ProcessLineFast("hsimple(1)");
if (!example) return;
TH1F *hpx = (TH1F*)example->Get("hpx");
hpx->SetName("hpx1");
TFile::Cp(example->GetName(), fname);
TFile *file = TFile::Open(fname, "UPDATE");
file->mkdir("folder")->cd();
hpx->Write();
file->Close();
example->Close();
TString sname(fname);
if (sname.Contains("000")) {
TFile::Cp(fname, "original.root");
TFile::Open("original.root");
}
}
ObjectServer::ObjectServer(const char *name, string_map_t *options)
: FileServer(name, options), m_enable_readdir(false)
{
string sname("_");
sname += name;
const char *submodule = get_string(*options, "Submodule");
if (submodule == NULL)
{
submodule = "default";
}
m_submodule = submodule;
m_server = Modules::instance()->new_instance(submodule, sname.c_str(), options);
if (!m_server)
{
_FATAL("Can not create server module %s", submodule);
}
ASSERT(m_server);
}
static v8::Handle<v8::Value> add_field(const v8::Arguments& args, Osmium::Export::Shapefile* shapefile) {
if (args.Length() < 3 || args.Length() > 4) {
throw std::runtime_error("Wrong number of arguments to add_field method.");
}
v8::String::Utf8Value name(args[0]);
std::string sname(*name);
v8::String::Utf8Value type(args[1]);
std::string stype(*type);
int width = args[2]->Int32Value();
int decimals = (args.Length() == 4) ? args[3]->Int32Value() : 0;
shapefile->add_field(sname, stype, width, decimals);
return v8::Integer::New(1);
}
int test_Factory_helper::dyncastVector(fei::Vector* vector,
const char* libname)
{
std::string sname(libname);
if (sname == "TEST_LSC") {
fei::Vector_Impl<LinearSystemCore>* svector =
dynamic_cast<fei::Vector_Impl<LinearSystemCore>*>(vector);
if (svector == NULL) {
FEI_CERR << "dynamic_cast<fei::Vector_Impl<LinearSystemCore>*> failed"<<FEI_ENDL;
ERReturn(-1);
}
}
if (sname == "Aztec") {
#ifdef HAVE_FEI_AZTECOO
fei::Vector_Impl<LinearSystemCore>* svector =
dynamic_cast<fei::Vector_Impl<LinearSystemCore>*>(vector);
if (svector == NULL) {
FEI_CERR << "dynamic_cast<fei::Vector_Impl<LinearSystemCore>*> failed"<<FEI_ENDL;
ERReturn(-1);
}
#else
FEI_CERR << "libname==Aztec but HAVE_FEI_AZTECOO not defined."<<FEI_ENDL;
ERReturn(-1);
#endif
}
if (sname == "Trilinos") {
#ifdef HAVE_FEI_EPETRA
fei::Vector_Impl<Epetra_MultiVector>* svector =
dynamic_cast<fei::Vector_Impl<Epetra_MultiVector>*>(vector);
if (svector == NULL) {
FEI_CERR << "dynamic_cast<fei::Vector_Impl<Epetra_MultiVector>*> failed"<<FEI_ENDL;
ERReturn(-1);
}
#else
FEI_CERR << "libname==Trilinos but HAVE_FEI_EPETRA not defined."<<FEI_ENDL;
ERReturn(-1);
#endif
}
return(0);
}
bool StatsSet::getInt64( const char *name, long long int *val )
{
std::wstring value;
std::string sname( name );
std::map<std::string, std::wstring>::const_iterator iter = m_map.find( sname );
if( iter == m_map.end() )
{
throw Exception( "StatsSet: trying to get non-existent Int64 var [%s] with no default value!", name );
//return false; // warning C4702: unreachable code
}
value = iter->second;
long long int i64 = 0;
int r = swscanf( value.c_str(), L"%I64d", &i64 );
if( r == 1 )
{
(*val) = i64;
return true;
}
throw Exception( "StatsSet.getInt: failed to scanf %%I64d from [%s]=[%S]", name, value.c_str() );
}
CTexture* ShaderDX::getConstTexture(const char *argName){
String sname(argName);
std::vector<String> names;
sname.split(':', names);
if (names[0][0] && names[1] && '.' == names[0][2]){
if ('v' == names[0][0])
return (CTexture*)new UniformVSTexture(this, vResourcesRef[names[0]], vSamplerRef[names[1]]);
else if ('p' == names[0][0])
return (CTexture*)new UniformPSTexture(this, pResourcesRef[names[0]], pSamplerRef[names[1]]);
else if ('g' == names[0][0])
return (CTexture*)new UniformGSTexture(this, gResourcesRef[names[0]], gSamplerRef[names[1]]);
else
return nullptr;
}
else{
return (CTexture*)new UniformVSTexture(this, vVariablesRef[String("vs.") + names[0]], vSamplerRef[names[1]]);
}
}
void DNSSDPluginAPI::browse_callback(DNSServiceRef sdref,
DNSServiceFlags flags,
uint32_t ifnum,
DNSServiceErrorType err,
const char* name,
const char* type,
const char* domain,
void* context) {
if (context == NULL) return;
if (err == kDNSServiceErr_NoError) {
bool add = flags & kDNSServiceFlagsAdd ? true : false;
std::string sname(name);
std::string stype(type);
std::string sdomain(domain);
FB::VariantMap info = FB::variant_map_of<std::string>("add",add)
("ifnum",ifnum)("name",sname)("type",stype)("domain",sdomain);
static_cast<DNSSDPluginOp*>(context)->result(info);
} else {
static_cast<DNSSDPluginOp*>(context)->error("browse_callback",
(int64_t) err);
}
}
std::string GlobalizationNDK::getLocaleName()
{
const Locale& loc = Locale::getDefault();
const char* name = loc.getName();
if (name) {
std::string sname(name);
size_t pos = sname.find_first_of("_");
if (pos != std::string::npos)
sname.replace(pos, 1, "-");
return resultInJson(sname);
}
const char* lang = loc.getLanguage();
if (!lang)
return resultInJson("en"); // FIXME: what should be the default language?
const char* country = loc.getCountry();
if (!country)
return resultInJson(lang);
return resultInJson(std::string(lang) + "-" + country);
}
bool StatsSet::getString( const char *name, std::string& val )
{
std::wstring ws;
std::string sname( name );
std::map<std::string, std::wstring>::const_iterator iter = m_map.find( sname );
if( iter == m_map.end() )
{
throw Exception( "StatsSet: trying to get non-existent String var [%s] with no default value!", name );
//return false; // warning C4702: unreachable code
}
ws = iter->second;
const wchar_t *cws = ws.c_str(); // get wchar_t *
char *c_tmp = (char *)malloc( ws.size() + 16 ); // allocate space for Unicode -> ANSI convert
if( c_tmp )
{
l2c_unicode_to_ansi( cws, c_tmp, ws.size()+1 );
c_tmp[ws.size()] = 0;
val.assign( c_tmp, ws.size() );
free( c_tmp );
}
else val.assign( "malloc() failed" );
return true;
}
unsigned int psLight::AttachLight(const char* name, const csVector3& pos,
float radius, const csColor& colour, csRef<iMeshWrapper> mw)
{
baseColour = colour;
csString lightName = name;
lightName.Append("_%u", genUniqueID);
light = engine->CreateLight(lightName, pos, radius, colour, CS_LIGHT_DYNAMICTYPE_DYNAMIC);
light->SetAttenuationMode(CS_ATTN_INVERSE);
// Attach to mesh.
light->QuerySceneNode()->SetParent(mw->QuerySceneNode());
csString sname(mw->GetMovable()->GetSectors()->Get(0)->QueryObject()->GetName());
if(sname.Find("room") == 0)
{
// Add to the podium sector.
podium = engine->GetSectors()->FindByName("room");
if(podium.IsValid()) podium->GetLights()->Add(light);
}
lastTime = vclock->GetCurrentTicks();
return ++genUniqueID;
}
void getParamDumper::analyzerEval(const clang::CallExpr *CE, clang::ento::CheckerContext &C) const {
if ( ! C.getSourceManager().isInMainFile(CE->getExprLoc()) ) return;
const FunctionDecl * FD = CE->getDirectCallee();
if (!FD) return;
std::string mname = support::getQualifiedName(*FD);
const char *sfile=C.getSourceManager().getPresumedLoc(CE->getExprLoc()).getFilename();
std::string sname(sfile);
if ( ! support::isInterestingLocation(sname) ) return;
std::string mdname;
const FunctionDecl * MD = C.getCurrentAnalysisDeclContext()->getDecl()->getAsFunction();
if (!MD) return;
mdname = MD->getQualifiedNameAsString();
for ( unsigned I=0, E=MD->getNumParams(); I != E; ++I) {
std::string ps = "const class edm::ParameterSet ";
std::string ups = "const class edm::UntrackedParameterSet ";
std::string pname = MD->getParamDecl(I)->getQualifiedNameAsString();
std::string qname = MD->getParamDecl(I)->getType().getCanonicalType().getAsString();
// if (qname.substr(0,ps.length()) == ps || qname.substr(0,ups.length()) == ups) {
std::string buf;
llvm::raw_string_ostream os(buf);
os << "in function decl '"<< mdname << "' with parameter '"<< qname << " " << pname <<"'\n";
// }
}
const CXXMemberCallExpr * CXE = llvm::dyn_cast_or_null<CXXMemberCallExpr>(CE);
if (!CXE) return;
const Expr * IOA = CXE->getImplicitObjectArgument();
std::string tname = "getparam-dumper.txt.unsorted";
std::string gp = "edm::ParameterSet::getParameter";
std::string gup = "edm::ParameterSet::getUntrackedParameter";
if (mname.substr(0,gp.length()) == gp || mname.substr(0,gup.length()) == gup ) {
std::string buf;
llvm::raw_string_ostream os(buf);
os << "in function decl '" << mdname << "' member function call '";
clang::LangOptions LangOpts;
LangOpts.CPlusPlus = true;
clang::PrintingPolicy Policy(LangOpts);
os << support::getQualifiedName(*(CXE->getMethodDecl()));
os << "' with args '";
for ( unsigned I=0, E=CE->getNumArgs(); I != E; ++I) {
if (I) os <<", ";
CE->getArg(I)->printPretty(os,0,Policy);
}
os << "' with implicit object '";
const Expr * E = IOA->IgnoreParenNoopCasts(C.getASTContext());
QualType QE = E->getType().getCanonicalType();
os << QE.getAsString()<<" ";
switch( E->getStmtClass() ) {
case Stmt::MemberExprClass:
os << dyn_cast<MemberExpr>(E)->getMemberDecl()->getQualifiedNameAsString();
break;
case Stmt::DeclRefExprClass:
os << dyn_cast<DeclRefExpr>(E)->getDecl()->getQualifiedNameAsString();
break;
case Stmt::CXXOperatorCallExprClass:
dyn_cast<CXXOperatorCallExpr>(E)->printPretty(os,0,Policy);
break;
case Stmt::CXXBindTemporaryExprClass:
dyn_cast<CXXBindTemporaryExpr>(E)->printPretty(os,0,Policy);
break;
case Stmt::CXXMemberCallExprClass:
dyn_cast<CXXMemberCallExpr>(E)->printPretty(os,0,Policy);
break;
case Stmt::UnaryOperatorClass:
dyn_cast<UnaryOperator>(E)->printPretty(os,0,Policy);
break;
default:
E->printPretty(os,0,Policy);
os << " unhandled expr class " <<E->getStmtClassName();
}
os<<"'\n";
support::writeLog(os.str(),tname);
}
return ;
}
void gpWalkAST::VisitCXXMemberCallExpr( clang::CXXMemberCallExpr *CE ) {
const FunctionDecl * FD = CE->getMethodDecl();
if (!FD) return;
std::string mname = FD->getQualifiedNameAsString();
const char *sfile=BR.getSourceManager().getPresumedLoc(CE->getExprLoc()).getFilename();
std::string sname(sfile);
if ( ! support::isInterestingLocation(sname) ) return;
std::string mdname = ND->getQualifiedNameAsString();
const Expr * IOA = CE->getImplicitObjectArgument();
std::string tname = "getparam-dumper.txt.unsorted";
std::string ps = "const class edm::ParameterSet ";
std::string ups = "const class edm::UntrackedParameterSet ";
std::string gp = "edm::ParameterSet::getParameter";
std::string gup = "edm::ParameterSet::getUntrackedParameter";
if (mname.substr(0,gp.length()) == gp || mname.substr(0,gup.length()) == gup ) {
std::string buf;
llvm::raw_string_ostream os(buf);
const NamedDecl * nd = llvm::dyn_cast<NamedDecl>(AC->getDecl());
if ( FunctionDecl::classof(ND) ) {
os << "function decl '" << nd->getQualifiedNameAsString() ;
os << "' this '"<<mdname;
} else {
os << "constructor decl '" << nd->getQualifiedNameAsString() ;
os << "' initializer for member decl '"<<mdname;
}
clang::LangOptions LangOpts;
LangOpts.CPlusPlus = true;
clang::PrintingPolicy Policy(LangOpts);
os << "' with call args '";
for ( unsigned I=0, E=CE->getNumArgs(); I != E; ++I) {
if (I) os <<", ";
os << CE->getType().getCanonicalType().getAsString()<<" ";
CE->getArg(I)->printPretty(os,0,Policy);
}
os << "' with implicit object '";
const Expr * E = IOA->IgnoreParenCasts();
QualType QE = E->getType().getCanonicalType();
os << QE.getAsString()<<" ";
switch( E->getStmtClass() ) {
case Stmt::MemberExprClass:
os << dyn_cast<MemberExpr>(E)->getMemberDecl()->getQualifiedNameAsString();
break;
case Stmt::DeclRefExprClass:
os << dyn_cast<DeclRefExpr>(E)->getDecl()->getQualifiedNameAsString();
break;
case Stmt::CXXOperatorCallExprClass:
dyn_cast<CXXOperatorCallExpr>(E)->printPretty(os,0,Policy);
break;
case Stmt::CXXBindTemporaryExprClass:
dyn_cast<CXXBindTemporaryExpr>(E)->printPretty(os,0,Policy);
break;
case Stmt::CXXMemberCallExprClass:
dyn_cast<CXXMemberCallExpr>(E)->printPretty(os,0,Policy);
break;
case Stmt::UnaryOperatorClass:
dyn_cast<UnaryOperator>(E)->printPretty(os,0,Policy);
break;
default:
E->printPretty(os,0,Policy);
os << " unhandled expr class " <<E->getStmtClassName();
}
os<<"'\n";
support::writeLog(os.str(),tname);
}
return ;
}
