void Object::lower()
{
Dout( dc::notice, *this << " lower" );
evas_object_lower( o );
}
void AIStateMachine::multiplex(event_type event)
{
// If this fails then you are using a pointer to a state machine instead of an LLPointer.
llassert(event == initial_run || getNumRefs() > 0);
DoutEntering(dc::statemachine(mSMDebug), "AIStateMachine::multiplex(" << event_str(event) << ") [" << (void*)this << "]");
base_state_type state;
state_type run_state;
// Critical area of mState.
{
multiplex_state_type_rat state_r(mState);
// If another thread is already running multiplex() then it will pick up
// our need to run (by us having set need_run), so there is no need to run
// ourselves.
llassert(!mMultiplexMutex.isSelfLocked()); // We may never enter recursively!
if (!mMultiplexMutex.tryLock())
{
Dout(dc::statemachine(mSMDebug), "Leaving because it is already being run [" << (void*)this << "]");
return;
}
//===========================================
// Start of critical area of mMultiplexMutex.
// If another thread already called begin_loop() since we needed a run,
// then we must not schedule a run because that could lead to running
// the same state twice. Note that if need_run was reset in the mean
// time and then set again, then it can't hurt to schedule a run since
// we should indeed run, again.
if (event == schedule_run && !sub_state_type_rat(mSubState)->need_run)
{
Dout(dc::statemachine(mSMDebug), "Leaving because it was already being run [" << (void*)this << "]");
return;
}
// We're at the beginning of multiplex, about to actually run it.
// Make a copy of the states.
run_state = begin_loop((state = state_r->base_state));
}
// End of critical area of mState.
bool keep_looping;
bool destruct = false;
do
{
if (event == normal_run)
{
#ifdef CWDEBUG
if (state == bs_multiplex)
Dout(dc::statemachine(mSMDebug), "Running state bs_multiplex / " << state_str_impl(run_state) << " [" << (void*)this << "]");
else
Dout(dc::statemachine(mSMDebug), "Running state " << state_str(state) << " [" << (void*)this << "]");
#endif
#ifdef SHOW_ASSERT
// This debug code checks that each state machine steps precisely through each of it's states correctly.
if (state != bs_reset)
{
switch(mDebugLastState)
{
case bs_reset:
llassert(state == bs_initialize || state == bs_killed);
break;
case bs_initialize:
llassert(state == bs_multiplex || state == bs_abort);
break;
case bs_multiplex:
llassert(state == bs_multiplex || state == bs_finish || state == bs_abort);
break;
case bs_abort:
llassert(state == bs_finish);
break;
case bs_finish:
llassert(state == bs_callback);
break;
case bs_callback:
llassert(state == bs_killed || state == bs_reset);
break;
case bs_killed:
llassert(state == bs_killed);
break;
}
}
// More sanity checks.
if (state == bs_multiplex)
{
// set_state is only called from multiplex_impl and therefore synced with mMultiplexMutex.
mDebugShouldRun |= mDebugSetStatePending;
// Should we run at all?
llassert(mDebugShouldRun);
}
// Any previous reason to run is voided by actually running.
mDebugShouldRun = false;
#endif
mRunMutex.lock();
// Now we are actually running a single state.
// If abort() was called at any moment before, we execute that state instead.
bool const late_abort = (state == bs_multiplex || state == bs_initialize) && sub_state_type_rat(mSubState)->aborted;
if (LL_UNLIKELY(late_abort))
{
// abort() was called from a child state machine, from another thread, while we were already scheduled to run normally from an engine.
// What we want to do here is pretend we detected the abort at the end of the *previous* run.
// If the state is bs_multiplex then the previous state was either bs_initialize or bs_multiplex,
// both of which would have switched to bs_abort: we set the state to bs_abort instead and just
// continue this run.
// However, if the state is bs_initialize we can't switch to bs_killed because that state isn't
// handled in the switch below; it's only handled when exiting multiplex() directly after it is set.
// Therefore, in that case we have to set the state BACK to bs_reset and run it again. This duplicated
// run of bs_reset is not a problem because it happens to be a NoOp.
state = (state == bs_initialize) ? bs_reset : bs_abort;
#ifdef CWDEBUG
Dout(dc::statemachine(mSMDebug), "Late abort detected! Running state " << state_str(state) << " instead [" << (void*)this << "]");
#endif
}
#ifdef SHOW_ASSERT
mDebugLastState = state;
// Make sure we only call ref() once and in balance with unref().
if (state == bs_initialize)
{
// This -- and call to ref() (and the test when we're about to call unref()) -- is all done in the critical area of mMultiplexMutex.
llassert(!mDebugRefCalled);
mDebugRefCalled = true;
}
#endif
switch(state)
{
case bs_reset:
// We're just being kick started to get into the right thread
// (possibly for the second time when a late abort was detected, but that's ok: we do nothing here).
break;
case bs_initialize:
ref();
initialize_impl();
break;
case bs_multiplex:
llassert(!mDebugAborted);
multiplex_impl(run_state);
break;
case bs_abort:
abort_impl();
break;
case bs_finish:
sub_state_type_wat(mSubState)->reset = false; // By default, halt state machines when finished.
finish_impl(); // Call run() from finish_impl() or the call back to restart from the beginning.
break;
case bs_callback:
callback();
break;
case bs_killed:
mRunMutex.unlock();
// bs_killed is handled when it is set. So, this must be a re-entry.
// We can only get here when being called by an engine that we were added to before we were killed.
// This should already be have been set to NULL to indicate that we want to be removed from that engine.
llassert(!multiplex_state_type_rat(mState)->current_engine);
// Do not call unref() twice.
return;
}
mRunMutex.unlock();
}
{
multiplex_state_type_wat state_w(mState);
//=================================
// Start of critical area of mState
// Unless the state is bs_multiplex or bs_killed, the state machine needs to keep calling multiplex().
bool need_new_run = true;
if (event == normal_run || event == insert_abort)
{
sub_state_type_rat sub_state_r(mSubState);
if (event == normal_run)
{
// Switch base state as function of sub state.
switch(state)
{
case bs_reset:
if (sub_state_r->aborted)
{
// We have been aborted before we could even initialize, no de-initialization is possible.
state_w->base_state = bs_killed;
// Stop running.
need_new_run = false;
}
else
{
// run() was called: call initialize_impl() next.
state_w->base_state = bs_initialize;
}
break;
case bs_initialize:
if (sub_state_r->aborted)
{
// initialize_impl() called abort.
state_w->base_state = bs_abort;
}
else
{
// Start actually running.
state_w->base_state = bs_multiplex;
// If the state is bs_multiplex we only need to run again when need_run was set again in the meantime or when this state machine isn't idle.
need_new_run = sub_state_r->need_run || !sub_state_r->idle;
}
break;
case bs_multiplex:
if (sub_state_r->aborted)
{
// abort() was called.
state_w->base_state = bs_abort;
}
else if (sub_state_r->finished)
{
// finish() was called.
state_w->base_state = bs_finish;
}
else
{
// Continue in bs_multiplex.
// If the state is bs_multiplex we only need to run again when need_run was set again in the meantime or when this state machine isn't idle.
need_new_run = sub_state_r->need_run || !sub_state_r->idle;
// If this fails then the run state didn't change and neither idle() nor yield() was called.
llassert_always(!(need_new_run && !sub_state_r->skip_idle && !mYieldEngine && sub_state_r->run_state == run_state));
}
break;
case bs_abort:
// After calling abort_impl(), call finish_impl().
state_w->base_state = bs_finish;
break;
case bs_finish:
// After finish_impl(), call the call back function.
state_w->base_state = bs_callback;
break;
case bs_callback:
if (sub_state_r->reset)
{
// run() was called (not followed by kill()).
state_w->base_state = bs_reset;
}
else
{
// After the call back, we're done.
state_w->base_state = bs_killed;
// Call unref().
destruct = true;
// Stop running.
need_new_run = false;
}
break;
default: // bs_killed
// We never get here.
break;
}
}
else // event == insert_abort
{
// We have been aborted, but we're idle. If we'd just schedule a new run below, it would re-run
// the last state before the abort is handled. What we really need is to pick up as if the abort
// was handled directly after returning from the last run. If we're not running anymore, then
// do nothing as the state machine already ran and things should be processed normally
// (in that case this is just a normal schedule which can't harm because we're can't accidently
// re-run an old run_state).
if (state_w->base_state == bs_multiplex) // Still running?
{
// See the switch above for case bs_multiplex.
llassert(sub_state_r->aborted);
// abort() was called.
state_w->base_state = bs_abort;
}
}
#ifdef CWDEBUG
if (state != state_w->base_state)
Dout(dc::statemachine(mSMDebug), "Base state changed from " << state_str(state) << " to " << state_str(state_w->base_state) <<
"; need_new_run = " << (need_new_run ? "true" : "false") << " [" << (void*)this << "]");
#endif
}
// Figure out in which engine we should run.
AIEngine* engine = mYieldEngine ? mYieldEngine : (state_w->current_engine ? state_w->current_engine : mDefaultEngine);
// And the current engine we're running in.
AIEngine* current_engine = (event == normal_run) ? state_w->current_engine : NULL;
// Immediately run again if yield() wasn't called and it's OK to run in this thread.
// Note that when it's OK to run in any engine (mDefaultEngine is NULL) then the last
// compare is also true when current_engine == NULL.
keep_looping = need_new_run && !mYieldEngine && engine == current_engine;
mYieldEngine = NULL;
if (keep_looping)
{
// Start a new loop.
run_state = begin_loop((state = state_w->base_state));
event = normal_run;
}
else
{
if (need_new_run)
{
// Add us to an engine if necessary.
if (engine != state_w->current_engine)
{
// engine can't be NULL here: it can only be NULL if mDefaultEngine is NULL.
engine->add(this);
// Mark that we're added to this engine, and at the same time, that we're not added to the previous one.
state_w->current_engine = engine;
}
#ifdef SHOW_ASSERT
// We are leaving the loop, but we're not idle. The statemachine should re-enter the loop again.
mDebugShouldRun = true;
#endif
}
else
{
// Remove this state machine from any engine,
// causing the engine to remove us.
state_w->current_engine = NULL;
}
#ifdef SHOW_ASSERT
// Mark that we stop running the loop.
mThreadId.clear();
if (destruct)
{
// We're about to call unref(). Make sure we call that in balance with ref()!
llassert(mDebugRefCalled);
mDebugRefCalled = false;
}
#endif
// End of critical area of mMultiplexMutex.
//=========================================
// Release the lock on mMultiplexMutex *first*, before releasing the lock on mState,
// to avoid to ever call the tryLock() and fail, while this thread isn't still
// BEFORE the critical area of mState!
mMultiplexMutex.unlock();
}
// Now it is safe to leave the critical area of mState as the tryLock won't fail anymore.
// (Or, if we didn't release mMultiplexMutex because keep_looping is true, then this
// end of the critical area of mState is equivalent to the first critical area in this
// function.
// End of critical area of mState.
//================================
}
}
while (keep_looping);
if (destruct)
{
unref();
}
}
EvasCanvas::~EvasCanvas()
{
Dout( dc::notice, "EvasCanvas::~Canvas - freeing Evas" );
evas_free( o );
}
inline virtual ~ErlTuple() {
Dout(dc::erlang, "["<<this<<"] ~ErlTuple()");
}
/*
* Print mail entries
*/
void
printmail()
{
static char pn[] = "printmail";
int flg, curlet, showlet, k, print, aret, stret, rc;
int nsmbox = 0; /* 1 ==> mailbox is in non-standard place */
int sav_j = -1;
char *p, *getarg();
struct stat stbuf;
struct stat *stbufp;
int ttyf = isatty(1) ? TTY : ORDINARY;
char readbuf[LSIZE]; /* holds user's response in interactive mode */
char *resp;
gid_t savedegid;
stbufp = &stbuf;
/*
* create working directory mbox name
*/
if ((hmbox = malloc(strlen(home) + strlen(mbox) + 1)) == NULL) {
errmsg(E_MBOX, "");
return;
}
cat(hmbox, home, mbox);
/*
* If we are not using an alternate mailfile, then get
* the $MAIL value and build the filename for the mailfile.
* If $MAIL is set, but is NOT the 'standard' place, then
* use it but set flgf to circumvent :saved processing.
*/
if (!flgf) {
if ((p = malloc(strlen(maildir) + strlen(my_name) + 1))
== NULL) {
errmsg(E_MEM, "");
return;
}
cat(p, maildir, my_name);
if (((mailfile = getenv("MAIL")) == NULL) ||
(strlen(mailfile) == 0)) {
/* $MAIL not set, use standard path to mailfile */
mailfile = p;
} else {
if (strcmp(mailfile, p) != 0) {
flgf = 1;
nsmbox = 1;
Dout(pn, 0, "$MAIL ('%s') != standard path\n",
mailfile);
Dout("", 0, "\tSetting flgf to 1.\n");
}
free(p);
}
}
/*
* Get ACCESS and MODIFICATION times of mailfile BEFORE we
* use it. This allows us to put them back when we are
* done. If we didn't, the shell would think NEW mail had
* arrived since the file times would have changed.
*/
stret = CERROR;
if (access(mailfile, A_EXIST) == A_OK) {
if ((stret = stat(mailfile, stbufp)) != A_OK) {
errmsg(E_FILE, "Cannot stat mailfile");
return;
}
mf_gid = stbufp->st_gid;
mf_uid = stbufp->st_uid;
utimep->actime = stbufp->st_atime;
utimep->modtime = stbufp->st_mtime;
file_size = stbufp->st_size;
}
/* Open the file as the real gid */
savedegid = getegid();
(void) setegid(getgid());
malf = fopen(mailfile, "r");
(void) setegid(savedegid);
/*
* stat succeeded, but we cannot access the mailfile
*/
if (stret == CSUCCESS && malf == NULL) {
char buf[MAXFILENAME+50];
(void) snprintf(buf, sizeof (buf),
"Invalid permissions on %s", mailfile);
errmsg(E_PERM, buf);
return;
} else
/*
* using an alternate mailfile, but we failed on access
*/
if (!nsmbox && flgf && (malf == NULL)) {
errmsg(E_FILE, "Cannot open mailfile");
return;
}
/*
* we failed to access OR the file is empty
*/
else if ((malf == NULL) || (stbuf.st_size == 0)) {
if (!flge && !flgE) {
printf("No mail.\n");
}
error = E_FLGE;
Dout(pn, 0, "error set to %d\n", error);
return;
}
if (flge)
return;
if (flgE) {
if (utimep->modtime < utimep->actime) {
error = E_FLGE_OM;
Dout(pn, 0, "error set to %d\n", error);
}
return;
}
/*
* Secure the mailfile to guarantee integrity
*/
lock(my_name);
/*
* copy mail to temp file and mark each letter in the
* let array --- mailfile is still locked !!!
*/
mktmp();
copymt(malf, tmpf);
onlet = nlet;
fclose(malf);
fclose(tmpf);
unlock(); /* All done, OK to unlock now */
tmpf = doopen(lettmp, "r+", E_TMP);
changed = 0;
print = 1;
curlet = 0;
while (curlet < nlet) {
/*
* reverse order ?
*/
showlet = flgr ? curlet : nlet - curlet - 1;
if (setjmp(sjbuf) == 0 && print != 0) {
/* -h says to print the headers first */
if (flgh) {
gethead(showlet, 0);
flgh = 0; /* Only once */
/* set letter # to invalid # */
curlet--;
showlet =
flgr ? curlet : nlet - curlet - 1;
} else {
if (showlet != sav_j) {
/* Looking at new message. */
/* Reset flag to override */
/* non-display of binary */
/* contents */
sav_j = showlet;
pflg = 0;
Pflg = flgP;
}
copylet(showlet, stdout, ttyf);
}
}
/*
* print only
*/
if (flgp) {
curlet++;
continue;
}
/*
* Interactive
*/
interactive = 1;
setjmp(sjbuf);
stat(mailfile, stbufp);
if (stbufp->st_size != file_size) {
/*
* New mail has arrived, load it
*/
k = nlet;
lock(my_name);
malf = doopen(mailfile, "r", E_FILE);
fclose(tmpf);
tmpf = doopen(lettmp, "a", E_TMP);
fseek(malf, let[nlet].adr, 0);
copymt(malf, tmpf);
file_size = stbufp->st_size;
fclose(malf);
fclose(tmpf);
unlock();
tmpf = doopen(lettmp, "r+", E_TMP);
if (++k < nlet)
printf("New mail loaded into letters %d - %d\n",
k, nlet);
else
printf("New mail loaded into letter %d\n",
nlet);
}
/* read the command */
printf("? ");
fflush(stdout);
fflush(stderr);
if (fgets(readbuf, sizeof (readbuf), stdin) == NULL) break;
resp = readbuf;
while (*resp == ' ' || *resp == '\t') resp++;
print = 1;
Dout(pn, 0, "resp = '%s'\n", resp);
if ((rc = atoi(resp)) != 0) {
if (!validmsg(rc)) print = 0;
else curlet = flgr ? rc - 1 : nlet - rc;
} else switch (resp[0]) {
default:
printf("Usage:\n");
/*
* help
*/
case '?':
print = 0;
for (rc = 0; help[rc]; rc++)
printf("%s", help[rc]);
break;
/*
* print message number of current message
*/
case '#':
print = 0;
if ((showlet == nlet) || (showlet < 0)) {
printf("No message selected yet.\n");
} else {
printf("Current message number is %d\n",
showlet+1);
}
break;
/*
* headers
*/
case 'h':
print = 0;
if (resp[2] != 'd' &&
resp[2] != 'a' &&
(rc = getnumbr(resp+1)) > 0) {
showlet = rc - 1;
curlet = flgr ? rc - 1 : nlet - rc- 1;
}
if (rc == -1 && resp[2] != 'a' &&
resp[2] != 'd')
break;
if (resp[2] == 'a') rc = 1;
else if (resp[2] == 'd') rc = 2;
else rc = 0;
/*
* if (!validmsg(showlet)) break;
*/
gethead(showlet, rc);
break;
/*
* skip entry
*/
case '+':
case 'n':
case '\n':
curlet++;
break;
case 'P':
Pflg++;
break;
case 'p':
pflg++;
break;
case 'x':
changed = 0;
case 'q':
goto donep;
/*
* Previous entry
*/
case '^':
case '-':
if (--curlet < 0) curlet = 0;
break;
/*
* Save in file without header
*/
case 'y':
case 'w':
/*
* Save mail with header
*/
case 's':
print = 0;
if (!validmsg(curlet)) break;
if (resp[1] == '\n' || resp[1] == '\0') {
cat(resp+1, hmbox, "");
} else if (resp[1] != ' ') {
printf("Invalid command\n");
break;
}
umask(umsave);
flg = 0;
if (getarg(lfil, resp + 1) == NULL) {
cat(resp + 1, hmbox, "");
}
malf = (FILE *)NULL;
p = resp + 1;
while ((p = getarg(lfil, p)) != NULL) {
if (flg) {
fprintf(stderr,
"%s: File '%s' skipped\n",
program, lfil);
continue;
}
malf = NULL;
if ((aret = legal(lfil))) {
malf = fopen(lfil, "a");
}
if ((malf == NULL) || (aret == 0)) {
fprintf(stderr,
"%s: Cannot append to %s\n",
program, lfil);
flg++;
} else if (aret == 2) {
chown(lfil, my_euid, my_gid);
}
if (!flg &&
copylet(showlet, malf, resp[0] ==
's'? ORDINARY: ZAP) == FALSE) {
fprintf(stderr,
"%s: Cannot save mail to '%s'\n",
program, lfil);
flg++;
} else
Dout(pn, 0, "!saved\n");
if (malf != (FILE *)NULL) {
fclose(malf);
}
}
umask(7);
if (!flg) {
setletr(showlet, resp[0]);
print = 1;
curlet++;
}
break;
/*
* Reply to a letter
*/
case 'r':
print = 0;
if (!validmsg(curlet)) break;
replying = 1;
for (k = 1; resp[k] == ' ' || resp[k] == '\t';
++k);
resp[strlen(resp)-1] = '\0';
(void) strlcpy(m_sendto, resp+k,
sizeof (m_sendto));
goback(showlet);
replying = 0;
setletr(showlet, resp[0]);
break;
/*
* Undelete
*/
case 'u':
print = 0;
if ((k = getnumbr(resp+1)) <= 0) k = showlet;
else k--;
if (!validmsg(k)) break;
setletr(k, ' ');
break;
/*
* Mail letter to someone else
*/
case 'm':
{
reciplist list;
print = 0;
if (!validmsg(curlet)) break;
new_reciplist(&list);
flg = 0;
k = 0;
if (substr(resp, " -") != -1 ||
substr(resp, "\t-") != -1) {
printf("Only users may be specified\n");
break;
}
p = resp + 1;
while ((p = getarg(lfil, p)) != NULL) {
char *env;
if (lfil[0] == '$') {
if (!(env = getenv(&lfil[1]))) {
fprintf(stderr,
"%s: %s has no value or is not exported.\n",
program, lfil);
flg++;
} else
add_recip(&list, env,
FALSE);
k++;
} else if (lfil[0] != '\0') {
add_recip(&list, lfil, FALSE);
k++;
}
}
(void) strlcpy(Rpath, my_name, sizeof (Rpath));
sending = TRUE;
flg += sendlist(&list, showlet, 0);
sending = FALSE;
if (k) {
if (!flg) {
setletr(showlet, 'm');
print = 1;
curlet++;
}
} else
printf("Invalid command\n");
del_reciplist(&list);
break;
}
/*
* Read new letters
*/
case 'a':
if (onlet == nlet) {
printf("No new mail\n");
print = 0;
break;
}
curlet = 0;
print = 1;
break;
/*
* Escape to shell
*/
case '!':
systm(resp + 1);
printf("!\n");
print = 0;
break;
/*
* Delete an entry
*/
case 'd':
print = 0;
k = 0;
if (strncmp("dq", resp, 2) != SAME &&
strncmp("dp", resp, 2) != SAME)
if ((k = getnumbr(resp+1)) == -1) break;
if (k == 0) {
k = showlet;
if (!validmsg(curlet)) break;
print = 1;
curlet++;
} else k--;
setletr(k, 'd');
if (resp[1] == 'p') print = 1;
else if (resp[1] == 'q') goto donep;
break;
}
}
/*
* Copy updated mailfile back
*/
donep:
if (changed) {
copyback();
stamp();
}
}
EcoreEvasWindow::~EcoreEvasWindow()
{
Dout( dc::notice, "EcoreEvasWindow::~EcoreEvasWindow" );
delete _canvas;
}
void EcoreEvasWindow::deleteRequestEvent()
{
Dout( dc::notice, "EcoreEvasWindow::deleteRequestEvent()" );
if ( canClose() ) eApp->quit();
}
Object::~Object()
{
Dout( dc::notice, *this << " Object::~Object" );
unregisterCallbacks ();
}
void Object::move( const Point& point )
{
Dout( dc::notice, *this << " move" << " x=" << x << " y=" << y );
evas_object_move( o, point.x(), point.y() );
}
void Object::hide()
{
Dout( dc::notice, *this << " hide" );
evas_object_hide( o );
}
void Object::setFocus( bool focus )
{
Dout( dc::notice, *this << " setFocus:" << focus );
evas_object_focus_set( o, focus );
}
void Object::show()
{
Dout( dc::notice, *this << " show" );
evas_object_show( o );
}
void Object::stackBelow( const Object* obj )
{
Dout( dc::notice, *this << " stackBelow" );
evas_object_stack_below( o, obj->obj() );
}
void Object::stackAbove( const Object* obj )
{
Dout( dc::notice, *this << " stackAbove" );
evas_object_stack_above( o, obj->obj() );
}
void EcoreEvasWindow::mouseOutEvent()
{
Dout( dc::notice, "EcoreEvasWindow::mouseOutEvent()" );
}
void Object::resize( const Size& size, bool fill )
{
Dout( dc::notice, *this << " resize" << " width=" << width << " height=" << height );
evas_object_resize( o, size.width(), size.height() );
}
void EcoreEvasWindow::postRenderEvent()
{
Dout( dc::notice, "EcoreEvasWindow::postRenderEvent()" );
}
AICurlEasyRequestStateMachine::~AICurlEasyRequestStateMachine()
{
Dout(dc::statemachine(mSMDebug), "Calling ~AICurlEasyRequestStateMachine() [" << (void*)this << "] [" << (void*)mCurlEasyRequest.get() << "]");
--AICurlInterface::Stats::AICurlEasyRequestStateMachine_count;
}
void EcoreEvasWindow::hideEvent()
{
Dout( dc::notice, "EcoreEvasWindow::hideEvent()" );
}
void AIFetchInventoryFolder::multiplex_impl(state_type run_state)
{
switch (run_state)
{
case AIFetchInventoryFolder_checkFolderExists:
{
// If LLInventoryModel_mIsAgentInvUsable_true then this should be and stay true forever.
llassert(gInventory.isInventoryUsable());
if (mParentFolder.isNull())
mParentFolder = gInventory.getRootFolderID();
if (mFolderUUID.isNull() || !gInventory.getCategory(mFolderUUID)) // Is the UUID unknown, or doesn't exist?
{
// Set this to null here in case we abort.
mFolderUUID.setNull();
if (mFolderName.empty())
{
// We can only find a folder by name, or create it, if we know it's name.
llwarns << "Unknown folder ID " << mFolderUUID << llendl;
abort();
break;
}
// Check if the parent exists.
if (mParentFolder != gInventory.getRootFolderID() && !gInventory.getCategory(mParentFolder))
{
llwarns << "Unknown parent folder ID " << mParentFolder << llendl;
abort();
break;
}
// Look up UUID by name.
LLInventoryModel::cat_array_t* categories;
gInventory.getDirectDescendentsOf(mParentFolder, categories);
for (S32 i = 0; i < categories->getLength(); ++i)
{
LLPointer<LLViewerInventoryCategory> const& category(categories->get(i));
if (category->getName() == mFolderName)
{
mFolderUUID = category->getUUID();
break;
}
}
if (mFolderUUID.isNull()) // Does the folder exist?
{
if (!mCreate)
{
// We're done.
finish();
break;
}
// Create the folder.
mFolderUUID = gInventory.createNewCategory(mParentFolder, LLFolderType::FT_NONE, mFolderName);
llassert_always(!mFolderUUID.isNull());
Dout(dc::statemachine, "Created folder \"" << mFolderName << "\".");
mNeedNotifyObservers = true;
}
mCreated = true;
}
// mFolderUUID is now valid.
mExists = true;
if (!mFetchContents || // No request to fetch contents.
LLInventoryModelBackgroundFetch::instance().isEverythingFetched()) // No need to fetch contents.
{
// We're done.
finish();
break;
}
set_state(AIFetchInventoryFolder_fetchDescendents);
/*Fall-through*/
}
case AIFetchInventoryFolder_fetchDescendents:
{
idle(); // Wait till the state is set to AIFetchInventoryFolder_folderCompleted.
// This sets the state to AIFetchInventoryFolder_folderCompleted once the folder is complete.
new AIInventoryFetchDescendentsObserver(this, mFolderUUID);
break;
}
case AIFetchInventoryFolder_folderCompleted:
{
// Does it still exist?
if (!gInventory.getCategory(mFolderUUID))
{
// Assume the folder was deleted in the meantime.
abort();
break;
}
llassert(gInventory.isCategoryComplete(mFolderUUID));
// The folder is complete!
finish();
break;
}
}
}
void NodeStore::addNode(bool_node* node){
node->id = newnodes.size() + dagsize;
Dout(cout<<" add "<<node->id<<" "<<node->get_name()<<endl);
newnodes.push_back(node);
}
inline virtual ~ErlConsList() {
Dout(dc::erlang, "["<<this<<"] ~ErlConsList()");
}
/**
* Create unitialized tuple
* Arity and elements have to be initialized.
*/
inline ErlTuple(): ErlTerm(), mArityDefined(false), mElementVector(0) {
Dout(dc::erlang, "Created unitialized Tuple at" << this);
}
/*
Send mail - High level sending routine
*/
void
sendmail(int argc, char **argv)
{
char **args;
char *tp, *zp;
char *buf = NULL;
size_t bufsize = 0;
char last1c;
FILE *input;
struct stat sbuf;
int aret;
int i, n;
int oldn = 1;
int ttyf = 0;
int pushrest = 0;
int hdrtyp = 0;
int ctf = FALSE;
int binflg = 0;
long count = 0L;
struct tm *bp;
struct hdrs *hptr;
static char pn[] = "sendmail";
reciplist list;
buf = smalloc(bufsize = 2048);
Dout(pn, 0, "entered\n");
new_reciplist(&list);
for (i = 1; i < argc; ++i) {
if (argv[i][0] == '-') {
if (argv[i][1] == '\0') {
errmsg(E_SYNTAX,"Hyphens MAY NOT be followed by spaces");
}
if (i > 1) {
errmsg(E_SYNTAX,"Options MUST PRECEDE persons");
}
done(0);
}
/*
Ensure no NULL names in list
*/
if (argv[i][0] == '\0' || argv[i][strlen(argv[i])-1] == '!') {
errmsg(E_SYNTAX,"Null names are not allowed");
done(0);
}
add_recip(&list, argv[i], FALSE); /* Don't check for duplication */
}
mktmp();
/*
Format time
*/
time(&iop);
bp = localtime(&iop);
tp = asctime(bp);
zp = tzname[bp->tm_isdst];
sprintf(datestring, "%.16s %.4s %.5s", tp, zp, tp+20);
trimnl (datestring);
/* asctime: Fri Sep 30 00:00:00 1986\n */
/* 0123456789012345678901234 */
/* RFCtime: Fri, 28 Jul 89 10:30 EDT */
sprintf(RFC822datestring, "%.3s, %.2s %.3s %.4s %.5s %.3s",
tp, tp+8, tp+4, tp+20, tp+11, zp);
/*
Write out the from line header for the letter
*/
if (fromflag && deliverflag && from_user[0] != '\0') {
snprintf(buf, bufsize, "%s%s %s\n",
header[H_FROM].tag, from_user, datestring);
} else {
snprintf(buf, bufsize, "%s%s %s\n",
header[H_FROM].tag, my_name, datestring);
}
if (!wtmpf(buf, strlen(buf))) {
done(0);
}
savehdrs(buf, H_FROM);
/*
Copy to list in mail entry?
*/
if (flgt == 1 && argc > 1) {
aret = argc;
args = argv;
while (--aret > 0) {
snprintf(buf, bufsize, "%s %s\n", header[H_TO].tag, *++args);
if (!wtmpf(buf, strlen(buf))) {
done(0);
}
savehdrs(buf, H_TO);
}
}
flgf = 1; /* reset when first read of message body succeeds */
/*
Read mail message, allowing for lines of infinite
length. This is tricky, have to watch for newlines.
*/
saveint = setsig(SIGINT, savdead);
last1c = ' '; /* anything other than newline */
ttyf = isatty (fileno(stdin));
pushrest = 0;
/*
* scan header & save relevant info.
*/
cpy(&fromU, &fromUsize, my_name);
cpy(&fromS, &fromSsize, "");
input = stdin;
if (fstat(fileno(input), &sbuf) < 0) {
#ifdef EOVERFLOW
if (errno == EOVERFLOW) {
perror("stdin");
exit(1);
}
#endif
}
while ((n = getline (&line, &linesize, stdin)) > 0) {
last1c = line[n-1];
if (pushrest) {
if (!wtmpf(line,n)) {
done(0);
}
pushrest = (last1c != '\n');
continue;
}
pushrest = (last1c != '\n');
if ((hdrtyp = isheader (line, &ctf)) == FALSE) {
break;
}
flgf = 0;
switch (hdrtyp) {
case H_RVERS:
/* Are we dealing with a delivery report? */
/* dflag = 9 ==> do not return on failure */
dflag = 9;
Dout(pn, 0, "dflag = 9\n");
break;
case H_FROM:
if (!wtmpf(">", 1)) {
done(0);
}
/* note dropthru */
hdrtyp = H_FROM1;
case H_FROM1:
if (substr(line, "forwarded by") > -1) {
break;
}
pickFrom (line);
if (Rpath[0] != '\0')
concat(&Rpath, &Rpathsize, "!");
concat(&Rpath, &Rpathsize, fromS);
n = 0; /* don't copy remote from's into mesg. */
break;
case H_CTYPE:
/* suppress it: only generated if needed */
n = 0; /* suppress */
break;
case H_TCOPY:
/* Write out placeholder for later */
snprintf(buf, bufsize, "%s \n", header[H_TCOPY].tag);
if (!wtmpf(buf, strlen(buf))) {
done(0);
}
n = 0; /* suppress */
break;
case H_MTYPE:
if (flgm) {
/* suppress if message-type argument */
n = 0;
}
break;
case H_CONT:
if (oldn == 0) {
/* suppress continuation line also */
n = 0;
}
break;
}
oldn = n; /* remember if this line was suppressed */
if (n && !wtmpf(line,n)) {
done(0);
}
if (!n) savehdrs(line, hdrtyp);
}
if (Rpath != NULL && Rpath[0] != '\0')
concat(&Rpath, &Rpathsize, "!");
concat(&Rpath, &Rpathsize, fromU);
/* push out message type if so requested */
if (flgm) { /* message-type */
snprintf(buf, bufsize, "%s%s\n", header[H_MTYPE].tag, msgtype);
if (!wtmpf(buf, strlen(buf))) {
done(0);
}
}
if (n > bufsize) {
free(buf);
buf = smalloc(bufsize = n);
}
memcpy (buf, line, n);
if (n == 0 || (ttyf && !strncmp (buf, ".\n", 2)) ) {
if (flgf) {
/* no input */
return;
} else {
/*
* no content: put content-type
* only if explicitly present.
* Write out 'place-holders' only. (see below....)
*/
if ((hptr = hdrlines[H_CTYPE].head) !=
(struct hdrs *)NULL) {
snprintf(line, linesize, "%s \n", header[H_CTYPE].tag);
if (!wtmpf(line, strlen(line))) {
done(0);
}
}
goto wrapsend;
}
}
if (n == 1 && last1c == '\n') { /* blank line -- suppress */
n = getline (&buf, &bufsize, stdin);
if (n == 0 || (ttyf && !strncmp (buf, ".\n", 2)) ) {
/*
* no content: put content-type
* only if explicitly present.
* Write out 'place-holder' only. (see below....)
*/
if ((hptr = hdrlines[H_CTYPE].head) !=
(struct hdrs *)NULL) {
snprintf(line, linesize, "%s \n", header[H_CTYPE].tag);
if (!wtmpf(line, strlen(line))) {
done(0);
}
}
goto wrapsend;
}
}
if (debug > 0) {
buf[n] = '\0';
Dout(pn, 0, "header scan complete, readahead %d = \"%s\"\n", n, buf);
}
/*
* Write out H_CTYPE line. This is used only as
* placeholders in the tmp file. When the 'real' message is sent,
* the proper value will be put out by copylet().
*/
snprintf(line, linesize, "%s \n", header[H_CTYPE].tag);
if (!wtmpf(line, strlen(line))) {
done(0);
}
if (hdrlines[H_CTYPE].head == (struct hdrs *)NULL) {
savehdrs(line,H_CTYPE);
}
/* and a blank line */
if (!wtmpf("\n", 1)) {
done(0);
}
Dout(pn, 0, "header out completed\n");
pushrest = 0;
count = 0L;
/*
* Are we returning mail from a delivery failure of an old-style
* (SVR3.1 or SVR3.0) rmail? If so, we won't return THIS on failure
* [This line should occur as the FIRST non-blank non-header line]
*/
if (!strncmp("***** UNDELIVERABLE MAIL sent to",buf,32)) {
dflag = 9; /* 9 says do not return on failure */
Dout(pn, 0, "found old-style UNDELIVERABLE line. dflag = 9\n");
}
/* scan body of message */
while (n > 0) {
if (ttyf && !strcmp (buf, ".\n"))
break;
if (!binflg) {
binflg = !istext ((unsigned char *)buf, n);
}
if (!wtmpf(buf, n)) {
done(0);
}
count += n;
n = ttyf
? getline (&buf, &bufsize, stdin)
: fread (buf, 1, bufsize, stdin);
}
setsig(SIGINT, saveint);
wrapsend:
/*
* In order to use some of the subroutines that are used to
* read mail, the let array must be set up
*/
nlet = 1;
let[0].adr = 0;
let[1].adr = ftell(tmpf);
let[0].text = (binflg == 1 ? FALSE : TRUE);
Dout(pn, 0, "body copy complete, count %ld\n", count);
/*
* Modify value of H_CTYPE if necessary.
*/
if ((hptr = hdrlines[H_CTYPE].head) != (struct hdrs *)NULL) {
if (strlen(hptr->value) == 0)
strcpy(hptr->value, binflg ? "binary" : "text");
}
if (fclose(tmpf) == EOF) {
tmpf = NULL;
tmperr();
done(0);
}
tmpf = doopen(lettmp,"r+",E_TMP);
/* Do not send mail on SIGINT */
if (dflag == 2) {
done(0);
}
sendlist(&list, 0, 0);
done(0);
}
// static
void AIEngine::setMaxCount(F32 StateMachineMaxTime)
{
llassert(AIThreadID::in_main_thread());
Dout(dc::statemachine, "(Re)calculating AIStateMachine::sMaxCount");
sMaxCount = calc_clock_frequency() * StateMachineMaxTime / 1000;
}
void EcoreEvasWindow::destroyEvent()
{
Dout( dc::notice, "EcoreEvasWindow::destroyEvent()" );
}
/*
Routine creates dead.letter
*/
void mkdead()
{
static char pn[] = "mkdead";
int aret;
char *dotdead = &dead[1];
gid_t egid = getegid();
struct stat st;
malf = (FILE *)NULL;
/*
Make certain that there's something to copy.
*/
if (!tmpf)
return;
/*
Try to create dead letter in current directory
or in home directory
*/
umask(umsave);
setgid(getgid());
if ((aret = legal(dotdead)) && stat(dotdead, &st) == 0)
malf = fopen(dotdead, "a");
if ((malf == NULL) || (aret == 0)) {
/*
try to create in $HOME
*/
if((hmdead = malloc(strlen(home) + strlen(dead) + 1)) == NULL) {
fprintf(stderr, "%s: Can't malloc\n",program);
Dout(pn, 0, "Cannot malloc.\n");
goto out;
}
cat(hmdead, home, dead);
if ((aret=legal(hmdead)) && !(stat(hmdead, &st) < 0 &&
errno == EOVERFLOW))
malf = fopen(hmdead, "a");
if ((malf == NULL) || (aret == 0)) {
fprintf(stderr,
"%s: Cannot create %s\n",
program,dotdead);
Dout(pn, 0, "Cannot create %s\n", dotdead);
out:
fclose(tmpf);
error = E_FILE;
Dout(pn, 0, "error set to %d\n", error);
umask(7);
setegid(egid);
return;
} else {
chmod(hmdead, DEADPERM);
fprintf(stderr,"%s: Mail saved in %s\n",program,hmdead);
}
} else {
chmod(dotdead, DEADPERM);
fprintf(stderr,"%s: Mail saved in %s\n",program,dotdead);
}
/*
Copy letter into dead letter box
*/
umask(7);
aret = fseek(tmpf,0L,0);
if (aret)
errmsg(E_DEAD,"");
if (!copystream(tmpf, malf))
errmsg(E_DEAD,"");
fclose(malf);
setegid(egid);
}
void EcoreEvasWindow::focusOutEvent()
{
Dout( dc::notice, "EcoreEvasWindow::focusOutEvent()" );
}
// TODO: Possible without #ifdef stuff?
EvasWindowFB::EvasWindowFB( const Eflxx::Size &size, const char* display, int rotation ) :
EvasWindow()
{
Dout( dc::notice, "EvasWindow::EvasWindowFB" );
Application::getInstance()->setMainWindow( this );
/*if ( ::getenv( "EFL_DISPLAY" ) ) display = ::getenv( "EFL_DISPLAY" );
if ( ::getenv( "EFL_WIDTH" ) ) size.width (atoi( ::getenv( "EFL_WIDTH" ) ));
if ( ::getenv( "EFL_HEIGHT" ) ) size.height (atoi( ::getenv( "EFL_HEIGHT" ) ));
if ( ::getenv( "EFL_ROTATION" ) ) rotation = atoi( ::getenv( "EFL_ROTATION" ) );*/
if ( display /*&& ::strstr( display, "/dev/fb" )*/ )
{
#ifdef ENABLE_EFLPP_FB
int fb_dev_fd = ::open( display, O_RDONLY );
if ( fb_dev_fd < 0 )
{
fprintf(stderr,"Can't open display '%s': %s\n", display, strerror(errno));
exit( 1 );
}
struct fb_var_screeninfo fb_vinfo;
struct fb_fix_screeninfo fb_finfo;
// read VScreen info from fb
if ( ioctl( fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo ) )
{
fprintf(stderr,"Can't get VSCREENINFO: %s\n", strerror(errno));
exit(1);
}
// readFScreen info from fb
if ( ioctl( fb_dev_fd, FBIOGET_FSCREENINFO, &fb_finfo ) )
{
fprintf(stderr,"Can't get FSCREENINFO: %s\n", strerror(errno));
exit(1);
}
Dout( dc::notice, "- using display '" << display << "' [" << fb_finfo.id << "] - " << fb_vinfo.xres << "x" << fb_vinfo.yres << "@" << rotation );
width = ( rotation % 180 ) ? fb_vinfo.yres : fb_vinfo.xres;
height = ( rotation % 180 ) ? fb_vinfo.xres : fb_vinfo.yres;
Dout( dc::notice, "- using size (after rotating) " << size.width () << "x" << size.height () );
#ifdef ECORE_FB_NO_ROTATION_BUG
//FIXME EFL BUG: initial rotation is not taken into account for evas calculation
_ee = ecore_evas_fb_new( const_cast<char*>( display ), rotation, 50, 50 );
#else
_ee = ecore_evas_fb_new( const_cast<char*>( display ), 0, 50, 50 ); // start with rotation 0 to workaround bug
#endif
ecore_evas_fullscreen_set( _ee, 1 ); // fullscreen is default to get auto resize on changing rotation
ecore_evas_rotation_set( _ee, rotation ); // force resize
#else
printf("FB engine not enabled\n");
#endif
}
ecore_evas_title_set( _ee, Application::getInstance()->getName().c_str() );
ecore_evas_borderless_set( _ee, 0 );
_canvas = Evasxx::Canvas::wrap (ecore_evas_get( _ee ));
/* Set up magic object back link */
ecore_evas_data_set( _ee, "obj_c++", this );
/* Set up default callbacks */
setEventEnabled( Resize, true );
setEventEnabled( DeleteRequest, true );
}
void Object::raise()
{
Dout( dc::notice, *this << " raise" );
evas_object_raise( o );
}
