int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
if (LHS.getNameKind() != RHS.getNameKind())
return (LHS.getNameKind() < RHS.getNameKind() ? -1 : 1);
switch (LHS.getNameKind()) {
case DeclarationName::Identifier: {
IdentifierInfo *LII = LHS.getAsIdentifierInfo();
IdentifierInfo *RII = RHS.getAsIdentifierInfo();
if (!LII) return RII ? -1 : 0;
if (!RII) return 1;
return LII->getName().compare(RII->getName());
}
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector: {
Selector LHSSelector = LHS.getObjCSelector();
Selector RHSSelector = RHS.getObjCSelector();
unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) {
switch (LHSSelector.getNameForSlot(I).compare(
RHSSelector.getNameForSlot(I))) {
case -1: return true;
case 1: return false;
default: break;
}
}
return compareInt(LN, RN);
}
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
return -1;
if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
return 1;
return 0;
case DeclarationName::CXXOperatorName:
return compareInt(LHS.getCXXOverloadedOperator(),
RHS.getCXXOverloadedOperator());
case DeclarationName::CXXLiteralOperatorName:
return LHS.getCXXLiteralIdentifier()->getName().compare(
RHS.getCXXLiteralIdentifier()->getName());
case DeclarationName::CXXUsingDirective:
return 0;
}
llvm_unreachable("Invalid DeclarationName Kind!");
}
// Selection test
void MD5Surface::testSelect(Selector& selector,
SelectionTest& test,
const Matrix4& localToWorld)
{
test.BeginMesh(localToWorld);
SelectionIntersection best;
test.TestTriangles(
vertexpointer_arbitrarymeshvertex(_vertices.data()),
IndexPointer(_indices.data(), IndexPointer::index_type(_indices.size())),
best
);
if(best.valid()) {
selector.addIntersection(best);
}
}
// ICI l'id du client correspond a l'id du client auquel on veut envoyer les bails
void TCPWinServSocket::SendData(CircularBuff &circbuff, Selector &sel)
{
std::vector<Message> &to_send = circbuff.get_data();
DWORD sentbytes;
WSABUF databuf[3];
char first_buff[4];
char second_buff[4];
char third_buff[256];
databuf[0].len = 4;
databuf[0].buf = first_buff;
databuf[1].len = 4;
databuf[1].buf = second_buff;
databuf[2].len = 256;
databuf[2].buf = third_buff;
//pour tous les messages
for (size_t i = 0; i < to_send.size(); i++)
if (sel.Is_writable(to_send.at(i).get_client().get_socket()))
{
//reset des buffers
memset(&first_buff, '\0', 4);
memset(&second_buff, '\0', 4);
memset(&third_buff, '\0', 256);
// on crée des variables parce qu'on a besoin d'une adresse pour memcpy (donc juste des getters ca suffit pas)
int rq_type = to_send.at(i).get_rq_type();
int data_length = to_send.at(i).get_data_length();
//on rempli nos 3 buffers
memcpy(&first_buff, (char *)&(rq_type), 4);
memcpy(&second_buff, (char *)&(data_length), 4);
memcpy(&third_buff, to_send.at(i).get_packet(), data_length);
// et on les envoi
WSASend(to_send.at(i).get_client().get_socket(), databuf, 3, &sentbytes, 0, NULL, NULL);
delete[] to_send.at(i).get_packet();
}
else
std::cerr << "Corruption possible (1)" << std::endl;
to_send.clear();
}
// ICI l'id du client correspond a l'id du client auquel on veut envoyer les bails
void TCPLinServSocket::SendData(CircularBuff &circbuff, Selector &sel)
{
std::vector<Message> &to_send = circbuff.get_data();
struct iovec databuf[3];
char first_buff[4];
char second_buff[4];
char third_buff[256];
int sentbytes = 0;
databuf[0].iov_len = 4;
databuf[0].iov_base = first_buff;
databuf[1].iov_len = 4;
databuf[1].iov_base = second_buff;
databuf[2].iov_len = 256;
databuf[2].iov_base = third_buff;
//pour tous les messages
for (size_t i = 0; i < to_send.size(); i++)
if (sel.Is_writable(to_send.at(i).get_client().get_socket()))
{
//reset des buffers
memset(&first_buff, '\0', 4);
memset(&second_buff, '\0', 4);
memset(&third_buff, '\0', 256);
// on crée des variables parce qu'on a besoin d'une
//adresse pour memcpy (donc juste des getters ca suffit pas)
int rq_type = to_send.at(i).get_rq_type();
int data_length = to_send.at(i).get_data_length();
//on rempli nos 3 buffers
memcpy(&first_buff, (char *)&(rq_type), 4);
memcpy(&second_buff, (char *)&(data_length), 4);
memcpy(&third_buff, to_send.at(i).get_packet(), data_length);
// et on les envoi
sentbytes = writev(to_send.at(i).get_client().get_socket(), databuf, 3);
delete[] to_send.at(i).get_packet();
}
to_send.clear();
}
void ODRHash::AddDeclarationName(DeclarationName Name) {
AddBoolean(Name.isEmpty());
if (Name.isEmpty())
return;
auto Kind = Name.getNameKind();
ID.AddInteger(Kind);
switch (Kind) {
case DeclarationName::Identifier:
AddIdentifierInfo(Name.getAsIdentifierInfo());
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector: {
Selector S = Name.getObjCSelector();
AddBoolean(S.isNull());
AddBoolean(S.isKeywordSelector());
AddBoolean(S.isUnarySelector());
unsigned NumArgs = S.getNumArgs();
for (unsigned i = 0; i < NumArgs; ++i) {
AddIdentifierInfo(S.getIdentifierInfoForSlot(i));
}
break;
}
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
AddQualType(Name.getCXXNameType());
break;
case DeclarationName::CXXOperatorName:
ID.AddInteger(Name.getCXXOverloadedOperator());
break;
case DeclarationName::CXXLiteralOperatorName:
AddIdentifierInfo(Name.getCXXLiteralIdentifier());
break;
case DeclarationName::CXXConversionFunctionName:
AddQualType(Name.getCXXNameType());
break;
case DeclarationName::CXXUsingDirective:
break;
case DeclarationName::CXXDeductionGuideName: {
auto *Template = Name.getCXXDeductionGuideTemplate();
AddBoolean(Template);
if (Template) {
AddDecl(Template);
}
}
}
}
/// \brief Get a GlobalSelector for the ASTContext-specific selector.
GlobalSelector GlobalSelector::get(Selector Sel, Program &Prog) {
if (Sel.isNull())
return GlobalSelector();
ProgramImpl &ProgImpl = *static_cast<ProgramImpl*>(Prog.Impl);
llvm::SmallVector<IdentifierInfo *, 8> Ids;
for (unsigned i = 0, e = Sel.isUnarySelector() ? 1 : Sel.getNumArgs();
i != e; ++i) {
IdentifierInfo *II = Sel.getIdentifierInfoForSlot(i);
IdentifierInfo *GlobII = &ProgImpl.getIdents().get(II->getName(),
II->getName() + II->getLength());
Ids.push_back(GlobII);
}
Selector GlobSel = ProgImpl.getSelectors().getSelector(Sel.getNumArgs(),
Ids.data());
return GlobalSelector(GlobSel.getAsOpaquePtr());
}
cocoa::NamingConvention cocoa::deriveNamingConvention(Selector S) {
switch (S.getMethodFamily()) {
case OMF_None:
case OMF_autorelease:
case OMF_dealloc:
case OMF_release:
case OMF_retain:
case OMF_retainCount:
return NoConvention;
case OMF_init:
return InitRule;
case OMF_alloc:
case OMF_copy:
case OMF_mutableCopy:
case OMF_new:
return CreateRule;
}
llvm_unreachable("unexpected naming convention");
return NoConvention;
}
// Perform selection test for this surface
void RenderablePicoSurface::testSelect(Selector& selector,
SelectionTest& test,
const Matrix4& localToWorld) const
{
if (!_vertices.empty() && !_indices.empty())
{
// Test for triangle selection
test.BeginMesh(localToWorld);
SelectionIntersection result;
test.TestTriangles(
VertexPointer(&_vertices[0].vertex, sizeof(ArbitraryMeshVertex)),
IndexPointer(&_indices[0],
IndexPointer::index_type(_indices.size())),
result
);
// Add the intersection to the selector if it is valid
if(result.valid()) {
selector.addIntersection(result);
}
}
}
void BLSSS::draw_beta() {
Selector g = m_->coef().inc();
if(g.nvars() == 0) {
m_->drop_all();
return;
}
SpdMatrix ivar = g.select(pri_->siginv());
Vector ivar_mu = ivar * g.select(pri_->mu());
ivar += g.select(suf().xtx());
ivar_mu += g.select(suf().xty());
Vector b = ivar.solve(ivar_mu);
b = rmvn_ivar_mt(rng(), b, ivar);
// If model selection is turned off and some elements of beta
// happen to be zero (because, e.g., of a failed MH step) we don't
// want the dimension of beta to change.
m_->set_included_coefficients(b, g);
}
void BLSSS::draw_beta() {
Selector g = model_->coef().inc();
if (g.nvars() == 0) {
model_->drop_all();
return;
}
SpdMatrix precision = g.select(slab_->siginv());
Vector scaled_mean = precision * g.select(slab_->mu());
precision += g.select(suf().xtx());
Cholesky precision_cholesky_factor(precision);
scaled_mean += g.select(suf().xty());
Vector posterior_mean = precision_cholesky_factor.solve(scaled_mean);
Vector beta = rmvn_precision_upper_cholesky_mt(
rng(), posterior_mean, precision_cholesky_factor.getLT());
// If model selection is turned off and some elements of beta
// happen to be zero (because, e.g., of a failed MH step) we don't
// want the dimension of beta to change.
model_->set_included_coefficients(beta, g);
}
Specificity Wt::Render::Match::isMatch(const Block* block, const Selector& selector)
{
if(!selector.size())
return Specificity(false);
if(!isMatch(block, selector.at(selector.size()-1)))
return Specificity(false);
const Block* parent = block->parent();
for(int i = selector.size()-2; i >= 0; --i)
{
bool matchFound;
while(parent)
{
matchFound = isMatch(parent, selector.at(i));
parent = parent->parent();
if(matchFound)
break;
}
if(!matchFound && !parent)
return Specificity(false);
}
return selector.specificity();
}
void EventTest::Func2( uint32_t p1, uint16_t p2 )
{
TRACE_BEGIN( LOG_LVL_INFO );
mSelector->sendEventSync( jh_new Event2( p1, p2 ) );
}
void EventTest::Func1()
{
TRACE_BEGIN( LOG_LVL_INFO );
mSelector->sendEvent( jh_new Event1() );
}
bool
VanillaProc::JobReaper(int pid, int status)
{
dprintf(D_FULLDEBUG,"Inside VanillaProc::JobReaper()\n");
//
// Run all the reapers first, since some of them change the exit status.
//
if( m_pid_ns_status_filename.length() > 0 ) {
status = pidNameSpaceReaper( status );
}
bool jobExited = OsProc::JobReaper( pid, status );
if( pid != JobPid ) { return jobExited; }
#if defined(LINUX)
// On newer kernels if memory.use_hierarchy==1, then we cannot disable
// the OOM killer. Hence, we have to be ready for a SIGKILL to be delivered
// by the kernel at the same time we get the notification. Hence, if we
// see an exit signal, we must also check the event file descriptor.
//
// outOfMemoryEvent() is aware of checkpointing and will mention that
// the OOM event happened during a checkpoint.
int efd = -1;
if( (m_oom_efd >= 0) && daemonCore->Get_Pipe_FD(m_oom_efd, &efd) && (efd != -1) ) {
Selector selector;
selector.add_fd(efd, Selector::IO_READ);
selector.set_timeout(0);
selector.execute();
if( !selector.failed() && !selector.timed_out() && selector.has_ready() && selector.fd_ready(efd, Selector::IO_READ) ) {
outOfMemoryEvent( m_oom_efd );
}
}
#endif
//
// We have three cases to consider:
// * if we're checkpointing; or
// * if we see a special checkpoint exit code; or
// * there's no special case to consider.
//
bool wantsFileTransferOnCheckpointExit = false;
JobAd->LookupBool( ATTR_WANT_FT_ON_CHECKPOINT, wantsFileTransferOnCheckpointExit );
int checkpointExitCode = 0;
JobAd->LookupInteger( ATTR_CHECKPOINT_EXIT_CODE, checkpointExitCode );
int checkpointExitSignal = 0;
JobAd->LookupInteger( ATTR_CHECKPOINT_EXIT_SIGNAL, checkpointExitSignal );
bool checkpointExitBySignal = 0;
JobAd->LookupBool( ATTR_CHECKPOINT_EXIT_BY_SIGNAL, checkpointExitBySignal );
int successfulCheckpointStatus = 0;
if( checkpointExitBySignal ) {
successfulCheckpointStatus = checkpointExitSignal;
} else if( checkpointExitCode != 0 ) {
successfulCheckpointStatus = checkpointExitCode << 8;
#if defined( WINDOWS )
successfulCheckpointStatus = checkpointExitCode;
#endif
}
if( isCheckpointing ) {
dprintf( D_FULLDEBUG, "Inside VanillaProc::JobReaper() during a checkpoint\n" );
if( exit_status == successfulCheckpointStatus ) {
if( isSoftKilling ) {
notifySuccessfulEvictionCheckpoint();
return true;
}
restartCheckpointedJob();
isCheckpointing = false;
return false;
} else {
// The job exited without taking a checkpoint. If we don't do
// anything, it will be reported as if the error code or signal
// had happened naturally (and the job will usually exit the
// queue). This could confuse the users.
//
// Instead, we'll put the job on hold, figuring that if the job
// requested that we (periodically) send it a signal, and we
// did, that it's not our fault that the job failed. This has
// the convenient side-effect of not overwriting the job's
// previous checkpoint(s), if any (since file transfer doesn't
// occur when the job goes on hold).
killFamilyIfWarranted();
recordFinalUsage();
std::string holdMessage;
formatstr( holdMessage, "Job did not exit as promised when sent its checkpoint signal. "
"Promised exit was %s %u, actual exit status was %s %u.",
checkpointExitBySignal ? "on signal" : "with exit code",
checkpointExitBySignal ? checkpointExitSignal : checkpointExitCode,
WIFSIGNALED( exit_status ) ? "on signal" : "with exit code",
WIFSIGNALED( exit_status ) ? WTERMSIG( exit_status ) : WEXITSTATUS( exit_status ) );
Starter->jic->holdJob( holdMessage.c_str(), CONDOR_HOLD_CODE_FailedToCheckpoint, exit_status );
Starter->Hold();
return true;
}
} else if( wantsFileTransferOnCheckpointExit && exit_status == successfulCheckpointStatus ) {
dprintf( D_FULLDEBUG, "Inside VanillaProc::JobReaper() and the job self-checkpointed.\n" );
if( isSoftKilling ) {
notifySuccessfulEvictionCheckpoint();
return true;
} else {
restartCheckpointedJob();
return false;
}
} else {
// If the parent job process died, clean up all of the job's processes.
killFamilyIfWarranted();
// Record final usage stats for this process family, since
// once the reaper returns, the family is no longer
// registered with DaemonCore and we'll never be able to
// get this information again.
recordFinalUsage();
return jobExited;
}
}
int main(int argc, char** argv)
{
LBCHECK(co::init(argc, argv));
co::ConnectionDescriptionPtr description = new co::ConnectionDescription;
description->type = co::CONNECTIONTYPE_TCPIP;
description->port = 4242;
bool isClient = true;
bool useThreads = false;
size_t packetSize = 1048576;
size_t nPackets = 0xffffffffu;
uint32_t waitTime = 0;
try // command line parsing
{
po::options_description options(
"netperf - Collage network benchmark tool " +
co::Version::getString());
std::string clientString("");
std::string serverString("");
bool showHelp(false);
options.add_options()("help,h",
po::bool_switch(&showHelp)->default_value(false),
"show help message")(
"client,c", po::value<std::string>(&clientString),
"run as client, format IP[:port][:protocol]")(
"server,s", po::value<std::string>(&serverString),
"run as server, format IP[:port][:protocol]")(
"threaded,t", po::bool_switch(&useThreads)->default_value(false),
"Run each receive in a separate thread (server only)")(
"packetSize,p", po::value<std::size_t>(&packetSize),
"packet size")("numPackets,n", po::value<std::size_t>(&nPackets),
"number of packets to send, unsigned int")(
"wait,w", po::value<uint32_t>(&waitTime),
"wait time (ms) between sends (client only)")(
"delay,d", po::value<uint32_t>(&_delay),
"wait time (ms) between receives (server only");
// parse program options
po::variables_map variableMap;
po::store(po::command_line_parser(argc, argv)
.options(options)
.allow_unregistered()
.run(),
variableMap);
po::notify(variableMap);
// evaluate parsed arguments
if (showHelp)
{
std::cout << options << std::endl;
co::exit();
return EXIT_SUCCESS;
}
if (variableMap.count("client") == 1)
description->fromString(clientString);
else if (variableMap.count("server") == 1)
{
isClient = false;
description->fromString(serverString);
}
}
catch (std::exception& exception)
{
std::cerr << "Command line parse error: " << exception.what()
<< std::endl;
co::exit();
return EXIT_FAILURE;
}
// run
co::ConnectionPtr connection = co::Connection::create(description);
if (!connection)
{
LBWARN << "Unsupported connection: " << description << std::endl;
co::exit();
return EXIT_FAILURE;
}
Selector* selector = 0;
if (isClient)
{
if (description->type == co::CONNECTIONTYPE_RSP)
{
selector = new Selector(connection, packetSize, useThreads);
selector->start();
}
else if (!connection->connect())
::exit(EXIT_FAILURE);
lunchbox::Buffer<uint8_t> buffer;
buffer.resize(packetSize);
for (size_t i = 0; i < packetSize; ++i)
buffer[i] = static_cast<uint8_t>(i);
const float mBytesSec = buffer.getSize() / 1024.0f / 1024.0f * 1000.0f;
lunchbox::Clock clock;
size_t lastOutput = nPackets;
clock.reset();
while (nPackets--)
{
buffer[SEQUENCE] = uint8_t(nPackets);
LBCHECK(connection->send(buffer.getData(), buffer.getSize()));
const float time = clock.getTimef();
if (time > 1000.f)
{
const lunchbox::ScopedWrite mutex(_mutexPrint);
const size_t nSamples = lastOutput - nPackets;
std::cerr << "Send perf: " << mBytesSec / time * nSamples
<< "MB/s (" << nSamples / time * 1000.f << "pps)"
<< std::endl;
lastOutput = nPackets;
clock.reset();
}
if (waitTime > 0)
lunchbox::sleep(waitTime);
}
const float time = clock.getTimef();
const size_t nSamples = lastOutput - nPackets;
if (nSamples != 0)
{
const lunchbox::ScopedWrite mutex(_mutexPrint);
std::cerr << "Send perf: " << mBytesSec / time * nSamples
<< "MB/s (" << nSamples / time * 1000.f << "pps)"
<< std::endl;
}
if (selector)
{
connection->close();
selector->join();
}
}
else
{
selector = new Selector(connection, packetSize, useThreads);
selector->start();
LBASSERTINFO(connection->getRefCount() >= 1, connection->getRefCount());
if (selector)
selector->join();
}
delete selector;
LBASSERTINFO(connection->getRefCount() == 1, connection->getRefCount());
connection = 0;
LBCHECK(co::exit());
return EXIT_SUCCESS;
}
void NilArgChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
CheckerContext &C) const {
const ObjCInterfaceDecl *ID = msg.getReceiverInterface();
if (!ID)
return;
FoundationClass Class = findKnownClass(ID);
static const unsigned InvalidArgIndex = UINT_MAX;
unsigned Arg = InvalidArgIndex;
bool CanBeSubscript = false;
if (Class == FC_NSString) {
Selector S = msg.getSelector();
if (S.isUnarySelector())
return;
if (StringSelectors.empty()) {
ASTContext &Ctx = C.getASTContext();
Selector Sels[] = {
getKeywordSelector(Ctx, "caseInsensitiveCompare", nullptr),
getKeywordSelector(Ctx, "compare", nullptr),
getKeywordSelector(Ctx, "compare", "options", nullptr),
getKeywordSelector(Ctx, "compare", "options", "range", nullptr),
getKeywordSelector(Ctx, "compare", "options", "range", "locale",
nullptr),
getKeywordSelector(Ctx, "componentsSeparatedByCharactersInSet",
nullptr),
getKeywordSelector(Ctx, "initWithFormat",
nullptr),
getKeywordSelector(Ctx, "localizedCaseInsensitiveCompare", nullptr),
getKeywordSelector(Ctx, "localizedCompare", nullptr),
getKeywordSelector(Ctx, "localizedStandardCompare", nullptr),
};
for (Selector KnownSel : Sels)
StringSelectors[KnownSel] = 0;
}
auto I = StringSelectors.find(S);
if (I == StringSelectors.end())
return;
Arg = I->second;
} else if (Class == FC_NSArray) {
Selector S = msg.getSelector();
if (S.isUnarySelector())
return;
if (ArrayWithObjectSel.isNull()) {
ASTContext &Ctx = C.getASTContext();
ArrayWithObjectSel = getKeywordSelector(Ctx, "arrayWithObject", nullptr);
AddObjectSel = getKeywordSelector(Ctx, "addObject", nullptr);
InsertObjectAtIndexSel =
getKeywordSelector(Ctx, "insertObject", "atIndex", nullptr);
ReplaceObjectAtIndexWithObjectSel =
getKeywordSelector(Ctx, "replaceObjectAtIndex", "withObject", nullptr);
SetObjectAtIndexedSubscriptSel =
getKeywordSelector(Ctx, "setObject", "atIndexedSubscript", nullptr);
ArrayByAddingObjectSel =
getKeywordSelector(Ctx, "arrayByAddingObject", nullptr);
}
if (S == ArrayWithObjectSel || S == AddObjectSel ||
S == InsertObjectAtIndexSel || S == ArrayByAddingObjectSel) {
Arg = 0;
} else if (S == SetObjectAtIndexedSubscriptSel) {
Arg = 0;
CanBeSubscript = true;
} else if (S == ReplaceObjectAtIndexWithObjectSel) {
Arg = 1;
}
} else if (Class == FC_NSDictionary) {
Selector S = msg.getSelector();
if (S.isUnarySelector())
return;
if (DictionaryWithObjectForKeySel.isNull()) {
ASTContext &Ctx = C.getASTContext();
DictionaryWithObjectForKeySel =
getKeywordSelector(Ctx, "dictionaryWithObject", "forKey", nullptr);
SetObjectForKeySel =
getKeywordSelector(Ctx, "setObject", "forKey", nullptr);
SetObjectForKeyedSubscriptSel =
getKeywordSelector(Ctx, "setObject", "forKeyedSubscript", nullptr);
RemoveObjectForKeySel =
getKeywordSelector(Ctx, "removeObjectForKey", nullptr);
}
if (S == DictionaryWithObjectForKeySel || S == SetObjectForKeySel) {
Arg = 0;
warnIfNilArg(C, msg, /* Arg */1, Class);
} else if (S == SetObjectForKeyedSubscriptSel) {
CanBeSubscript = true;
Arg = 0;
warnIfNilArg(C, msg, /* Arg */1, Class, CanBeSubscript);
} else if (S == RemoveObjectForKeySel) {
Arg = 0;
}
}
// If argument is '0', report a warning.
if ((Arg != InvalidArgIndex))
warnIfNilArg(C, msg, Arg, Class, CanBeSubscript);
}
void run_bt(Agent* BT_AGENT, bool bt_seq, bool bt_prio)
{
Action_right* action_right = new Action_right(1);
Action_down* action_down = new Action_down(1);
Action_left* action_left = new Action_left(1);
if(bt_seq)
{
// Structure
Selector* root = new Selector;
Sequence* sequence1 = new Sequence;
Sequence* sequence2 = new Sequence;
Sequence* sequence3 = new Sequence;
Less_than* condition_1 = new Less_than(7, &BT_AGENT->pos.y);
Less_than* condition_21 = new Less_than(4,&BT_AGENT->pos.x);
Less_than* condition_22 = new Less_than(9,&BT_AGENT->pos.y);
Equal_to* condition_31 = new Equal_to(9, &BT_AGENT->pos.y);
Less_than* condition_32 = new Less_than(5, &BT_AGENT->pos.x);
// Building the Tree
root->addChild(sequence1);
root->addChild(sequence2);
root->addChild(sequence3);
root->addChild(action_left);
sequence1->addChild(condition_1);
sequence1->addChild(action_right);
sequence2->addChild(condition_21);
sequence2->addChild(condition_22);
sequence2->addChild(action_right);
sequence3->addChild(condition_31);
sequence3->addChild(condition_32);
sequence3->addChild(action_down);
// Initialisation Agent
//BT_AGENT->setSteps(30);
BT_AGENT->setTimeStep(30);
BT_AGENT->initializeAgent(3,0);
while(!BT_AGENT->madeIt())
{
root->update(BT_AGENT);
BT_AGENT->performAction();
}
}
if(bt_prio)
{
// Structure
Selector* root = new Selector;
Sequence* sequence1 = new Sequence;
Sequence* sequence2 = new Sequence;
Greater_than* condition_11 = new Greater_than(4, &BT_AGENT->pos.x);
Greater_than* condition_12 = new Greater_than(6, &BT_AGENT->pos.y);
Less_than* condition_21 = new Less_than(9, &BT_AGENT->pos.y);
root->addChild(sequence1);
root->addChild(sequence2);
root->addChild(action_down);
sequence1->addChild(condition_11);
sequence1->addChild(condition_12);
sequence1->addChild(action_left);
sequence2->addChild(condition_21);
sequence2->addChild(action_right);
// Initialisation Agent
//BT_AGENT->setSteps(30);
BT_AGENT->setTimeStep(30);
BT_AGENT->initializeAgent(3,0);
while(!BT_AGENT->madeIt())
{
root->update(BT_AGENT);
BT_AGENT->performAction();
}
}
}
inline void debug_ast(AST_Node* node, std::string ind, Env* env)
{
if (node == 0) return;
if (ind == "") std::cerr << "####################################################################\n";
if (dynamic_cast<Bubble*>(node)) {
Bubble* bubble = dynamic_cast<Bubble*>(node);
std::cerr << ind << "Bubble " << bubble;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << bubble->tabs();
std::cerr << std::endl;
} else if (dynamic_cast<At_Root_Block*>(node)) {
At_Root_Block* root_block = dynamic_cast<At_Root_Block*>(node);
std::cerr << ind << "At_Root_Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << root_block->tabs();
std::cerr << std::endl;
debug_ast(root_block->expression(), ind + ":", env);
debug_ast(root_block->block(), ind + " ", env);
} else if (dynamic_cast<Selector_List*>(node)) {
Selector_List* selector = dynamic_cast<Selector_List*>(node);
std::cerr << ind << "Selector_List " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
// } else if (dynamic_cast<Expression*>(node)) {
// Expression* expression = dynamic_cast<Expression*>(node);
// std::cerr << ind << "Expression " << expression << " " << expression->concrete_type() << std::endl;
} else if (dynamic_cast<Parent_Selector*>(node)) {
Parent_Selector* selector = dynamic_cast<Parent_Selector*>(node);
std::cerr << ind << "Parent_Selector " << selector;
// if (selector->not_selector()) cerr << " [in_declaration]";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
// debug_ast(selector->selector(), ind + "->", env);
} else if (dynamic_cast<Complex_Selector*>(node)) {
Complex_Selector* selector = dynamic_cast<Complex_Selector*>(node);
std::cerr << ind << "Complex_Selector " << selector
<< " (" << pstate_source_position(node) << ")"
<< " <" << selector->hash() << ">"
<< " [weight:" << longToHex(selector->specificity()) << "]"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_parent_ref() ? " [has parent]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< " -- ";
std::string del;
switch (selector->combinator()) {
case Complex_Selector::PARENT_OF: del = ">"; break;
case Complex_Selector::PRECEDES: del = "~"; break;
case Complex_Selector::ADJACENT_TO: del = "+"; break;
case Complex_Selector::ANCESTOR_OF: del = " "; break;
case Complex_Selector::REFERENCE: del = "//"; break;
}
// if (del = "/") del += selector->reference()->perform(&to_string) + "/";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
if (selector->tail()) {
debug_ast(selector->tail(), ind + "{" + del + "}", env);
} else if(del != " ") {
std::cerr << ind << " |" << del << "| {trailing op}" << std::endl;
}
SourcesSet set = selector->sources();
// debug_sources_set(set, ind + " @--> ");
} else if (dynamic_cast<Compound_Selector*>(node)) {
Compound_Selector* selector = dynamic_cast<Compound_Selector*>(node);
std::cerr << ind << "Compound_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [weight:" << longToHex(selector->specificity()) << "]";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->extended() ? " [extended]": " -");
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Propset*>(node)) {
Propset* selector = dynamic_cast<Propset*>(node);
std::cerr << ind << "Propset " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << selector->tabs() << std::endl;
if (selector->block()) for(auto i : selector->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Wrapped_Selector*>(node)) {
Wrapped_Selector* selector = dynamic_cast<Wrapped_Selector*>(node);
std::cerr << ind << "Wrapped_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->selector(), ind + " () ", env);
} else if (dynamic_cast<Pseudo_Selector*>(node)) {
Pseudo_Selector* selector = dynamic_cast<Pseudo_Selector*>(node);
std::cerr << ind << "Pseudo_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->expression(), ind + " <= ", env);
} else if (dynamic_cast<Attribute_Selector*>(node)) {
Attribute_Selector* selector = dynamic_cast<Attribute_Selector*>(node);
std::cerr << ind << "Attribute_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
} else if (dynamic_cast<Selector_Qualifier*>(node)) {
Selector_Qualifier* selector = dynamic_cast<Selector_Qualifier*>(node);
std::cerr << ind << "Selector_Qualifier " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
} else if (dynamic_cast<Type_Selector*>(node)) {
Type_Selector* selector = dynamic_cast<Type_Selector*>(node);
std::cerr << ind << "Type_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">";
std::cerr << std::endl;
} else if (dynamic_cast<Selector_Placeholder*>(node)) {
Selector_Placeholder* selector = dynamic_cast<Selector_Placeholder*>(node);
std::cerr << ind << "Selector_Placeholder [" << selector->ns_name() << "] " << selector
<< " <" << selector->hash() << ">"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Simple_Selector*>(node)) {
Simple_Selector* selector = dynamic_cast<Simple_Selector*>(node);
std::cerr << ind << "Simple_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << std::endl;
} else if (dynamic_cast<Selector_Schema*>(node)) {
Selector_Schema* selector = dynamic_cast<Selector_Schema*>(node);
std::cerr << ind << "Selector_Schema " << selector;
std::cerr << " (" << pstate_source_position(node) << ")"
<< (selector->at_root() && selector->at_root() ? " [@ROOT]" : "")
<< " [@media:" << selector->media_block() << "]"
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
debug_ast(selector->contents(), ind + " ");
// for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Selector*>(node)) {
Selector* selector = dynamic_cast<Selector*>(node);
std::cerr << ind << "Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Media_Query_Expression*>(node)) {
Media_Query_Expression* block = dynamic_cast<Media_Query_Expression*>(node);
std::cerr << ind << "Media_Query_Expression " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_interpolated() ? " [is_interpolated]": " -")
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Media_Query*>(node)) {
Media_Query* block = dynamic_cast<Media_Query*>(node);
std::cerr << ind << "Media_Query " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_negated() ? " [is_negated]": " -")
<< (block->is_restricted() ? " [is_restricted]": " -")
<< std::endl;
debug_ast(block->media_type(), ind + " ");
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Media_Block*>(node)) {
Media_Block* block = dynamic_cast<Media_Block*>(node);
std::cerr << ind << "Media_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->media_queries(), ind + " =@ ");
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Supports_Block*>(node)) {
Supports_Block* block = dynamic_cast<Supports_Block*>(node);
std::cerr << ind << "Supports_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->condition(), ind + " =@ ");
} else if (dynamic_cast<Supports_Operator*>(node)) {
Supports_Operator* block = dynamic_cast<Supports_Operator*>(node);
std::cerr << ind << "Supports_Operator " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->left(), ind + " left) ");
debug_ast(block->right(), ind + " right) ");
} else if (dynamic_cast<Supports_Negation*>(node)) {
Supports_Negation* block = dynamic_cast<Supports_Negation*>(node);
std::cerr << ind << "Supports_Negation " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->condition(), ind + " condition) ");
} else if (dynamic_cast<Supports_Declaration*>(node)) {
Supports_Declaration* block = dynamic_cast<Supports_Declaration*>(node);
std::cerr << ind << "Supports_Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Block*>(node)) {
Block* root_block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
if (root_block->is_root()) std::cerr << " [root]";
std::cerr << " " << root_block->tabs() << std::endl;
if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Warning*>(node)) {
Warning* block = dynamic_cast<Warning*>(node);
std::cerr << ind << "Warning " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Error*>(node)) {
Error* block = dynamic_cast<Error*>(node);
std::cerr << ind << "Error " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Debug*>(node)) {
Debug* block = dynamic_cast<Debug*>(node);
std::cerr << ind << "Debug " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Comment*>(node)) {
Comment* block = dynamic_cast<Comment*>(node);
std::cerr << ind << "Comment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() <<
" <" << prettyprint(block->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(block->text(), ind + "// ", env);
} else if (dynamic_cast<If*>(node)) {
If* block = dynamic_cast<If*>(node);
std::cerr << ind << "If " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->predicate(), ind + " = ");
debug_ast(block->block(), ind + " <>");
debug_ast(block->alternative(), ind + " ><");
} else if (dynamic_cast<Return*>(node)) {
Return* block = dynamic_cast<Return*>(node);
std::cerr << ind << "Return " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Extension*>(node)) {
Extension* block = dynamic_cast<Extension*>(node);
std::cerr << ind << "Extension " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "-> ", env);
} else if (dynamic_cast<Content*>(node)) {
Content* block = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import_Stub*>(node)) {
Import_Stub* block = dynamic_cast<Import_Stub*>(node);
std::cerr << ind << "Import_Stub " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import*>(node)) {
Import* block = dynamic_cast<Import*>(node);
std::cerr << ind << "Import " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->media_queries(), ind + " @ ");
// std::vector<std::string> files_;
for (auto imp : block->urls()) debug_ast(imp, "@ ", env);
} else if (dynamic_cast<Assignment*>(node)) {
Assignment* block = dynamic_cast<Assignment*>(node);
std::cerr << ind << "Assignment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <<" << block->variable() << ">> " << block->tabs() << std::endl;
debug_ast(block->value(), ind + "=", env);
} else if (dynamic_cast<Declaration*>(node)) {
Declaration* block = dynamic_cast<Declaration*>(node);
std::cerr << ind << "Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->property(), ind + " prop: ", env);
debug_ast(block->value(), ind + " value: ", env);
} else if (dynamic_cast<Keyframe_Rule*>(node)) {
Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
std::cerr << ind << "Keyframe_Rule " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<At_Rule*>(node)) {
At_Rule* block = dynamic_cast<At_Rule*>(node);
std::cerr << ind << "At_Rule " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << block->keyword() << "] " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "~", env);
debug_ast(block->value(), ind + "+", env);
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Each*>(node)) {
Each* block = dynamic_cast<Each*>(node);
std::cerr << ind << "Each " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<For*>(node)) {
For* block = dynamic_cast<For*>(node);
std::cerr << ind << "For " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<While*>(node)) {
While* block = dynamic_cast<While*>(node);
std::cerr << ind << "While " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Definition*>(node)) {
Definition* block = dynamic_cast<Definition*>(node);
std::cerr << ind << "Definition " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << block->name() << "] ";
std::cerr << " [type: " << (block->type() == Sass::Definition::Type::MIXIN ? "Mixin " : "Function ") << "] ";
// this seems to lead to segfaults some times?
// std::cerr << " [signature: " << block->signature() << "] ";
std::cerr << " [native: " << block->native_function() << "] ";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->parameters(), ind + " params: ", env);
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Mixin_Call*>(node)) {
Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
std::cerr << ind << "Mixin_Call " << block << " " << block->tabs();
std::cerr << " [" << block->name() << "]";
std::cerr << " [has_content: " << block->has_content() << "] " << std::endl;
debug_ast(block->arguments(), ind + " args: ");
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (Ruleset* ruleset = dynamic_cast<Ruleset*>(node)) {
std::cerr << ind << "Ruleset " << ruleset;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [indent: " << ruleset->tabs() << "]";
std::cerr << (ruleset->at_root() ? " [@ROOT]" : "");
std::cerr << (ruleset->is_root() ? " [root]" : "");
std::cerr << std::endl;
debug_ast(ruleset->selector(), ind + ">");
debug_ast(ruleset->block(), ind + " ");
} else if (dynamic_cast<Block*>(node)) {
Block* block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [indent: " << block->tabs() << "]" << std::endl;
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Textual*>(node)) {
Textual* expression = dynamic_cast<Textual*>(node);
std::cerr << ind << "Textual ";
if (expression->type() == Textual::NUMBER) std::cerr << " [NUMBER]";
else if (expression->type() == Textual::PERCENTAGE) std::cerr << " [PERCENTAGE]";
else if (expression->type() == Textual::DIMENSION) std::cerr << " [DIMENSION]";
else if (expression->type() == Textual::HEX) std::cerr << " [HEX]";
std::cerr << expression << " [" << expression->value() << "]";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << std::endl;
} else if (dynamic_cast<Variable*>(node)) {
Variable* expression = dynamic_cast<Variable*>(node);
std::cerr << ind << "Variable " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]" << std::endl;
std::string name(expression->name());
if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
} else if (dynamic_cast<Function_Call_Schema*>(node)) {
Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
std::cerr << ind << "Function_Call_Schema " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << "" << std::endl;
debug_ast(expression->name(), ind + "name: ", env);
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Function_Call*>(node)) {
Function_Call* expression = dynamic_cast<Function_Call*>(node);
std::cerr << ind << "Function_Call " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << std::endl;
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Arguments*>(node)) {
Arguments* expression = dynamic_cast<Arguments*>(node);
std::cerr << ind << "Arguments " << expression;
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->has_named_arguments()) std::cerr << " [has_named_arguments]";
if (expression->has_rest_argument()) std::cerr << " [has_rest_argument]";
if (expression->has_keyword_argument()) std::cerr << " [has_keyword_argument]";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Argument*>(node)) {
Argument* expression = dynamic_cast<Argument*>(node);
std::cerr << ind << "Argument " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->value() << "]";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [rest: " << expression->is_rest_argument() << "] ";
std::cerr << " [keyword: " << expression->is_keyword_argument() << "] " << std::endl;
debug_ast(expression->value(), ind + " value: ", env);
} else if (dynamic_cast<Parameters*>(node)) {
Parameters* expression = dynamic_cast<Parameters*>(node);
std::cerr << ind << "Parameters " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [has_optional: " << expression->has_optional_parameters() << "] ";
std::cerr << " [has_rest: " << expression->has_rest_parameter() << "] ";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Parameter*>(node)) {
Parameter* expression = dynamic_cast<Parameter*>(node);
std::cerr << ind << "Parameter " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [default: " << expression->default_value() << "] ";
std::cerr << " [rest: " << expression->is_rest_parameter() << "] " << std::endl;
} else if (dynamic_cast<Unary_Expression*>(node)) {
Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
std::cerr << ind << "Unary_Expression " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type() << "]" << std::endl;
debug_ast(expression->operand(), ind + " operand: ", env);
} else if (dynamic_cast<Binary_Expression*>(node)) {
Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
std::cerr << ind << "Binary_Expression " << expression;
if (expression->is_interpolant()) std::cerr << " [is interpolant] ";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " [ws_before: " << expression->op().ws_before << "] ";
std::cerr << " [ws_after: " << expression->op().ws_after << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type_name() << "]" << std::endl;
debug_ast(expression->left(), ind + " left: ", env);
debug_ast(expression->right(), ind + " right: ", env);
} else if (dynamic_cast<Map*>(node)) {
Map* expression = dynamic_cast<Map*>(node);
std::cerr << ind << "Map " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [Hashed]" << std::endl;
for (auto i : expression->elements()) {
debug_ast(i.first, ind + " key: ");
debug_ast(i.second, ind + " val: ");
}
} else if (dynamic_cast<List*>(node)) {
List* expression = dynamic_cast<List*>(node);
std::cerr << ind << "List " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " (" << expression->length() << ") " <<
(expression->separator() == SASS_COMMA ? "Comma " : expression->separator() == SASS_HASH ? "Map" : "Space ") <<
" [delayed: " << expression->is_delayed() << "] " <<
" [interpolant: " << expression->is_interpolant() << "] " <<
" [arglist: " << expression->is_arglist() << "] " <<
" [hash: " << expression->hash() << "] " <<
std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Content*>(node)) {
Content* expression = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [Statement]" << std::endl;
} else if (dynamic_cast<Boolean*>(node)) {
Boolean* expression = dynamic_cast<Boolean*>(node);
std::cerr << ind << "Boolean " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << "]" << std::endl;
} else if (dynamic_cast<Color*>(node)) {
Color* expression = dynamic_cast<Color*>(node);
std::cerr << ind << "Color " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->r() << ":" << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << std::endl;
} else if (dynamic_cast<Number*>(node)) {
Number* expression = dynamic_cast<Number*>(node);
std::cerr << ind << "Number " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << expression->unit() << "]" <<
" [hash: " << expression->hash() << "] " <<
std::endl;
} else if (dynamic_cast<String_Quoted*>(node)) {
String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
std::cerr << ind << "String_Quoted " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->sass_fix_1291()) std::cerr << " [sass_fix_1291]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
if (expression->quote_mark()) std::cerr << " [quote_mark: " << expression->quote_mark() << "]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Constant*>(node)) {
String_Constant* expression = dynamic_cast<String_Constant*>(node);
std::cerr << ind << "String_Constant " << expression;
if (expression->concrete_type()) {
std::cerr << " " << expression->concrete_type();
}
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->sass_fix_1291()) std::cerr << " [sass_fix_1291]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Schema*>(node)) {
String_Schema* expression = dynamic_cast<String_Schema*>(node);
std::cerr << ind << "String_Schema " << expression;
std::cerr << " " << expression->concrete_type();
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [is interpolant]";
if (expression->has_interpolant()) std::cerr << " [has interpolant]";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<String*>(node)) {
String* expression = dynamic_cast<String*>(node);
std::cerr << ind << "String " << expression;
std::cerr << " " << expression->concrete_type();
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->sass_fix_1291()) std::cerr << " [sass_fix_1291]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<Expression*>(node)) {
Expression* expression = dynamic_cast<Expression*>(node);
std::cerr << ind << "Expression " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
switch (expression->concrete_type()) {
case Expression::Concrete_Type::NONE: std::cerr << " [NONE]"; break;
case Expression::Concrete_Type::BOOLEAN: std::cerr << " [BOOLEAN]"; break;
case Expression::Concrete_Type::NUMBER: std::cerr << " [NUMBER]"; break;
case Expression::Concrete_Type::COLOR: std::cerr << " [COLOR]"; break;
case Expression::Concrete_Type::STRING: std::cerr << " [STRING]"; break;
case Expression::Concrete_Type::LIST: std::cerr << " [LIST]"; break;
case Expression::Concrete_Type::MAP: std::cerr << " [MAP]"; break;
case Expression::Concrete_Type::SELECTOR: std::cerr << " [SELECTOR]"; break;
case Expression::Concrete_Type::NULL_VAL: std::cerr << " [NULL_VAL]"; break;
case Expression::Concrete_Type::C_WARNING: std::cerr << " [C_WARNING]"; break;
case Expression::Concrete_Type::C_ERROR: std::cerr << " [C_ERROR]"; break;
case Expression::Concrete_Type::NUM_TYPES: std::cerr << " [NUM_TYPES]"; break;
}
std::cerr << std::endl;
} else if (dynamic_cast<Has_Block*>(node)) {
Has_Block* has_block = dynamic_cast<Has_Block*>(node);
std::cerr << ind << "Has_Block " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Statement*>(node)) {
Statement* statement = dynamic_cast<Statement*>(node);
std::cerr << ind << "Statement " << statement;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << statement->tabs() << std::endl;
}
if (ind == "") std::cerr << "####################################################################\n";
}
void Mixin::parseArguments(TokenList::const_iterator i, const Selector &selector) {
TokenList::const_iterator j;
string delimiter = ",";
TokenList argument;
size_t nestedParenthesis = 0;
string argName;
if (i != selector.end() &&
(*i).type == Token::PAREN_OPEN) {
i++;
}
// if a ';' token occurs then that is the delimiter instead of the ','.
for(j = i; j != selector.end(); j++) {
if (*j == ";") {
delimiter = ";";
break;
}
}
while (i != selector.end() && (*i).type != Token::PAREN_CLOSED) {
while (i != selector.end() &&
(*i).type == Token::WHITESPACE) {
i++;
}
if ((*i).type == Token::ATKEYWORD) {
argName = (*i);
i++;
if (i != selector.end() &&
(*i).type == Token::COLON) {
i++;
} else {
argName = "";
i--;
}
}
while (i != selector.end() &&
(nestedParenthesis > 0 ||
((*i) != delimiter &&
(*i).type != Token::PAREN_CLOSED))) {
if ((*i).type == Token::PAREN_OPEN)
nestedParenthesis++;
if ((*i).type == Token::PAREN_CLOSED)
nestedParenthesis--;
argument.push_back(*i);
i++;
}
if (*i == delimiter)
i++;
if (argName == "")
this->arguments.push_back(argument);
else {
this->namedArguments.insert(pair<string,
TokenList>(argName,argument));
argName = "";
}
argument.clear();
}
}
void Output_Nested::operator()(Ruleset* r)
{
Selector* s = r->selector();
Block* b = r->block();
bool decls = false;
if (s->has_placeholder()) return;
if (b->has_non_hoistable()) {
decls = true;
indent();
if (source_comments) {
stringstream ss;
ss << "/* line " << r->line() << ", " << r->path() << " */" << endl;
buffer += ss.str();
indent();
}
s->perform(this);
buffer += " {\n";
++indentation;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
bool bPrintExpression = true;
// Check print conditions
if (typeid(*stm) == typeid(Declaration)) {
Declaration* dec = static_cast<Declaration*>(stm);
if (dec->value()->concrete_type() == Expression::STRING) {
String_Constant* valConst = static_cast<String_Constant*>(dec->value());
string val(valConst->value());
if (val.empty()) {
bPrintExpression = false;
}
}
else if (dec->value()->concrete_type() == Expression::LIST) {
List* list = static_cast<List*>(dec->value());
bool all_invisible = true;
for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
Expression* item = (*list)[list_i];
if (!item->is_invisible()) all_invisible = false;
}
if (all_invisible) bPrintExpression = false;
}
}
// Print if OK
if (!stm->is_hoistable() && bPrintExpression) {
if (!stm->block()) indent();
stm->perform(this);
buffer += '\n';
}
}
--indentation;
buffer.erase(buffer.length()-1);
buffer += " }\n";
}
if (b->has_hoistable()) {
if (decls) ++indentation;
// indent();
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
if (decls) --indentation;
}
}
bool CalculateCenter(typename TAAPosVRT::ValueType& centerOut,
Selector& sel, TAAPosVRT& aaPos)
{
if(!sel.grid()){
throw(UGError("No grid assigned to selector"));
}
Grid& grid = *sel.grid();
// collect all vertices that are adjacent to selected elements
// we have to make sure that each vertex is only counted once.
// we do this by using grid::mark.
grid.begin_marking();
// std::vector<Vertex*> vrts;
// vrts.assign(sel.vertices_begin(), sel.vertices_end());
// grid.mark(sel.vertices_begin(), sel.vertices_end());
VecSet(centerOut, 0);
size_t n = 0;
for(VertexIterator iter = sel.vertices_begin();
iter != sel.vertices_end(); ++iter)
{
VecAdd(centerOut, centerOut, aaPos[*iter]);
grid.mark(*iter);
++n;
}
for(EdgeIterator iter = sel.edges_begin();
iter != sel.edges_end(); ++iter)
{
Edge::ConstVertexArray vrts = (*iter)->vertices();
for(size_t i = 0; i < (*iter)->num_vertices(); ++i){
if(!grid.is_marked(vrts[i])){
grid.mark(vrts[i]);
VecAdd(centerOut, centerOut, aaPos[vrts[i]]);
++n;
}
}
}
for(FaceIterator iter = sel.faces_begin();
iter != sel.faces_end(); ++iter)
{
Face::ConstVertexArray vrts = (*iter)->vertices();
for(size_t i = 0; i < (*iter)->num_vertices(); ++i){
if(!grid.is_marked(vrts[i])){
grid.mark(vrts[i]);
VecAdd(centerOut, centerOut, aaPos[vrts[i]]);
++n;
}
}
}
for(VolumeIterator iter = sel.volumes_begin();
iter != sel.volumes_end(); ++iter)
{
Volume::ConstVertexArray vrts = (*iter)->vertices();
for(size_t i = 0; i < (*iter)->num_vertices(); ++i){
if(!grid.is_marked(vrts[i])){
grid.mark(vrts[i]);
VecAdd(centerOut, centerOut, aaPos[vrts[i]]);
++n;
}
}
}
grid.end_marking();
if(n > 0){
VecScale(centerOut, centerOut, 1. / (number)n);
return true;
}
return false;
}
void ObjCSuperCallChecker::checkASTDecl(const ObjCImplementationDecl *D,
AnalysisManager &Mgr,
BugReporter &BR) const {
ASTContext &Ctx = BR.getContext();
if (!isUIViewControllerSubclass(Ctx, D))
return;
const char *SelectorNames[] =
{"addChildViewController", "viewDidAppear", "viewDidDisappear",
"viewWillAppear", "viewWillDisappear", "removeFromParentViewController",
"didReceiveMemoryWarning", "viewDidUnload", "viewWillUnload",
"viewDidLoad"};
const unsigned SelectorArgumentCounts[] =
{1, 1, 1, 1, 1, 0, 0, 0, 0, 0};
const size_t SelectorCount = llvm::array_lengthof(SelectorNames);
assert(llvm::array_lengthof(SelectorArgumentCounts) == SelectorCount);
// Fill the Selectors SmallSet with all selectors we want to check.
llvm::SmallSet<Selector, 16> Selectors;
for (size_t i = 0; i < SelectorCount; i++) {
unsigned ArgumentCount = SelectorArgumentCounts[i];
const char *SelectorCString = SelectorNames[i];
// Get the selector.
IdentifierInfo *II = &Ctx.Idents.get(SelectorCString);
Selectors.insert(Ctx.Selectors.getSelector(ArgumentCount, &II));
}
// Iterate over all instance methods.
for (ObjCImplementationDecl::instmeth_iterator I = D->instmeth_begin(),
E = D->instmeth_end();
I != E; ++I) {
Selector S = (*I)->getSelector();
// Find out whether this is a selector that we want to check.
if (!Selectors.count(S))
continue;
ObjCMethodDecl *MD = *I;
// Check if the method calls its superclass implementation.
if (MD->getBody())
{
FindSuperCallVisitor Visitor(S);
Visitor.TraverseDecl(MD);
// It doesn't call super, emit a diagnostic.
if (!Visitor.DoesCallSuper) {
PathDiagnosticLocation DLoc =
PathDiagnosticLocation::createEnd(MD->getBody(),
BR.getSourceManager(),
Mgr.getAnalysisDeclContext(D));
const char *Name = "Missing call to superclass";
SmallString<256> Buf;
llvm::raw_svector_ostream os(Buf);
os << "The '" << S.getAsString()
<< "' instance method in UIViewController subclass '" << *D
<< "' is missing a [super " << S.getAsString() << "] call";
BR.EmitBasicReport(MD, Name, categories::CoreFoundationObjectiveC,
os.str(), DLoc);
}
}
}
}
void parcefile(std::string filepath)
{
xmlpp::DomParser parser;
parser.parse_file(filepath);
const xmlpp::Node* rootNode = parser.get_document()->get_root_node();
xmlpp::Node::NodeList mainList = rootNode->get_children();
char origLocale[1024];
strcpy(origLocale, std::setlocale(LC_ALL, "")); //Store locale before changing
std::setlocale(LC_ALL, "C"); // We use '.' as decimal-point separator
int m_pos=-1; //For keeping track on the current module position
for(xmlpp::Node::NodeList::iterator iter = mainList.begin(); iter != mainList.end(); ++iter)
{
std::string contName= (*iter)->get_name();
if(contName=="modules")
{
xmlpp::Element::NodeList modulesList = (*iter)->get_children();
for(xmlpp::Element::NodeList::iterator modIter = modulesList.begin(); modIter != modulesList.end(); ++modIter)
{
std::string nodeType=(*modIter)->get_name();
if(nodeType=="module")
{
m_pos++; //First occurence will be 0, second 1 etc...
const xmlpp::Element* element1 = dynamic_cast<const xmlpp::Element*>(*modIter);
std::string moduleName = element1->get_attribute_value("name"); //Not actually used here
std::string moduleId = element1->get_attribute_value("type_id");
int module_type_id = std::stoi(moduleId);
create_and_append_module(module_type_id); //Append module to rack
Module* current_module = modules[m_pos];
//Check for aggregated knob, switch etc. data within module entry:
xmlpp::Element::NodeList moduleDataList = (*modIter)->get_children();
for(xmlpp::Element::NodeList::iterator modDataIter = moduleDataList.begin(); modDataIter != moduleDataList.end(); ++modDataIter)
{
std::string nodeDataType=(*modDataIter)->get_name();
if(nodeDataType=="knob")
{
const xmlpp::Element* element2m = dynamic_cast<const xmlpp::Element*>(*modDataIter);
int knob_n = std::stoi(element2m->get_attribute_value("n"));
double value = std::stof(element2m->get_attribute_value("value"));
//std::cerr << "Module:" << m_pos << "Knob#" << knob_n << "value:" << value <<"\n";
if((dynamic_cast<Selector*>(current_module->knobs[knob_n])))
{
//This Knob is, in fact a Selector object, treat differently
Selector* someSelector = (Selector*)current_module->knobs[knob_n];
someSelector->set_value(value);
//std::cerr << "Is selector\n";
}
else
{
//Treat as basic Knob object
current_module->knobs[knob_n]->set_value(value);
//std::cerr << "Is knob\n";
}
}
if(nodeDataType=="switch")
{
const xmlpp::Element* element3m = dynamic_cast<const xmlpp::Element*>(*modDataIter);
int switch_n = std::stoi(element3m->get_attribute_value("n"));
double value = std::stof(element3m->get_attribute_value("value"));
Switch* theSwitch = current_module->switches[switch_n];
theSwitch->set_value(value);
}
}
}
}
}
if(contName=="wires")
{
xmlpp::Element::NodeList wiresList = (*iter)->get_children();
for(xmlpp::Element::NodeList::iterator wireIter = wiresList.begin(); wireIter != wiresList.end(); ++wireIter)
{
std::string nodeType=(*wireIter)->get_name();
if(nodeType=="wire")
{
const xmlpp::Element* element = dynamic_cast<const xmlpp::Element*>(*wireIter);
int src = std::stoi(element->get_attribute_value("src"));
int sj = std::stoi(element->get_attribute_value("sj"));
int dst = std::stoi(element->get_attribute_value("dst"));
int dj = std::stoi(element->get_attribute_value("dj"));
Module* srcMod = modules[src];
Module* dstMod = modules[dst];
connect(srcMod->outlets[sj], dstMod->inlets[dj]);
}
}
}
if(contName=="knobs")
{
xmlpp::Element::NodeList knobList = (*iter)->get_children();
int i=0;
for(xmlpp::Element::NodeList::iterator knobIter = knobList.begin(); knobIter != knobList.end(); ++knobIter)
{
std::string nodeType=(*knobIter)->get_name();
if(nodeType=="knob")
{
const xmlpp::Element* element2 = dynamic_cast<const xmlpp::Element*>(*knobIter);
double value = std::stof(element2->get_attribute_value("value"));
if(typeid(*knobs[i]) == typeid(Selector))
{
//This Knob is, in fact a Selector object, treat differently
Selector* someSelector = (Selector*)knobs[i];
someSelector->set_value(value);
}
else
{
//Treat as basic Knob object
knobs[i]->set_value(value);
}
i++;
}
}
}
if(contName=="switches")
{
xmlpp::Element::NodeList switchList = (*iter)->get_children();
int i=0;
for(xmlpp::Element::NodeList::iterator switchIter = switchList.begin(); switchIter != switchList.end(); ++switchIter)
{
std::string nodeType=(*switchIter)->get_name();
if(nodeType=="switch")
{
const xmlpp::Element* element3 = dynamic_cast<const xmlpp::Element*>(*switchIter);
double value = std::stof(element3->get_attribute_value("value"));
switches[i]->set_value(value);
i++;
}
}
}
}
std::setlocale(LC_ALL, origLocale); //Restore locale to the original state
} //end parcefile()
// Effects:
// 4 things are set.
// 1) prediction_error
// 2) scaled_prediction_error
// 3) forecast_precision_log_determinant
// 4) kalman_gain
void Marginal::high_dimensional_update(
const Vector &observation,
const Selector &observed,
const SparseKalmanMatrix &transition,
const SparseKalmanMatrix &observation_coefficient_subset) {
Vector observed_subset = observed.select(observation);
set_prediction_error(observed_subset
- observation_coefficient_subset * state_mean());
// At this point the Kalman recursions compute the forecast precision Finv
// and its log determinant. However, we can get rid of the forecast
// precision matrix, and replace it with the scaled error = Finv *
// prediction_error.
//
// To evaluate the normal likelihood, we need the quadratic form:
// error * Finv * error == error.dot(scaled_error).
// We also need the log determinant of Finv.
//
// The forecast_precision can be computed using a version of the binomial
// inverse theorem:
//
// (A + UBV).inv =
// A.inv - A.inv * U * (I + B * V * Ainv * U).inv * B * V * Ainv.
//
// When applied to F = H + Z P Z' the theorem gives
//
// Finv = Hinv - Hinv * Z * (I + P Z' Hinv Z).inv * P * Z' * Hinv
//
// This helps because H is diagonal. The only matrix that needs to be
// inverted is (I + PZ'HinvZ), which is a state x state matrix.
//
// We don't compute Finv directly, we compute Finv * prediction_error.
// observation_precision refers to the precision of the observed subset.
DiagonalMatrix observation_precision(observed.select(
1.0 / model_->observation_variance(time_index()).diag()));
// Set inner_matrix to I + P * Z' * Hinv * Z
SpdMatrix ZTZ = observation_coefficient_subset.inner(
observation_precision.diag());
// Note: the product of two SPD matrices need not be symmetric.
Matrix inner_matrix = state_variance() * ZTZ;
inner_matrix.diag() += 1.0;
LU inner_lu(inner_matrix);
// inner_inv_P is inner.inv() * state_variance. This matrix need not be
// symmetric.
Matrix inner_inv_P = inner_lu.solve(state_variance());
Matrix HinvZ = observation_precision *
observation_coefficient_subset.dense();
set_scaled_prediction_error(
observation_precision * prediction_error()
- HinvZ * inner_inv_P * HinvZ.Tmult(prediction_error()));
// The log determinant of F.inverse is the negative log of det(H + ZPZ').
// That determinant can be computed using the "matrix determinant lemma,"
// which says det(A + UV') = det(I + V' * A.inv * U) * det(A)
//
// https://en.wikipedia.org/wiki/Matrix_determinant_lemma#Generalization
//
// With F = H + ZPZ', and setting A = H, U = Z, V' = PZ'.
// Then det(F) = det(I + PZ' * Hinv * Z) * det(H)
set_forecast_precision_log_determinant(
observation_precision.logdet() - inner_lu.logdet());
// The Kalman gain is: K = T * P * Z' * Finv.
// Substituting the expression for Finv from above gives
//
// K = T * P * Z' *
// (Hinv - Hinv * Z * (I + P Z' Hinv Z).inv * P * Z' * Hinv)
Matrix ZtHinv = HinvZ.transpose();
set_kalman_gain(transition * state_variance() *
(ZtHinv - ZTZ * inner_inv_P * ZtHinv));
}
void Output::operator()(Ruleset* r)
{
Selector* s = r->selector();
Block* b = r->block();
bool decls = false;
// Filter out rulesets that aren't printable (process its children though)
if (!Util::isPrintable(r, output_style())) {
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (dynamic_cast<Has_Block*>(stm)) {
stm->perform(this);
}
}
return;
}
if (b->has_non_hoistable()) {
decls = true;
if (output_style() == NESTED) indentation += r->tabs();
if (opt.source_comments) {
std::stringstream ss;
append_indentation();
ss << "/* line " << r->pstate().line + 1 << ", " << r->pstate().path << " */";
append_string(ss.str());
append_optional_linefeed();
}
s->perform(this);
append_scope_opener(b);
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
bool bPrintExpression = true;
// Check print conditions
if (typeid(*stm) == typeid(Declaration)) {
Declaration* dec = static_cast<Declaration*>(stm);
if (dec->value()->concrete_type() == Expression::STRING) {
String_Constant* valConst = static_cast<String_Constant*>(dec->value());
std::string val(valConst->value());
if (auto qstr = dynamic_cast<String_Quoted*>(valConst)) {
if (!qstr->quote_mark() && val.empty()) {
bPrintExpression = false;
}
}
}
else if (dec->value()->concrete_type() == Expression::LIST) {
List* list = static_cast<List*>(dec->value());
bool all_invisible = true;
for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
Expression* item = (*list)[list_i];
if (!item->is_invisible()) all_invisible = false;
}
if (all_invisible) bPrintExpression = false;
}
}
// Print if OK
if (!stm->is_hoistable() && bPrintExpression) {
stm->perform(this);
}
}
if (output_style() == NESTED) indentation -= r->tabs();
append_scope_closer(b);
}
if (b->has_hoistable()) {
if (decls) ++indentation;
for (size_t i = 0, L = b->length(); i < L; ++i) {
Statement* stm = (*b)[i];
if (stm->is_hoistable()) {
stm->perform(this);
}
}
if (decls) --indentation;
}
}
bool Sema::CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs,
Selector Sel, ObjCMethodDecl *Method,
bool isClassMessage,
SourceLocation lbrac, SourceLocation rbrac,
QualType &ReturnType, ExprValueKind &VK) {
if (!Method) {
// Apply default argument promotion as for (C99 6.5.2.2p6).
for (unsigned i = 0; i != NumArgs; i++) {
if (Args[i]->isTypeDependent())
continue;
DefaultArgumentPromotion(Args[i]);
}
unsigned DiagID = isClassMessage ? diag::warn_class_method_not_found :
diag::warn_inst_method_not_found;
Diag(lbrac, DiagID)
<< Sel << isClassMessage << SourceRange(lbrac, rbrac);
ReturnType = Context.getObjCIdType();
VK = VK_RValue;
return false;
}
ReturnType = Method->getSendResultType();
VK = Expr::getValueKindForType(Method->getResultType());
unsigned NumNamedArgs = Sel.getNumArgs();
// Method might have more arguments than selector indicates. This is due
// to addition of c-style arguments in method.
if (Method->param_size() > Sel.getNumArgs())
NumNamedArgs = Method->param_size();
// FIXME. This need be cleaned up.
if (NumArgs < NumNamedArgs) {
Diag(lbrac, diag::err_typecheck_call_too_few_args)
<< 2 << NumNamedArgs << NumArgs;
return false;
}
bool IsError = false;
for (unsigned i = 0; i < NumNamedArgs; i++) {
// We can't do any type-checking on a type-dependent argument.
if (Args[i]->isTypeDependent())
continue;
Expr *argExpr = Args[i];
ParmVarDecl *Param = Method->param_begin()[i];
assert(argExpr && "CheckMessageArgumentTypes(): missing expression");
if (RequireCompleteType(argExpr->getSourceRange().getBegin(),
Param->getType(),
PDiag(diag::err_call_incomplete_argument)
<< argExpr->getSourceRange()))
return true;
InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
Param);
ExprResult ArgE = PerformCopyInitialization(Entity, lbrac, Owned(argExpr));
if (ArgE.isInvalid())
IsError = true;
else
Args[i] = ArgE.takeAs<Expr>();
}
// Promote additional arguments to variadic methods.
if (Method->isVariadic()) {
for (unsigned i = NumNamedArgs; i < NumArgs; ++i) {
if (Args[i]->isTypeDependent())
continue;
IsError |= DefaultVariadicArgumentPromotion(Args[i], VariadicMethod, 0);
}
} else {
// Check for extra arguments to non-variadic methods.
if (NumArgs != NumNamedArgs) {
Diag(Args[NumNamedArgs]->getLocStart(),
diag::err_typecheck_call_too_many_args)
<< 2 /*method*/ << NumNamedArgs << NumArgs
<< Method->getSourceRange()
<< SourceRange(Args[NumNamedArgs]->getLocStart(),
Args[NumArgs-1]->getLocEnd());
}
}
DiagnoseSentinelCalls(Method, lbrac, Args, NumArgs);
return IsError;
}
void NilArgChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
CheckerContext &C) const {
const ObjCInterfaceDecl *ID = msg.getReceiverInterface();
if (!ID)
return;
FoundationClass Class = findKnownClass(ID);
static const unsigned InvalidArgIndex = UINT_MAX;
unsigned Arg = InvalidArgIndex;
bool CanBeSubscript = false;
if (Class == FC_NSString) {
Selector S = msg.getSelector();
if (S.isUnarySelector())
return;
// FIXME: This is going to be really slow doing these checks with
// lexical comparisons.
std::string NameStr = S.getAsString();
StringRef Name(NameStr);
assert(!Name.empty());
// FIXME: Checking for initWithFormat: will not work in most cases
// yet because [NSString alloc] returns id, not NSString*. We will
// need support for tracking expected-type information in the analyzer
// to find these errors.
if (Name == "caseInsensitiveCompare:" ||
Name == "compare:" ||
Name == "compare:options:" ||
Name == "compare:options:range:" ||
Name == "compare:options:range:locale:" ||
Name == "componentsSeparatedByCharactersInSet:" ||
Name == "initWithFormat:") {
Arg = 0;
}
} else if (Class == FC_NSArray) {
Selector S = msg.getSelector();
if (S.isUnarySelector())
return;
if (S.getNameForSlot(0).equals("addObject")) {
Arg = 0;
} else if (S.getNameForSlot(0).equals("insertObject") &&
S.getNameForSlot(1).equals("atIndex")) {
Arg = 0;
} else if (S.getNameForSlot(0).equals("replaceObjectAtIndex") &&
S.getNameForSlot(1).equals("withObject")) {
Arg = 1;
} else if (S.getNameForSlot(0).equals("setObject") &&
S.getNameForSlot(1).equals("atIndexedSubscript")) {
Arg = 0;
CanBeSubscript = true;
} else if (S.getNameForSlot(0).equals("arrayByAddingObject")) {
Arg = 0;
}
} else if (Class == FC_NSDictionary) {
Selector S = msg.getSelector();
if (S.isUnarySelector())
return;
if (S.getNameForSlot(0).equals("dictionaryWithObject") &&
S.getNameForSlot(1).equals("forKey")) {
Arg = 0;
WarnIfNilArg(C, msg, /* Arg */1, Class);
} else if (S.getNameForSlot(0).equals("setObject") &&
S.getNameForSlot(1).equals("forKey")) {
Arg = 0;
WarnIfNilArg(C, msg, /* Arg */1, Class);
} else if (S.getNameForSlot(0).equals("setObject") &&
S.getNameForSlot(1).equals("forKeyedSubscript")) {
CanBeSubscript = true;
Arg = 0;
WarnIfNilArg(C, msg, /* Arg */1, Class, CanBeSubscript);
} else if (S.getNameForSlot(0).equals("removeObjectForKey")) {
Arg = 0;
}
}
// If argument is '0', report a warning.
if ((Arg != InvalidArgIndex))
WarnIfNilArg(C, msg, Arg, Class, CanBeSubscript);
}
void Selector::appendSelector(const Selector &selector) {
insert(end(), selector.begin(), selector.end());
}
void SocketProxy::execute()
{
std::list<SocketProxyPair>::iterator it;
Selector selector;
while( true ) {
selector.reset();
bool has_active_sockets = false;
for ( it=m_socket_pairs.begin(); it != m_socket_pairs.end(); ++it ) {
if( it->shutdown ) {
continue;
}
has_active_sockets = true;
if( it->buf_end > 0 ) {
// drain the buffer before reading more
selector.add_fd(it->to_socket, Selector::IO_WRITE);
}
else {
selector.add_fd(it->from_socket, Selector::IO_READ);
}
}
if( !has_active_sockets ) {
break;
}
selector.execute();
for ( it=m_socket_pairs.begin(); it != m_socket_pairs.end(); ++it ) {
if( it->shutdown ) {
continue;
}
if( it->buf_end > 0 ) {
// attempt to drain the buffer
if( selector.fd_ready(it->to_socket, Selector::IO_WRITE) ) {
int n = write(it->to_socket,&it->buf[it->buf_begin],it->buf_end-it->buf_begin);
if( n > 0 ) {
it->buf_begin += n;
if( it->buf_begin >= it->buf_end ) {
it->buf_begin = 0;
it->buf_end = 0;
}
}
}
}
else if( selector.fd_ready(it->from_socket, Selector::IO_READ) ) {
int n = read(it->from_socket,it->buf,SOCKET_PROXY_BUFSIZE);
if( n > 0 ) {
it->buf_end = n;
}
else if( n == 0 ) {
// the socket has closed
// WIN32 lacks SHUT_RD=0 and SHUT_WR=1
shutdown(it->from_socket,0);
close(it->from_socket);
shutdown(it->to_socket,1);
close(it->to_socket);
it->shutdown = true;
}
else if( n < 0 ) {
MyString error_msg;
error_msg.sprintf("Error reading from socket %d: %s\n",
it->from_socket, strerror(errno));
setErrorMsg(error_msg.Value());
break;
}
}
}
}
}
/// This callback is used to infer the types for Class variables. This info is
/// used later to validate messages that sent to classes. Class variables are
/// initialized with by invoking the 'class' method on a class.
/// This method is also used to infer the type information for the return
/// types.
// TODO: right now it only tracks generic types. Extend this to track every
// type in the DynamicTypeMap and diagnose type errors!
void DynamicTypePropagation::checkPostObjCMessage(const ObjCMethodCall &M,
CheckerContext &C) const {
const ObjCMessageExpr *MessageExpr = M.getOriginExpr();
SymbolRef RetSym = M.getReturnValue().getAsSymbol();
if (!RetSym)
return;
Selector Sel = MessageExpr->getSelector();
ProgramStateRef State = C.getState();
// Inference for class variables.
// We are only interested in cases where the class method is invoked on a
// class. This method is provided by the runtime and available on all classes.
if (MessageExpr->getReceiverKind() == ObjCMessageExpr::Class &&
Sel.getAsString() == "class") {
QualType ReceiverType = MessageExpr->getClassReceiver();
const auto *ReceiverClassType = ReceiverType->getAs<ObjCObjectType>();
QualType ReceiverClassPointerType =
C.getASTContext().getObjCObjectPointerType(
QualType(ReceiverClassType, 0));
if (!ReceiverClassType->isSpecialized())
return;
const auto *InferredType =
ReceiverClassPointerType->getAs<ObjCObjectPointerType>();
assert(InferredType);
State = State->set<MostSpecializedTypeArgsMap>(RetSym, InferredType);
C.addTransition(State);
return;
}
// Tracking for return types.
SymbolRef RecSym = M.getReceiverSVal().getAsSymbol();
if (!RecSym)
return;
const ObjCObjectPointerType *const *TrackedType =
State->get<MostSpecializedTypeArgsMap>(RecSym);
if (!TrackedType)
return;
ASTContext &ASTCtxt = C.getASTContext();
const ObjCMethodDecl *Method =
findMethodDecl(MessageExpr, *TrackedType, ASTCtxt);
if (!Method)
return;
Optional<ArrayRef<QualType>> TypeArgs =
(*TrackedType)->getObjCSubstitutions(Method->getDeclContext());
if (!TypeArgs)
return;
QualType ResultType =
getReturnTypeForMethod(Method, *TypeArgs, *TrackedType, ASTCtxt);
// The static type is the same as the deduced type.
if (ResultType.isNull())
return;
const MemRegion *RetRegion = M.getReturnValue().getAsRegion();
ExplodedNode *Pred = C.getPredecessor();
// When there is an entry available for the return symbol in DynamicTypeMap,
// the call was inlined, and the information in the DynamicTypeMap is should
// be precise.
if (RetRegion && !State->get<DynamicTypeMap>(RetRegion)) {
// TODO: we have duplicated information in DynamicTypeMap and
// MostSpecializedTypeArgsMap. We should only store anything in the later if
// the stored data differs from the one stored in the former.
State = setDynamicTypeInfo(State, RetRegion, ResultType,
/*CanBeSubclass=*/true);
Pred = C.addTransition(State);
}
const auto *ResultPtrType = ResultType->getAs<ObjCObjectPointerType>();
if (!ResultPtrType || ResultPtrType->isUnspecialized())
return;
// When the result is a specialized type and it is not tracked yet, track it
// for the result symbol.
if (!State->get<MostSpecializedTypeArgsMap>(RetSym)) {
State = State->set<MostSpecializedTypeArgsMap>(RetSym, ResultPtrType);
C.addTransition(State, Pred);
}
}
