//////////////////////////////////////////////////////////////////////////
// Subtitles
//////////////////////////////////////////////////////////////////////////
void SoundQueue::updateSubtitles() {
Common::StackLock locker(_mutex);
uint32 index = 0;
SubtitleEntry *subtitle = NULL;
for (Common::List<SubtitleEntry *>::iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) {
uint32 current_index = 0;
SoundEntry *soundEntry = (*i)->getSoundEntry();
SoundStatus status = (SoundStatus)soundEntry->getStatus().status;
if (!(status & kSoundStatus_40)
|| status & kSoundStatus_180
|| soundEntry->getTime() == 0
|| (status & kSoundStatusFilter) < 6
|| ((getFlags()->nis & 0x8000) && soundEntry->getPriority() < 90)) {
current_index = 0;
} else {
current_index = soundEntry->getPriority() + (status & kSoundStatusFilter);
if (_currentSubtitle == (*i))
current_index += 4;
}
if (index < current_index) {
index = current_index;
subtitle = (*i);
}
}
if (_currentSubtitle == subtitle) {
if (subtitle)
subtitle->setupAndDraw();
return;
}
if (!subtitle)
return;
if (_subtitlesFlag & 1)
subtitle->drawOnScreen();
subtitle->loadData();
subtitle->setupAndDraw();
}
void PicButtonWidget::drawWidget() {
g_gui.theme()->drawButton(Common::Rect(_x, _y, _x+_w, _y+_h), "", _state, getFlags());
if (_gfx.getPixels()) {
// Check whether the set up surface needs to be converted to the GUI
// color format.
const Graphics::PixelFormat &requiredFormat = g_gui.theme()->getPixelFormat();
if (_gfx.format != requiredFormat) {
_gfx.convertToInPlace(requiredFormat);
}
const int x = _x + (_w - _gfx.w) / 2;
const int y = _y + (_h - _gfx.h) / 2;
g_gui.theme()->drawSurface(Common::Rect(x, y, x + _gfx.w, y + _gfx.h), _gfx, _state, _alpha, _transparency);
}
}
int
process_switchB(ea_t curr, ea_t start, ea_t func_end)
{
ea_t diff = start - curr,
min = func_end,
ptr;
unsigned long i;
if ( diff && diff < 4 )
{
do_unknown_range(curr, diff, true);
}
#ifdef PIC_DEBUG
RP_TRACE2("start %X, to %X\n", start, func_end);
#endif
ptr = get_next_code(start);
if ( NULL == ptr )
do_unknown(start,false);
else
{
if ( isTail(getFlags(start)) )
{
do_unknown(prev_not_tail(start),false);
}
else
do_unknown_range(start, ptr-start, true);
}
for ( i = 0; start+i < min; i += 4 )
{
ptr = got_addr - get_long(start + i);
#ifdef PIC_DEBUG
RP_TRACE3("min is %X, ptr %X, i %d\n", min, ptr, i);
#endif
if ( ptr < func_end )
{
if ( ptr < min )
min = ptr;
#ifdef PIC_DEBUG
RP_TRACE2("one_switch_entry %X, ptr %X\n", start+i, ptr );
#endif
one_switch_entry(start+i, ptr);
} else
break; /* end ? */
}
return (i>>2);
}
/**
* ifaceGetFlags
*
* @ifname : name of the interface
* @flags : pointer to short holding the flags on success
*
* Get the flags of the interface. Returns 0 on success, -errno on failure.
*/
int
ifaceGetFlags(const char *ifname, short *flags) {
struct ifreq ifr;
int rc;
int fd = socket(PF_PACKET, SOCK_DGRAM, 0);
if (fd < 0)
return -errno;
rc = getFlags(fd, ifname, &ifr);
*flags = ifr.ifr_flags;
VIR_FORCE_CLOSE(fd);
return rc;
}
bool TimeBase::isRunning() {
if (_paused && _pausedRate != 0)
return true;
Common::Rational rate = getRate();
if (rate == 0)
return false;
if (getFlags() & kLoopTimeBase)
return true;
if (rate > 0)
return getTime() != getStop();
return getTime() != getStart();
}
//////////////////////////////////////////////////////////////////////////
// Overlays & elements
//////////////////////////////////////////////////////////////////////////
void Menu::checkHotspots() {
if (!_isShowingMenu)
return;
if (!getFlags()->shouldRedraw)
return;
if (_isShowingCredits)
return;
SceneHotspot *hotspot = NULL;
getScenes()->get(getState()->scene)->checkHotSpot(getCoords(), &hotspot);
if (hotspot)
handleEvent((StartMenuAction)hotspot->action, _mouseFlags);
else
hideOverlays();
}
v8::Handle<v8::Value> V8DirectoryEntrySync::getDirectoryCallback(const v8::Arguments& args)
{
INC_STATS("DOM.DirectoryEntrySync.getDirectory");
DirectoryEntrySync* imp = V8DirectoryEntrySync::toNative(args.Holder());
ExceptionCode ec = 0;
STRING_TO_V8PARAMETER_EXCEPTION_BLOCK(V8Parameter<>, path, args[0]);
RefPtr<WebKitFlags> flags = getFlags(args[1], ec);
if (UNLIKELY(ec)) {
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
RefPtr<DirectoryEntrySync> result = imp->getDirectory(path, flags, ec);
if (UNLIKELY(ec)) {
V8Proxy::setDOMException(ec);
return v8::Handle<v8::Value>();
}
return toV8(result.release());
}
void OperatorWidget::getContent(OpaOperatorParams * params)
{
params->flags = getFlags();
params->volume = ui->volumeSlide->value();
params->coarse = ui->coarseDial->value();
params->fine = ui->fineDial->value();
params->LFOSpeed = ui->LFOSpeedDial->value();
params->LFOAmount = ui->LFOAmountDial->value();
params->feedback = ui->feedbackDial->value();
params->envAttack = ui->attackDial->value();
params->envDecay = ui->decayDial->value();
params->envSusLevel = ui->sustainDial->value();
params->envIniLevel = ui->initDial->value();
params->envRelease = ui->releaseDial->value();
}
//////////////////////////////////////////////////////////////////////////
// Subtitles
//////////////////////////////////////////////////////////////////////////
void SoundQueue::updateSubtitles() {
uint32 index = 0;
SubtitleEntry *subtitle = NULL;
for (Common::List<SubtitleEntry *>::iterator i = _subtitles.begin(); i != _subtitles.end(); ++i) {
uint32 current_index = 0;
SoundEntry *soundEntry = (*i)->getSoundEntry();
SoundFlag status = (SoundFlag)soundEntry->getStatus();
if (!(status & kSoundFlagPlaying)
|| status & kSoundFlagMute
|| soundEntry->getTime() == 0
|| (status & kSoundVolumeMask) < kVolume6
|| ((getFlags()->nis & 0x8000) && soundEntry->getPriority() < 90)) {
current_index = 0;
} else {
current_index = soundEntry->getPriority() + (status & kSoundVolumeMask);
if (_currentSubtitle == (*i))
current_index += 4;
}
if (index < current_index) {
index = current_index;
subtitle = (*i);
}
}
if (_currentSubtitle == subtitle) {
if (subtitle)
subtitle->setupAndDraw();
return;
}
if (!subtitle)
return;
if (_subtitlesFlag & 1)
subtitle->drawOnScreen();
subtitle->loadData();
subtitle->setupAndDraw();
}
void View::AttachedToWindow()
{
lock();
// First, add to the Window's pulse list if this view needs it.
if ( (getFlags() & PULSE_NEEDED) != 0 )
if ( GetWindow() != NULL ) GetWindow()->AddPulseChild( this );
// ...
for ( int i = 0; i < CountChildren(); i++ )
{
View *view = ChildAt(i);
view->_window = GetWindow();
view->AttachedToWindow();
}
unlock();
}
status_t BnMemoryHeap::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case HEAP_ID: {
CHECK_INTERFACE(IMemoryHeap, data, reply);
reply->writeFileDescriptor(getHeapID());
reply->writeInt32(getSize());
reply->writeInt32(getFlags());
#ifndef BINDER_COMPAT
reply->writeInt32(getOffset());
#endif
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
std::string Buddy::getSafeName() {
if (m_jid.isValid()) {
return m_jid.getNode();
}
std::string name = getName();
// Transport::instance()->protocol()->prepareUsername(name, purple_buddy_get_account(m_buddy));
if (getFlags() & BUDDY_JID_ESCAPING) {
name = Swift::JID::getEscapedNode(name);
}
else {
if (name.find_last_of("@") != std::string::npos) {
name.replace(name.find_last_of("@"), 1, "%"); // OK
}
}
// if (name.empty()) {
// Log("SpectrumBuddy::getSafeName", "Name is EMPTY! Previous was " << getName() << ".");
// }
return name;
}
bool STValidation::isValid (uint256 const& signingHash) const
{
try
{
if (publicKeyType(getSignerPublic()) != KeyType::secp256k1)
return false;
return verifyDigest (getSignerPublic(),
signingHash,
makeSlice(getFieldVL (sfSignature)),
getFlags () & vfFullyCanonicalSig);
}
catch (std::exception const&)
{
JLOG (debugLog().error())
<< "Exception validating validation";
return false;
}
}
void LiveRange::addSegment(InstNumberT Start, InstNumberT End, CfgNode *Node) {
if (getFlags().getSplitGlobalVars()) {
// Disable merging to make sure a live range 'segment' has a single node.
// Might be possible to enable when the target segment has the same node.
assert(NodeMap.find(Start) == NodeMap.end());
NodeMap[Start] = Node;
} else {
if (!Range.empty()) {
// Check for merge opportunity.
InstNumberT CurrentEnd = Range.back().second;
assert(Start >= CurrentEnd);
if (Start == CurrentEnd) {
Range.back().second = End;
return;
}
}
}
Range.push_back(RangeElementType(Start, End));
}
void
process_switchA(ea_t curr, ea_t start, unsigned int N)
{
ea_t diff = start - curr;
unsigned long i;
if ( diff && diff < 4 )
{
do_unknown_range(curr, diff, true);
}
if ( isTail(getFlags(start)) )
do_unknown(prev_not_tail(start),false);
else
do_unknown_range(start, N << 2, true);
for ( i = 0; i <= N; i++ )
{
diff = start + (i<<2);
one_switch_entry(diff, got_addr - get_long(diff));
}
}
std::vector<glm::vec4> Mesh::buildVertices() const {
int flags = getFlags();
size_t attributeCount = getAttributeCount();
size_t vertexCount = positions.size();
std::vector<glm::vec4> vertices;
vertices.reserve(vertexCount * attributeCount);
for (size_t i = 0; i < vertexCount; ++i) {
vertices.push_back(positions[i]);
if (flags & gl::Geometry::Flag::HAS_NORMAL) {
vertices.push_back(normals[i]);
}
if (flags & gl::Geometry::Flag::HAS_COLOR) {
vertices.push_back(glm::vec4(colors[i], 1));
}
if (flags & gl::Geometry::Flag::HAS_TEXTURE) {
vertices.push_back(glm::vec4(texCoords[i], 1, 1));
}
}
return vertices;
}
static int idaapi hook(void *user_data, int event_id, va_list va) {
static ea_t old_addr = 0;
ea_t addr;
if (event_id == view_curpos) {
addr = get_screen_ea();
if (old_addr != addr) {
if (isCode(getFlags(addr))) {
// don't update the address if it's already the qira address
if (addr != qira_address) {
set_qira_address(addr);
update_address("iaddr", addr);
}
} else {
update_address("daddr", addr);
}
}
old_addr = addr;
}
return 0;
}
ea_t find_instruction_backward(ea_t start, uint16 itype)
{
func_t *f = get_func(start);
if(f)
{
ea_t addr = prev_head(start, f->startEA);
while (addr != BADADDR)
{
flags_t flags = getFlags(addr);
if (isHead(flags) && isCode(flags))
{
ua_ana0(addr);
if(cmd.itype == itype)return addr;
}
addr = prev_head(addr, f->startEA);
}
}
return BADADDR;
}
void PicButtonWidget::drawWidget() {
g_gui.theme()->drawButton(Common::Rect(_x, _y, _x+_w, _y+_h), "", _state, getFlags());
if (_gfx->pixels) {
// Check whether the set up surface needs to be converted to the GUI
// color format.
const Graphics::PixelFormat &requiredFormat = g_gui.theme()->getPixelFormat();
if (_gfx->format != requiredFormat) {
Graphics::Surface *converted = _gfx->convertTo(requiredFormat);
_gfx->free();
delete _gfx;
_gfx = converted;
}
const int x = _x + (_w - _gfx->w) / 2;
const int y = _y + (_h - _gfx->h) / 2;
g_gui.theme()->drawSurface(Common::Rect(x, y, x + _gfx->w, y + _gfx->h), *_gfx, _state, _alpha, _transparency);
}
}
int main(int argc, char *argv[]) {
if(argc < 2) {
fprintf(stderr, "Usage: %s [-a <number of attemps>|-e <onerror> '<args>'|-r <onrestart> '<args>'] <program> <args>\n", argv[0]);
exit(1);
}
int i;
command_options *commands = malloc(sizeof(*commands));
getFlags(argc, argv, commands);
for(i = 0; i < commands->max_attempts; i++) {
start(commands);
on_restart(commands);
}
return 0;
}
//////////////////////////////////////////////////////////////////////////
// Setup
void Menu::setup() {
// Clear drawing queue
getScenes()->removeAndRedraw(&_frames[kOverlayAcorn], false);
SAFE_DELETE(_seqAcorn);
// Load Menu scene
// + 1 = normal menu with open egg / clock
// + 2 = shield menu, when no savegame exists (no game has been started)
_isGameStarted = _lowerTime >= kTimeStartGame;
getScenes()->loadScene((SceneIndex)(_isGameStarted ? _gameId * 5 + 1 : _gameId * 5 + 2));
getFlags()->shouldRedraw = true;
getLogic()->updateCursor();
//////////////////////////////////////////////////////////////////////////
// Load Acorn sequence
_seqAcorn = loadSequence(getAcornSequenceName(_isGameStarted ? getNextGameId() : kGameBlue));
//////////////////////////////////////////////////////////////////////////
// Check if we loaded sequences before
if (_seqTooltips && _seqTooltips->count() > 0)
return;
// Load all static data
_seqTooltips = loadSequence("helpnewr.seq");
_seqEggButtons = loadSequence("buttns.seq");
_seqButtons = loadSequence("quit.seq");
_seqCity1 = loadSequence("jlinetl.seq");
_seqCity2 = loadSequence("jlinecen.seq");
_seqCity3 = loadSequence("jlinebr.seq");
_seqCredits = loadSequence("credits.seq");
_frames[kOverlayTooltip] = new SequenceFrame(_seqTooltips);
_frames[kOverlayEggButtons] = new SequenceFrame(_seqEggButtons);
_frames[kOverlayButtons] = new SequenceFrame(_seqButtons);
_frames[kOverlayAcorn] = new SequenceFrame(_seqAcorn);
_frames[kOverlayCity1] = new SequenceFrame(_seqCity1);
_frames[kOverlayCity2] = new SequenceFrame(_seqCity2);
_frames[kOverlayCity3] = new SequenceFrame(_seqCity3);
_frames[kOverlayCredits] = new SequenceFrame(_seqCredits);
}
void FCDeAllocate( void ) {
//==============================
call_handle handle;
sym_id arr;
uint num;
handle = InitCall( RT_DEALLOCATE );
for( num = 0; (arr = GetPtr()) != NULL; ++num ) {
CGAddParm( handle, CGFEName( arr, TY_POINTER ), TY_POINTER );
CGAddParm( handle, getFlags( arr ), FLAG_PARM_TYPE );
}
CGAddParm( handle, CGInteger( num, TY_UNSIGNED ), TY_UNSIGNED );
if( GetU16() & ALLOC_STAT ) {
FCodeSequence();
CGAddParm( handle, XPop(), TY_POINTER );
} else {
CGAddParm( handle, CGInteger( 0, TY_POINTER ), TY_POINTER );
}
CGDone( CGCall( handle ) );
}
string TcpPacket::toString ()
{
ostringstream out;
Packet::PAYLOAD_BUFFER opts = getOptions ();
out << "TCP packet" << std::endl
<< "\tsource port: \t" << getSourceport() << std::endl
<< "\tdest port: \t" << getDestport() << std::endl
<< "\tsequencenum: \t" << getSequencenum() << std::endl
<< "\tacknum: \t" << getAcknum() << std::endl
<< "\theaderlen: \t" << getHeaderlength() << " bytes" << std::endl
<< "\tflags: \t\t0x" << std::hex << std::setw(4) << std::setfill ('0') << getFlags () << std::endl << std::dec
<< "\twindowsize: \t" << getWindowsize() << std::endl
<< "\tchecksum: \t0x" << std::hex << std::setw(4) << std::setfill ('0') << getChecksum () << std::endl << std::dec
<< "\turgent pnt: \t" << getUrgentpointer() << std::endl
<< "\toptions len: \t" << opts.size << std::endl
<< "\toptions: \t" << opts.toString ();
opts.destroy ();
return out.str ();
}
void initFlags() {
SetCommonFlagsDefaults();
{
CommonFlags cf;
cf.CopyFrom(*common_flags());
cf.exitcode = 1;
OverrideCommonFlags(cf);
}
Flags *f = getFlags();
f->setDefaults();
FlagParser scudo_parser;
RegisterScudoFlags(&scudo_parser, f);
RegisterCommonFlags(&scudo_parser);
scudo_parser.ParseString(GetEnv("SCUDO_OPTIONS"));
InitializeCommonFlags();
// Sanity checks and default settings for the Quarantine parameters.
if (f->QuarantineSizeMb < 0) {
const int DefaultQuarantineSizeMb = 64;
f->QuarantineSizeMb = DefaultQuarantineSizeMb;
}
// We enforce an upper limit for the quarantine size of 4Gb.
if (f->QuarantineSizeMb > (4 * 1024)) {
dieWithMessage("ERROR: the quarantine size is too large\n");
}
if (f->ThreadLocalQuarantineSizeKb < 0) {
const int DefaultThreadLocalQuarantineSizeKb = 1024;
f->ThreadLocalQuarantineSizeKb = DefaultThreadLocalQuarantineSizeKb;
}
// And an upper limit of 128Mb for the thread quarantine cache.
if (f->ThreadLocalQuarantineSizeKb > (128 * 1024)) {
dieWithMessage("ERROR: the per thread quarantine cache size is too "
"large\n");
}
}
/*
*******************************************************************
* Function:
*
* Description:
*
* Parameters:
*
* Returns:
*
*******************************************************************
*/
void xDistributedPoint3F::pack(xNStream *bstream)
{
if (this->getPropertyInfo()->mPredictionType == E_PTYPE_PREDICTED)
{
TNL::Point3f p;
p.x = mCurrentValue.x;
p.y = mCurrentValue.y;
p.z = mCurrentValue.z;
bstream->writePointCompressed(p,1.0f);
TNL::Point3f v;
v.x = mDifference.x;
v.y = mDifference.y;
v.z = mDifference.z;
bstream->writePointCompressed(v,1.0f);
}
if (this->getPropertyInfo()->mPredictionType == E_PTYPE_RELIABLE)
{
TNL::Point3f p;
p.x = mCurrentValue.x;
p.y = mCurrentValue.y;
p.z = mCurrentValue.z;
bstream->writePointCompressed(p,1.0f);
}
int flags = getFlags();
flags &= (~E_DP_NEEDS_SEND);
setFlags(flags);
}
void processRangeAccessWorkingSet(uptr PC, uptr Addr, SIZE_T Size,
bool IsWrite) {
if (Size == 0)
return;
SIZE_T I = 0;
uptr LineSize = getFlags()->cache_line_size;
// As Addr+Size could overflow at the top of a 32-bit address space,
// we avoid the simpler formula that rounds the start and end.
SIZE_T NumLines = Size / LineSize +
// Add any extra at the start or end adding on an extra line:
(LineSize - 1 + Addr % LineSize + Size % LineSize) / LineSize;
byte *Shadow = (byte *)appToShadow(Addr);
// Write shadow bytes until we're word-aligned.
while (I < NumLines && (uptr)Shadow % 4 != 0) {
if ((*Shadow & ShadowAccessedVal) != ShadowAccessedVal)
*Shadow |= ShadowAccessedVal;
++Shadow;
++I;
}
// Write whole shadow words at a time.
// Using a word-stride loop improves the runtime of a microbenchmark of
// memset calls by 10%.
u32 WordValue = ShadowAccessedVal | ShadowAccessedVal << 8 |
ShadowAccessedVal << 16 | ShadowAccessedVal << 24;
while (I + 4 <= NumLines) {
if ((*(u32*)Shadow & WordValue) != WordValue)
*(u32*)Shadow |= WordValue;
Shadow += 4;
I += 4;
}
// Write any trailing shadow bytes.
while (I < NumLines) {
if ((*Shadow & ShadowAccessedVal) != ShadowAccessedVal)
*Shadow |= ShadowAccessedVal;
++Shadow;
++I;
}
}
std::uint64_t
SetRegularKey::calculateBaseFee (
PreclaimContext const& ctx)
{
auto const id = ctx.tx.getAccountID(sfAccount);
auto const spk = ctx.tx.getSigningPubKey();
if (publicKeyType (makeSlice (spk)))
{
if (calcAccountID(PublicKey (makeSlice(spk))) == id)
{
auto const sle = ctx.view.read(keylet::account(id));
if (sle && (! (sle->getFlags () & lsfPasswordSpent)))
{
// flag is armed and they signed with the right account
return 0;
}
}
}
return Transactor::calculateBaseFee (ctx);
}
//--------------------------------------------------------------------------
// find all dwords equal to 'ea' and remember their translations
// search in the current module
static bool calc_thunk_target(uint32 ea32, uint32 imp32)
{
bool matched = false;
for ( ea_t pos = curmod.startEA;
pos <= curmod.endEA
&& (pos = bin_search(pos, curmod.endEA, (uchar *)&ea32, NULL,
4, BIN_SEARCH_FORWARD,
BIN_SEARCH_NOBREAK|BIN_SEARCH_CASE)) != BADADDR;
pos += sizeof(DWORD) )
{
if ( pos & 3 )
continue;
flags_t F = getFlags(pos);
if( isTail(F) )
continue;
matched = true;
thunks[pos] = imp32;
}
return matched;
}
api_return FilelistApi::handleQueueList(ApiRequest& aRequest, QueueItem::Flags aFlags) {
const auto& reqJson = aRequest.getRequestBody();
auto user = Deserializer::deserializeHintedUser(reqJson);
auto directory = Util::toNmdcFile(JsonUtil::getOptionalFieldDefault<string>("directory", reqJson, "/", false));
auto flags = aFlags;
flags.setFlag(QueueItem::FLAG_PARTIAL_LIST);
QueueItemPtr q = nullptr;
try {
q = QueueManager::getInstance()->addList(user, flags.getFlags(), directory);
} catch (const Exception& e) {
aRequest.setResponseErrorStr(e.getError());
return websocketpp::http::status_code::bad_request;
}
aRequest.setResponseBody({
{ "id", user.user->getCID().toBase32() }
});
return websocketpp::http::status_code::ok;
}
// if doWork is complete or aborted, call endWork() and return true
bool LLWorkerClass::checkWork(bool aborting)
{
LLMutexLock lock(&mMutex);
bool complete = false, abort = false;
if (mRequestHandle != LLWorkerThread::nullHandle())
{
LLWorkerThread::WorkRequest* workreq = (LLWorkerThread::WorkRequest*)mWorkerThread->getRequest(mRequestHandle);
llassert_always(workreq);
LLQueuedThread::status_t status = workreq->getStatus();
if (status == LLWorkerThread::STATUS_ABORTED)
{
complete = true;
abort = true;
}
else if (status == LLWorkerThread::STATUS_COMPLETE)
{
complete = true;
}
else
{
llassert_always(!aborting || (workreq->getFlags() & LLQueuedThread::FLAG_ABORT));
}
if (complete)
{
llassert_always(!(getFlags(WCF_WORKING)));
endWork(workreq->getParam(), abort);
mWorkerThread->completeRequest(mRequestHandle);
mRequestHandle = LLWorkerThread::nullHandle();
clearFlags(WCF_HAVE_WORK);
}
}
else
{
complete = true;
}
return complete;
}
