//-----------------------------------------------------------------------------
// Purpose: Converts the variant to a new type. This function defines which I/O
// types can be automatically converted between. Connections that require
// an unsupported conversion will cause an error message at runtime.
// Input : newType - the type to convert to
// Output : Returns true on success, false if the conversion is not legal
//-----------------------------------------------------------------------------
bool variant_t::Convert( fieldtype_t newType )
{
if ( newType == fieldType )
{
return true;
}
//
// Converting to a null value is easy.
//
if ( newType == FIELD_VOID )
{
Set( FIELD_VOID, NULL );
return true;
}
//
// FIELD_INPUT accepts the variant type directly.
//
if ( newType == FIELD_INPUT )
{
return true;
}
switch ( fieldType )
{
case FIELD_INTEGER:
{
switch ( newType )
{
case FIELD_FLOAT:
{
SetFloat( (float) iVal );
return true;
}
case FIELD_BOOLEAN:
{
SetBool( iVal != 0 );
return true;
}
}
break;
}
case FIELD_FLOAT:
{
switch ( newType )
{
case FIELD_INTEGER:
{
SetInt( (int) flVal );
return true;
}
case FIELD_BOOLEAN:
{
SetBool( flVal != 0 );
return true;
}
}
break;
}
//
// Everyone must convert from FIELD_STRING if possible, since
// parameter overrides are always passed as strings.
//
case FIELD_STRING:
{
switch ( newType )
{
case FIELD_INTEGER:
{
if (iszVal != NULL_STRING)
{
SetInt(atoi(STRING(iszVal)));
}
else
{
SetInt(0);
}
return true;
}
case FIELD_FLOAT:
{
if (iszVal != NULL_STRING)
{
SetFloat(atof(STRING(iszVal)));
}
else
{
SetFloat(0);
}
return true;
}
case FIELD_BOOLEAN:
{
if (iszVal != NULL_STRING)
{
SetBool( atoi(STRING(iszVal)) != 0 );
}
else
{
SetBool(false);
}
return true;
}
case FIELD_VECTOR:
{
Vector tmpVec = vec3_origin;
if (sscanf(STRING(iszVal), "[%f %f %f]", &tmpVec[0], &tmpVec[1], &tmpVec[2]) == 0)
{
// Try sucking out 3 floats with no []s
sscanf(STRING(iszVal), "%f %f %f", &tmpVec[0], &tmpVec[1], &tmpVec[2]);
}
SetVector3D( tmpVec );
return true;
}
case FIELD_COLOR32:
{
int nRed = 0;
int nGreen = 0;
int nBlue = 0;
int nAlpha = 255;
sscanf(STRING(iszVal), "%d %d %d %d", &nRed, &nGreen, &nBlue, &nAlpha);
SetColor32( nRed, nGreen, nBlue, nAlpha );
return true;
}
case FIELD_EHANDLE:
{
// convert the string to an entity by locating it by classname
CBaseEntity *ent = NULL;
if ( iszVal != NULL_STRING )
{
// FIXME: do we need to pass an activator in here?
ent = gEntList.FindEntityByName( NULL, iszVal );
}
SetEntity( ent );
return true;
}
}
break;
}
case FIELD_EHANDLE:
{
switch ( newType )
{
case FIELD_STRING:
{
// take the entities targetname as the string
string_t iszStr = NULL_STRING;
if ( eVal != NULL )
{
SetString( eVal->GetEntityName() );
}
return true;
}
}
break;
}
}
// invalid conversion
return false;
}
void CWizSettings::SetProxyHost(const QString& val)
{
SetString("Sync", "ProxyHost", val);
}
void
PageSetupWindow::_UpdateSetupMessage()
{
SetInt32(fSetupMsg, "orientation", fCurrentOrientation);
BMenuItem *item = fPDFCompatibilityMenu->Menu()->FindMarked();
if (item)
SetString(fSetupMsg, "pdf_compatibility", item->Label());
SetInt32(fSetupMsg, "pdf_compression", fPDFCompressionSlider->Value());
item = fPageSizeMenu->Menu()->FindMarked();
if (item) {
float w, h;
BMessage *msg = item->Message();
msg->FindFloat("width", &w);
msg->FindFloat("height", &h);
BRect r(0, 0, w, h);
if (fCurrentOrientation == PrinterDriver::LANDSCAPE_ORIENTATION)
r.Set(0, 0, h, w);
// Save the printable_rect
BRect margin = fMarginView->Margin();
if (fCurrentOrientation == PrinterDriver::PORTRAIT_ORIENTATION) {
margin.right = w - margin.right;
margin.bottom = h - margin.bottom;
} else {
margin.right = h - margin.right;
margin.bottom = w - margin.bottom;
}
SetRect(fSetupMsg, "paper_rect", r);
SetRect(fSetupMsg, "printable_rect", margin);
SetInt32(fSetupMsg, "units", fMarginView->Unit());
SetString(fSetupMsg, "pdf_paper_size", item->Label());
}
BMessage fonts;
if (fFonts->Archive(&fonts) == B_OK) {
fSetupMsg->RemoveName("fonts");
fSetupMsg->AddMessage("fonts", &fonts);
}
// advanced settings
BString value;
if (fAdvancedSettings.FindString("pdflib_license_key", &value) == B_OK)
SetString(fSetupMsg, "pdflib_license_key", value);
bool webLinks;
if (fAdvancedSettings.FindBool("create_web_links", &webLinks) == B_OK)
SetBool(fSetupMsg, "create_web_links", webLinks);
float linkBorder;
if (fAdvancedSettings.FindFloat("link_border_width", &linkBorder) == B_OK)
SetFloat(fSetupMsg, "link_border_width", linkBorder);
bool createBookmarks;
if (fAdvancedSettings.FindBool("create_bookmarks", &createBookmarks) == B_OK)
SetBool(fSetupMsg, "create_bookmarks", createBookmarks);
if (fAdvancedSettings.FindString("bookmark_definition_file", &value) == B_OK)
SetString(fSetupMsg, "bookmark_definition_file", value);
bool createXrefs;
if (fAdvancedSettings.FindBool("create_xrefs", &createXrefs) == B_OK)
SetBool(fSetupMsg, "create_xrefs", createXrefs);
if (fAdvancedSettings.FindString("xrefs_file", &value) == B_OK)
SetString(fSetupMsg, "xrefs_file", value.String());
int32 closeOption;
if (fAdvancedSettings.FindInt32("close_option", &closeOption) == B_OK)
SetInt32(fSetupMsg, "close_option", closeOption);
}
void CWizSettings::SetProxyUserName(const QString& val)
{
SetString("Sync", "ProxyUserName", val);
}
BOOL CWizSettings::SetInt(const QString& strSection, const QString& strKey, int val)
{
return SetString(strSection, strKey, WizIntToStr(val));
}
Identifier::Identifier(const char* szStr)
: OTData()
{
OT_ASSERT(nullptr != szStr);
SetString(szStr);
}
Identifier::Identifier(const String& theStr)
: OTData()
{
SetString(theStr);
}
DisplayStringFilter::DisplayStringFilter(WEBC_CHAR *pStr)
{
SetString(pStr);
miLength = -1;
}
void XMLUtils::SetStringArray(TiXmlNode* pRootNode, const char *strTag, const std::vector<std::string>& arrayValue)
{
for (unsigned int i = 0; i < arrayValue.size(); i++)
SetString(pRootNode, strTag, arrayValue.at(i));
}
void FString::Copy(const FString &s)
// Function used to copy FString objects.
{
SetString(s.sptr, s.length());
}
StringCopyBuilder::StringCopyBuilder(const char *str)
{
SetString(str);
}
void BIND(autogl_save_view_image_to_ppm_file)
(const char *fileName, int length)
{
SetString (fileName, length);
AutoGL_SaveViewImageToPPMFile (String);
}
void BIND(autogl_add_group)
(const char *name, int length)
{
SetString (name, length);
AutoGL_AddGroup (String);
}
void BIND(autogl_set_image_file_name)
(const char *fileName, int length)
{
SetString (fileName, length);
AutoGL_SetImageFileName (String);
}
BOOL CMSStringParam::SetValue( const char* pszValue )
{
SetString( pszValue );
return TRUE;
}
void XMLUtils::SetLong(TiXmlNode* pRootNode, const char *strTag, long value)
{
CStdString strValue;
strValue.Format("%ld", value);
SetString(pRootNode, strTag, strValue);
}
void Identifier::SetString(const char* szString)
{
OT_ASSERT(nullptr != szString);
const String theStr(szString);
SetString(theStr);
}
void XMLUtils::SetFloat(TiXmlNode* pRootNode, const char *strTag, float value)
{
CStdString strValue;
strValue.Format("%f", value);
SetString(pRootNode, strTag, strValue);
}
Identifier::Identifier(const std::string& theStr)
: OTData()
{
OT_ASSERT(!theStr.empty());
SetString(theStr.c_str());
}
void XMLUtils::SetBoolean(TiXmlNode* pRootNode, const char *strTag, bool value)
{
SetString(pRootNode, strTag, value ? "true" : "false");
}
bool CommandLine::ProcessKey(const Manager::Key& Key)
{
auto LocalKey = Key;
if ((LocalKey()==KEY_CTRLEND || LocalKey()==KEY_RCTRLEND || LocalKey()==KEY_CTRLNUMPAD1 || LocalKey()==KEY_RCTRLNUMPAD1) && (CmdStr.GetCurPos()==CmdStr.GetLength()))
{
if (LastCmdPartLength==-1)
strLastCmdStr = CmdStr.GetString();
auto strStr = strLastCmdStr;
const auto CurCmdPartLength = strStr.size();
Global->CtrlObject->CmdHistory->GetSimilar(strStr,LastCmdPartLength);
if (LastCmdPartLength==-1)
{
strLastCmdStr = CmdStr.GetString();
LastCmdPartLength = static_cast<int>(CurCmdPartLength);
}
{
SCOPED_ACTION(SetAutocomplete)(&CmdStr);
CmdStr.SetString(strStr);
CmdStr.Select(LastCmdPartLength,static_cast<int>(strStr.size()));
}
Show();
return true;
}
if (LocalKey() == KEY_UP || LocalKey() == KEY_NUMPAD8)
{
if (Global->CtrlObject->Cp()->LeftPanel()->IsVisible() || Global->CtrlObject->Cp()->RightPanel()->IsVisible())
return false;
LocalKey=KEY_CTRLE;
}
else if (LocalKey() == KEY_DOWN || LocalKey() == KEY_NUMPAD2)
{
if (Global->CtrlObject->Cp()->LeftPanel()->IsVisible() || Global->CtrlObject->Cp()->RightPanel()->IsVisible())
return false;
LocalKey=KEY_CTRLX;
}
// $ 25.03.2002 VVM + При погашенных панелях колесом крутим историю
if (!Global->CtrlObject->Cp()->LeftPanel()->IsVisible() && !Global->CtrlObject->Cp()->RightPanel()->IsVisible())
{
switch (LocalKey())
{
case KEY_MSWHEEL_UP: LocalKey = KEY_CTRLE; break;
case KEY_MSWHEEL_DOWN: LocalKey = KEY_CTRLX; break;
case KEY_MSWHEEL_LEFT: LocalKey = KEY_CTRLS; break;
case KEY_MSWHEEL_RIGHT: LocalKey = KEY_CTRLD; break;
}
}
switch (LocalKey())
{
case KEY_CTRLE:
case KEY_RCTRLE:
case KEY_CTRLX:
case KEY_RCTRLX:
{
if (Global->CtrlObject->CmdHistory->IsOnTop())
{
m_CurCmdStr = CmdStr.GetString();
}
SCOPED_ACTION(SetAutocomplete)(&CmdStr);
const auto strStr = LocalKey() == KEY_CTRLE || LocalKey() == KEY_RCTRLE?
Global->CtrlObject->CmdHistory->GetPrev() :
Global->CtrlObject->CmdHistory->GetNext();
SetString(Global->CtrlObject->CmdHistory->IsOnTop()? m_CurCmdStr : strStr, true);
}
return true;
case KEY_ESC:
{
// $ 24.09.2000 SVS - Если задано поведение по "Несохранению при Esc", то позицию в хистори не меняем и ставим в первое положение.
if (Global->Opt->CmdHistoryRule)
Global->CtrlObject->CmdHistory->ResetPosition();
SetString(L"", true);
return true;
}
case KEY_F2:
{
UserMenu(false);
return true;
}
case KEY_ALTF8:
case KEY_RALTF8:
{
history_record_type Type;
string strStr;
const auto SelectType = Global->CtrlObject->CmdHistory->Select(msg(lng::MHistoryTitle), L"History"sv, strStr, Type);
if (SelectType == HRT_ENTER || SelectType == HRT_SHIFTETNER || SelectType == HRT_CTRLENTER || SelectType == HRT_CTRLALTENTER)
{
std::unique_ptr<SetAutocomplete> disable;
if(SelectType != HRT_CTRLENTER)
{
disable = std::make_unique<SetAutocomplete>(&CmdStr);
}
SetString(strStr, true);
if (SelectType != HRT_CTRLENTER)
{
ProcessKey(SelectType == HRT_CTRLALTENTER? Manager::Key(KEY_CTRLALTENTER) : (SelectType == HRT_ENTER? Manager::Key(KEY_ENTER) : Manager::Key(KEY_SHIFTENTER)));
}
}
}
return true;
case KEY_ALTF10:
case KEY_RALTF10:
if (!Global->Opt->Tree.TurnOffCompletely)
{
string strStr;
const auto ActivePanel = Global->CtrlObject->Cp()->ActivePanel();
{
// TODO: здесь можно добавить проверку, что мы в корне диска и отсутствие файла Tree.Far...
FolderTree::create(strStr, MODALTREE_ACTIVE, TRUE, false);
}
Global->CtrlObject->Cp()->RedrawKeyBar();
if (!strStr.empty())
{
ActivePanel->SetCurDir(strStr,true);
ActivePanel->Show();
if (ActivePanel->GetType() == panel_type::TREE_PANEL)
ActivePanel->ProcessKey(Manager::Key(KEY_ENTER));
}
else
{
// TODO: ... а здесь проверить факт изменения/появления файла Tree.Far и мы опять же в корне (чтобы лишний раз не апдейтить панель)
ActivePanel->Update(UPDATE_KEEP_SELECTION);
ActivePanel->Redraw();
const auto AnotherPanel = Global->CtrlObject->Cp()->PassivePanel();
if (AnotherPanel->NeedUpdatePanel(ActivePanel.get()))
{
AnotherPanel->Update(UPDATE_KEEP_SELECTION);//|UPDATE_SECONDARY);
AnotherPanel->Redraw();
}
}
}
return true;
case KEY_ALTF11:
case KEY_RALTF11:
ShowViewEditHistory();
Global->CtrlObject->Cp()->Redraw();
return true;
case KEY_ALTF12:
case KEY_RALTF12:
{
history_record_type Type;
GUID Guid;
string strFile, strData, strStr;
const auto SelectType = Global->CtrlObject->FolderHistory->Select(msg(lng::MFolderHistoryTitle), L"HistoryFolders"sv, strStr, Type, &Guid, &strFile, &strData);
switch(SelectType)
{
case HRT_ENTER:
case HRT_SHIFTETNER:
case HRT_CTRLSHIFTENTER:
{
if (SelectType == HRT_SHIFTETNER)
Global->CtrlObject->FolderHistory->SetAddMode(false,2,true);
// пусть плагин сам прыгает... ;-)
auto Panel = Global->CtrlObject->Cp()->ActivePanel();
if (SelectType == HRT_CTRLSHIFTENTER)
Panel = Global->CtrlObject->Cp()->PassivePanel();
//Type==1 - плагиновый путь
//Type==0 - обычный путь
Panel->ExecShortcutFolder(std::move(strStr), Guid, strFile, strData, true);
// Panel may be changed
if(SelectType == HRT_CTRLSHIFTENTER)
{
Panel = Global->CtrlObject->Cp()->ActivePanel();
Panel->SetCurPath();
Panel = Global->CtrlObject->Cp()->PassivePanel();
}
else
{
Panel = Global->CtrlObject->Cp()->ActivePanel();
}
Panel->Redraw();
Global->CtrlObject->FolderHistory->SetAddMode(true,2,true);
}
break;
case HRT_CTRLENTER:
SetString(strStr, true);
break;
default:
break;
}
}
return true;
case KEY_NUMENTER:
case KEY_SHIFTNUMENTER:
case KEY_ENTER:
case KEY_SHIFTENTER:
case KEY_CTRLALTENTER:
case KEY_RCTRLRALTENTER:
case KEY_CTRLRALTENTER:
case KEY_RCTRLALTENTER:
case KEY_CTRLALTNUMENTER:
case KEY_RCTRLRALTNUMENTER:
case KEY_CTRLRALTNUMENTER:
case KEY_RCTRLALTNUMENTER:
{
const auto ActivePanel = Global->CtrlObject->Cp()->ActivePanel();
CmdStr.RemoveSelection();
Refresh();
const auto& strStr = CmdStr.GetString();
bool TryExecute = true;
if (!strStr.empty())
{
ActivePanel->SetCurPath();
if (!(Global->Opt->ExcludeCmdHistory&EXCLUDECMDHISTORY_NOTCMDLINE))
Global->CtrlObject->CmdHistory->AddToHistory(strStr, HR_DEFAULT, nullptr, {}, m_CurDir);
TryExecute = !ActivePanel->ProcessPluginEvent(FE_COMMAND, UNSAFE_CSTR(strStr));
}
if (TryExecute)
{
const auto KeyCode = LocalKey();
const auto IsNewWindow = (KeyCode & KEY_SHIFT) != 0;
const auto IsRunAs = (KeyCode & KEY_CTRL || KeyCode & KEY_RCTRL) && (KeyCode & KEY_ALT || KeyCode & KEY_RALT);
execute_info Info;
Info.Command = strStr;
Info.NewWindow = IsNewWindow;
Info.RunAs = IsRunAs;
SetString(L"", false);
ExecString(Info);
}
}
return true;
case KEY_CTRLU:
case KEY_RCTRLU:
CmdStr.RemoveSelection();
Refresh();
return true;
case KEY_OP_XLAT:
{
// 13.12.2000 SVS - ! Для CmdLine - если нет выделения, преобразуем всю строку (XLat)
CmdStr.Xlat((Global->Opt->XLat.Flags&XLAT_CONVERTALLCMDLINE) != 0);
// иначе неправильно работает ctrl-end
strLastCmdStr = CmdStr.GetString();
LastCmdPartLength = static_cast<int>(strLastCmdStr.size());
return true;
}
/* дополнительные клавиши для выделения в ком строке.
ВНИМАНИЕ!
Для сокращения кода этот кусок должен стоять перед "default"
*/
case KEY_ALTSHIFTLEFT: case KEY_ALTSHIFTNUMPAD4:
case KEY_RALTSHIFTLEFT: case KEY_RALTSHIFTNUMPAD4:
case KEY_ALTSHIFTRIGHT: case KEY_ALTSHIFTNUMPAD6:
case KEY_RALTSHIFTRIGHT: case KEY_RALTSHIFTNUMPAD6:
case KEY_ALTSHIFTEND: case KEY_ALTSHIFTNUMPAD1:
case KEY_RALTSHIFTEND: case KEY_RALTSHIFTNUMPAD1:
case KEY_ALTSHIFTHOME: case KEY_ALTSHIFTNUMPAD7:
case KEY_RALTSHIFTHOME: case KEY_RALTSHIFTNUMPAD7:
LocalKey&=~(KEY_ALT|KEY_RALT);
[[fallthrough]];
default:
// Сбрасываем выделение на некоторых клавишах
if (!Global->Opt->CmdLine.EditBlock)
{
static const unsigned int UnmarkKeys[]=
{
KEY_LEFT, KEY_NUMPAD4,
KEY_CTRLS, KEY_RCTRLS,
KEY_RIGHT, KEY_NUMPAD6,
KEY_CTRLD, KEY_RCTRLD,
KEY_CTRLLEFT, KEY_CTRLNUMPAD4,
KEY_RCTRLLEFT, KEY_RCTRLNUMPAD4,
KEY_CTRLRIGHT, KEY_CTRLNUMPAD6,
KEY_RCTRLRIGHT, KEY_RCTRLNUMPAD6,
KEY_CTRLHOME, KEY_CTRLNUMPAD7,
KEY_RCTRLHOME, KEY_RCTRLNUMPAD7,
KEY_CTRLEND, KEY_CTRLNUMPAD1,
KEY_RCTRLEND, KEY_RCTRLNUMPAD1,
KEY_HOME, KEY_NUMPAD7,
KEY_END, KEY_NUMPAD1
};
if (contains(UnmarkKeys, LocalKey()))
{
CmdStr.RemoveSelection();
}
}
if (LocalKey() == KEY_CTRLD || LocalKey() == KEY_RCTRLD)
LocalKey=KEY_RIGHT;
if(LocalKey() == KEY_CTRLSPACE || LocalKey() == KEY_RCTRLSPACE)
{
SCOPED_ACTION(SetAutocomplete)(&CmdStr, true);
CmdStr.AutoComplete(true,false);
return true;
}
if (!CmdStr.ProcessKey(LocalKey))
return Global->WindowManager->Desktop()->ProcessKey(Key);
LastCmdPartLength=-1;
return true;
}
}
void XMLUtils::SetHex(TiXmlNode* pRootNode, const char *strTag, uint32_t value)
{
CStdString strValue;
strValue.Format("%x", value);
SetString(pRootNode, strTag, strValue);
}
void CWizSettings::SetProxyPassword(const QString& val)
{
SetString("Sync", "ProxyPassword", val);
}
void XMLUtils::SetDateTime(TiXmlNode* pRootNode, const char *strTag, const CDateTime& dateTime)
{
SetString(pRootNode, strTag, dateTime.GetAsDBDateTime());
}
BOOL CWizSettings::SetEncryptedString(const QString& strSection, const QString& strKey, const QString& str)
{
return SetString(strSection, strKey, WizStringToBase64(str));
}
void CValueControl::SetValue(CValue &Val)
{
SetString(Val.GetString());
};
/*
====================
idInterpreter::Execute
====================
*/
bool idInterpreter::Execute( void ) {
varEval_t var_a;
varEval_t var_b;
varEval_t var_c;
varEval_t var;
statement_t *st;
int runaway;
idThread *newThread;
float floatVal;
idScriptObject *obj;
const function_t *func;
if ( threadDying || !currentFunction ) {
return true;
}
if ( multiFrameEvent ) {
// move to previous instruction and call it again
instructionPointer--;
}
runaway = 5000000;
doneProcessing = false;
while( !doneProcessing && !threadDying ) {
instructionPointer++;
if ( !--runaway ) {
Error( "runaway loop error" );
}
// next statement
st = &gameLocal.program.GetStatement( instructionPointer );
switch( st->op ) {
case OP_RETURN:
LeaveFunction( st->a );
break;
case OP_THREAD:
newThread = new idThread( this, st->a->value.functionPtr, st->b->value.argSize );
newThread->Start();
// return the thread number to the script
gameLocal.program.ReturnFloat( newThread->GetThreadNum() );
PopParms( st->b->value.argSize );
break;
case OP_OBJTHREAD:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
func = obj->GetTypeDef()->GetFunction( st->b->value.virtualFunction );
assert( st->c->value.argSize == func->parmTotal );
newThread = new idThread( this, GetEntity( *var_a.entityNumberPtr ), func, func->parmTotal );
newThread->Start();
// return the thread number to the script
gameLocal.program.ReturnFloat( newThread->GetThreadNum() );
} else {
// return a null thread to the script
gameLocal.program.ReturnFloat( 0.0f );
}
PopParms( st->c->value.argSize );
break;
case OP_CALL:
EnterFunction( st->a->value.functionPtr, false );
break;
case OP_EVENTCALL:
CallEvent( st->a->value.functionPtr, st->b->value.argSize );
break;
case OP_OBJECTCALL:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
func = obj->GetTypeDef()->GetFunction( st->b->value.virtualFunction );
EnterFunction( func, false );
} else {
// return a 'safe' value
gameLocal.program.ReturnVector( vec3_zero );
gameLocal.program.ReturnString( "" );
PopParms( st->c->value.argSize );
}
break;
case OP_SYSCALL:
CallSysEvent( st->a->value.functionPtr, st->b->value.argSize );
break;
case OP_IFNOT:
var_a = GetVariable( st->a );
if ( *var_a.intPtr == 0 ) {
NextInstruction( instructionPointer + st->b->value.jumpOffset );
}
break;
case OP_IF:
var_a = GetVariable( st->a );
if ( *var_a.intPtr != 0 ) {
NextInstruction( instructionPointer + st->b->value.jumpOffset );
}
break;
case OP_GOTO:
NextInstruction( instructionPointer + st->a->value.jumpOffset );
break;
case OP_ADD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.floatPtr + *var_b.floatPtr;
break;
case OP_ADD_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.vectorPtr + *var_b.vectorPtr;
break;
case OP_ADD_S:
SetString( st->c, GetString( st->a ) );
AppendString( st->c, GetString( st->b ) );
break;
case OP_ADD_FS:
var_a = GetVariable( st->a );
SetString( st->c, FloatToString( *var_a.floatPtr ) );
AppendString( st->c, GetString( st->b ) );
break;
case OP_ADD_SF:
var_b = GetVariable( st->b );
SetString( st->c, GetString( st->a ) );
AppendString( st->c, FloatToString( *var_b.floatPtr ) );
break;
case OP_ADD_VS:
var_a = GetVariable( st->a );
SetString( st->c, var_a.vectorPtr->ToString() );
AppendString( st->c, GetString( st->b ) );
break;
case OP_ADD_SV:
var_b = GetVariable( st->b );
SetString( st->c, GetString( st->a ) );
AppendString( st->c, var_b.vectorPtr->ToString() );
break;
case OP_SUB_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.floatPtr - *var_b.floatPtr;
break;
case OP_SUB_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.vectorPtr - *var_b.vectorPtr;
break;
case OP_MUL_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.floatPtr * *var_b.floatPtr;
break;
case OP_MUL_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = *var_a.vectorPtr * *var_b.vectorPtr;
break;
case OP_MUL_FV:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.floatPtr * *var_b.vectorPtr;
break;
case OP_MUL_VF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.vectorPtr = *var_a.vectorPtr * *var_b.floatPtr;
break;
case OP_DIV_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
if ( *var_b.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_c.floatPtr = idMath::INFINITY;
} else {
*var_c.floatPtr = *var_a.floatPtr / *var_b.floatPtr;
}
break;
case OP_MOD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable ( st->c );
if ( *var_b.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_c.floatPtr = *var_a.floatPtr;
} else {
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr ) % static_cast<int>( *var_b.floatPtr );
}
break;
case OP_BITAND:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr ) & static_cast<int>( *var_b.floatPtr );
break;
case OP_BITOR:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr ) | static_cast<int>( *var_b.floatPtr );
break;
case OP_GE:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr >= *var_b.floatPtr );
break;
case OP_LE:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr <= *var_b.floatPtr );
break;
case OP_GT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr > *var_b.floatPtr );
break;
case OP_LT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr < *var_b.floatPtr );
break;
case OP_AND:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) && ( *var_b.floatPtr != 0.0f );
break;
case OP_AND_BOOLF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) && ( *var_b.floatPtr != 0.0f );
break;
case OP_AND_FBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) && ( *var_b.intPtr != 0 );
break;
case OP_AND_BOOLBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) && ( *var_b.intPtr != 0 );
break;
case OP_OR:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) || ( *var_b.floatPtr != 0.0f );
break;
case OP_OR_BOOLF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) || ( *var_b.floatPtr != 0.0f );
break;
case OP_OR_FBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != 0.0f ) || ( *var_b.intPtr != 0 );
break;
case OP_OR_BOOLBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr != 0 ) || ( *var_b.intPtr != 0 );
break;
case OP_NOT_BOOL:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.intPtr == 0 );
break;
case OP_NOT_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr == 0.0f );
break;
case OP_NOT_V:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.vectorPtr == vec3_zero );
break;
case OP_NOT_S:
var_c = GetVariable( st->c );
*var_c.floatPtr = ( strlen( GetString( st->a ) ) == 0 );
break;
case OP_NOT_ENT:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( GetEntity( *var_a.entityNumberPtr ) == NULL );
break;
case OP_NEG_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = -*var_a.floatPtr;
break;
case OP_NEG_V:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.vectorPtr = -*var_a.vectorPtr;
break;
case OP_INT_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = static_cast<int>( *var_a.floatPtr );
break;
case OP_EQ_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr == *var_b.floatPtr );
break;
case OP_EQ_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.vectorPtr == *var_b.vectorPtr );
break;
case OP_EQ_S:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( idStr::Cmp( GetString( st->a ), GetString( st->b ) ) == 0 );
break;
case OP_EQ_E:
case OP_EQ_EO:
case OP_EQ_OE:
case OP_EQ_OO:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.entityNumberPtr == *var_b.entityNumberPtr );
break;
case OP_NE_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.floatPtr != *var_b.floatPtr );
break;
case OP_NE_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.vectorPtr != *var_b.vectorPtr );
break;
case OP_NE_S:
var_c = GetVariable( st->c );
*var_c.floatPtr = ( idStr::Cmp( GetString( st->a ), GetString( st->b ) ) != 0 );
break;
case OP_NE_E:
case OP_NE_EO:
case OP_NE_OE:
case OP_NE_OO:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
var_c = GetVariable( st->c );
*var_c.floatPtr = ( *var_a.entityNumberPtr != *var_b.entityNumberPtr );
break;
case OP_UADD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr += *var_a.floatPtr;
break;
case OP_UADD_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr += *var_a.vectorPtr;
break;
case OP_USUB_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr -= *var_a.floatPtr;
break;
case OP_USUB_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr -= *var_a.vectorPtr;
break;
case OP_UMUL_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr *= *var_a.floatPtr;
break;
case OP_UMUL_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr *= *var_a.floatPtr;
break;
case OP_UDIV_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_b.floatPtr = idMath::INFINITY;
} else {
*var_b.floatPtr = *var_b.floatPtr / *var_a.floatPtr;
}
break;
case OP_UDIV_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
var_b.vectorPtr->Set( idMath::INFINITY, idMath::INFINITY, idMath::INFINITY );
} else {
*var_b.vectorPtr = *var_b.vectorPtr / *var_a.floatPtr;
}
break;
case OP_UMOD_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr == 0.0f ) {
Warning( "Divide by zero" );
*var_b.floatPtr = *var_a.floatPtr;
} else {
*var_b.floatPtr = static_cast<int>( *var_b.floatPtr ) % static_cast<int>( *var_a.floatPtr );
}
break;
case OP_UOR_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = static_cast<int>( *var_b.floatPtr ) | static_cast<int>( *var_a.floatPtr );
break;
case OP_UAND_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = static_cast<int>( *var_b.floatPtr ) & static_cast<int>( *var_a.floatPtr );
break;
case OP_UINC_F:
var_a = GetVariable( st->a );
( *var_a.floatPtr )++;
break;
case OP_UINCP_F:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
( *var.floatPtr )++;
}
break;
case OP_UDEC_F:
var_a = GetVariable( st->a );
( *var_a.floatPtr )--;
break;
case OP_UDECP_F:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
( *var.floatPtr )--;
}
break;
case OP_COMP_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
*var_c.floatPtr = ~static_cast<int>( *var_a.floatPtr );
break;
case OP_STORE_F:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = *var_a.floatPtr;
break;
case OP_STORE_ENT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.entityNumberPtr = *var_a.entityNumberPtr;
break;
case OP_STORE_BOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.intPtr = *var_a.intPtr;
break;
case OP_STORE_OBJENT:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( !obj ) {
*var_b.entityNumberPtr = 0;
} else if ( !obj->GetTypeDef()->Inherits( st->b->TypeDef() ) ) {
//Warning( "object '%s' cannot be converted to '%s'", obj->GetTypeName(), st->b->TypeDef()->Name() );
*var_b.entityNumberPtr = 0;
} else {
*var_b.entityNumberPtr = *var_a.entityNumberPtr;
}
break;
case OP_STORE_OBJ:
case OP_STORE_ENTOBJ:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.entityNumberPtr = *var_a.entityNumberPtr;
break;
case OP_STORE_S:
SetString( st->b, GetString( st->a ) );
break;
case OP_STORE_V:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.vectorPtr = *var_a.vectorPtr;
break;
case OP_STORE_FTOS:
var_a = GetVariable( st->a );
SetString( st->b, FloatToString( *var_a.floatPtr ) );
break;
case OP_STORE_BTOS:
var_a = GetVariable( st->a );
SetString( st->b, *var_a.intPtr ? "true" : "false" );
break;
case OP_STORE_VTOS:
var_a = GetVariable( st->a );
SetString( st->b, var_a.vectorPtr->ToString() );
break;
case OP_STORE_FTOBOOL:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
if ( *var_a.floatPtr != 0.0f ) {
*var_b.intPtr = 1;
} else {
*var_b.intPtr = 0;
}
break;
case OP_STORE_BOOLTOF:
var_a = GetVariable( st->a );
var_b = GetVariable( st->b );
*var_b.floatPtr = static_cast<float>( *var_a.intPtr );
break;
case OP_STOREP_F:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->floatPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->floatPtr = *var_a.floatPtr;
}
break;
case OP_STOREP_ENT:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->entityNumberPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->entityNumberPtr = *var_a.entityNumberPtr;
}
break;
case OP_STOREP_FLD:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->intPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->intPtr = *var_a.intPtr;
}
break;
case OP_STOREP_BOOL:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->intPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->intPtr = *var_a.intPtr;
}
break;
case OP_STOREP_S:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
idStr::Copynz( var_b.evalPtr->stringPtr, GetString( st->a ), MAX_STRING_LEN );
}
break;
case OP_STOREP_V:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->vectorPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->vectorPtr = *var_a.vectorPtr;
}
break;
case OP_STOREP_FTOS:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
var_a = GetVariable( st->a );
idStr::Copynz( var_b.evalPtr->stringPtr, FloatToString( *var_a.floatPtr ), MAX_STRING_LEN );
}
break;
case OP_STOREP_BTOS:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
var_a = GetVariable( st->a );
if ( *var_a.floatPtr != 0.0f ) {
idStr::Copynz( var_b.evalPtr->stringPtr, "true", MAX_STRING_LEN );
} else {
idStr::Copynz( var_b.evalPtr->stringPtr, "false", MAX_STRING_LEN );
}
}
break;
case OP_STOREP_VTOS:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->stringPtr ) {
var_a = GetVariable( st->a );
idStr::Copynz( var_b.evalPtr->stringPtr, var_a.vectorPtr->ToString(), MAX_STRING_LEN );
}
break;
case OP_STOREP_FTOBOOL:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->intPtr ) {
var_a = GetVariable( st->a );
if ( *var_a.floatPtr != 0.0f ) {
*var_b.evalPtr->intPtr = 1;
} else {
*var_b.evalPtr->intPtr = 0;
}
}
break;
case OP_STOREP_BOOLTOF:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->floatPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->floatPtr = static_cast<float>( *var_a.intPtr );
}
break;
case OP_STOREP_OBJ:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->entityNumberPtr ) {
var_a = GetVariable( st->a );
*var_b.evalPtr->entityNumberPtr = *var_a.entityNumberPtr;
}
break;
case OP_STOREP_OBJENT:
var_b = GetVariable( st->b );
if ( var_b.evalPtr && var_b.evalPtr->entityNumberPtr ) {
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( !obj ) {
*var_b.evalPtr->entityNumberPtr = 0;
// st->b points to type_pointer, which is just a temporary that gets its type reassigned, so we store the real type in st->c
// so that we can do a type check during run time since we don't know what type the script object is at compile time because it
// comes from an entity
} else if ( !obj->GetTypeDef()->Inherits( st->c->TypeDef() ) ) {
//Warning( "object '%s' cannot be converted to '%s'", obj->GetTypeName(), st->c->TypeDef()->Name() );
*var_b.evalPtr->entityNumberPtr = 0;
} else {
*var_b.evalPtr->entityNumberPtr = *var_a.entityNumberPtr;
}
}
break;
case OP_ADDRESS:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var_c.evalPtr->bytePtr = &obj->data[ st->b->value.ptrOffset ];
} else {
var_c.evalPtr->bytePtr = NULL;
}
break;
case OP_INDIRECT_F:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.floatPtr = *var.floatPtr;
} else {
*var_c.floatPtr = 0.0f;
}
break;
case OP_INDIRECT_ENT:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.entityNumberPtr = *var.entityNumberPtr;
} else {
*var_c.entityNumberPtr = 0;
}
break;
case OP_INDIRECT_BOOL:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.intPtr = *var.intPtr;
} else {
*var_c.intPtr = 0;
}
break;
case OP_INDIRECT_S:
var_a = GetVariable( st->a );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
SetString( st->c, var.stringPtr );
} else {
SetString( st->c, "" );
}
break;
case OP_INDIRECT_V:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( obj ) {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.vectorPtr = *var.vectorPtr;
} else {
var_c.vectorPtr->Zero();
}
break;
case OP_INDIRECT_OBJ:
var_a = GetVariable( st->a );
var_c = GetVariable( st->c );
obj = GetScriptObject( *var_a.entityNumberPtr );
if ( !obj ) {
*var_c.entityNumberPtr = 0;
} else {
var.bytePtr = &obj->data[ st->b->value.ptrOffset ];
*var_c.entityNumberPtr = *var.entityNumberPtr;
}
break;
case OP_PUSH_F:
var_a = GetVariable( st->a );
Push( *var_a.intPtr );
break;
case OP_PUSH_FTOS:
var_a = GetVariable( st->a );
PushString( FloatToString( *var_a.floatPtr ) );
break;
case OP_PUSH_BTOF:
var_a = GetVariable( st->a );
floatVal = *var_a.intPtr;
Push( *reinterpret_cast<int *>( &floatVal ) );
break;
case OP_PUSH_FTOB:
var_a = GetVariable( st->a );
if ( *var_a.floatPtr != 0.0f ) {
Push( 1 );
} else {
Push( 0 );
}
break;
case OP_PUSH_VTOS:
var_a = GetVariable( st->a );
PushString( var_a.vectorPtr->ToString() );
break;
case OP_PUSH_BTOS:
var_a = GetVariable( st->a );
PushString( *var_a.intPtr ? "true" : "false" );
break;
case OP_PUSH_ENT:
var_a = GetVariable( st->a );
Push( *var_a.entityNumberPtr );
break;
case OP_PUSH_S:
PushString( GetString( st->a ) );
break;
case OP_PUSH_V:
var_a = GetVariable( st->a );
Push( *reinterpret_cast<int *>( &var_a.vectorPtr->x ) );
Push( *reinterpret_cast<int *>( &var_a.vectorPtr->y ) );
Push( *reinterpret_cast<int *>( &var_a.vectorPtr->z ) );
break;
case OP_PUSH_OBJ:
var_a = GetVariable( st->a );
Push( *var_a.entityNumberPtr );
break;
case OP_PUSH_OBJENT:
var_a = GetVariable( st->a );
Push( *var_a.entityNumberPtr );
break;
case OP_BREAK:
case OP_CONTINUE:
default:
Error( "Bad opcode %i", st->op );
break;
}
}
return threadDying;
}
void ParametersList::SetNumber( int key, long valor )
{
string sValor = StringUtilities::NumberToString( valor );
SetString( key, sValor );
}
void
FontDemoView::MessageReceived(BMessage* msg)
{
switch (msg->what) {
case TEXT_CHANGED_MSG:
{
const char* text = NULL;
if (msg->FindString("_text", &text) == B_OK) {
SetString(text);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case FONTSTYLE_CHANGED_MSG:
{
BMessage fontMessage;
if (msg->FindMessage("_fontMessage", &fontMessage) != B_OK)
return;
const char* family;
const char* style;
if (fontMessage.FindString("_family", &family) != B_OK
|| fontMessage.FindString("_style", &style) != B_OK)
return;
fFont.SetFamilyAndStyle(family, style);
Invalidate();
break;
}
case FONTFAMILY_CHANGED_MSG:
{
BMessage fontMessage;
if (msg->FindMessage("_fontMessage", &fontMessage) != B_OK)
return;
const char* family;
if (fontMessage.FindString("_family", &family) != B_OK)
return;
font_style style;
if (get_font_style(const_cast<char*>(family), 0, &style) == B_OK) {
fFont.SetFamilyAndStyle(family, style);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case FONTSIZE_MSG:
{
float size = 0.0;
if (msg->FindFloat("_size", &size) == B_OK) {
SetFontSize(size);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case FONTSHEAR_MSG:
{
float shear = 90.0;
if (msg->FindFloat("_shear", &shear) == B_OK) {
SetFontShear(shear);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case ROTATION_MSG:
{
float rotation = 0.0;
if (msg->FindFloat("_rotation", &rotation) == B_OK) {
SetFontRotation(rotation);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case SPACING_MSG:
{
float space = 0.0;
if (msg->FindFloat("_spacing", &space) == B_OK) {
SetSpacing(space);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case OUTLINE_MSG:
{
int8 outline = 0;
if (msg->FindInt8("_outline", &outline) == B_OK) {
SetOutlineLevel(outline);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case ALIASING_MSG:
{
bool aliased = false;
if (msg->FindBool("_aliased", &aliased) == B_OK) {
SetAntialiasing(aliased);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case DRAWINGMODE_CHANGED_MSG:
{
if (msg->FindInt32("_mode", (int32 *)&fDrawingMode) == B_OK) {
Invalidate(/*&fBoxRegion*/);
}
break;
}
case BOUNDING_BOX_MSG:
{
bool boundingbox = false;
if (msg->FindBool("_boundingbox", &boundingbox) == B_OK) {
SetDrawBoundingBoxes(boundingbox);
Invalidate(/*&fBoxRegion*/);
}
break;
}
default:
BView::MessageReceived(msg);
break;
}
}
bool CBitcoinSecret::SetString(const std::string& strSecret)
{
return SetString(strSecret.c_str());
}