Node* NodeTypeManager::Create(string name, Pipeline* p) { auto info = TypeOf(name); if( info != 0 ) return info->newInstance(p); return 0; }
DataNode& DataNode::SetValueRaw(const IObject& object) { struct helper { static void WriteObject(void* object, const ObjectType& type, DataNode& node) { for (auto baseType : type.GetBaseTypes()) { const ObjectType* baseObjectType = dynamic_cast<const ObjectType*>(baseType.type); if (!baseObjectType) continue; void* baseObject = (*baseType.dynamicCastUpFunc)(object); WriteObject(baseObject, *baseObjectType, node); } for (auto field : type.GetFields()) { auto srlzAttribute = field->GetAttribute<SerializableAttribute>(); if (srlzAttribute) field->SerializeFromObject(object, *node.AddNode(field->GetName())); } } }; if (object.GetType().IsBasedOn(TypeOf(ISerializable))) ((const ISerializable&)object).OnSerialize(*this); const ObjectType& type = dynamic_cast<const ObjectType&>(object.GetType()); void* objectPtr = type.DynamicCastFromIObject(const_cast<IObject*>(&object)); helper::WriteObject(objectPtr, type, *this); return *this; }
static struct code * code_pointer(lispobj object) { lispobj *headerp, header; int type, len; headerp = (lispobj *) PTR(object); header = *headerp; type = TypeOf(header); switch (type) { case type_CodeHeader: break; case type_ReturnPcHeader: case type_FunctionHeader: case type_ClosureFunctionHeader: len = HEADER_LENGTH(header); if (len == 0) headerp = NULL; else headerp -= len; break; default: headerp = NULL; } return (struct code *) headerp; }
/** * Add new child node after given node */ static Node *_build_node(Node *node, unsigned char *string, unsigned short length) { Node *next_node; if (length >= 1) { Node new_node; _node_init(&new_node, (BMapNode){(BMap){NULL, 0}}, NULL); _node_array_init(&new_node); //TODO: If key length <= sizeof(ptr) don't malloc, // Just turn pointer into a union and store the array inline. if(length > 1) { _node_set_array(&new_node, length-1); memcpy(new_node.array, string+1, length-1); } Result(BMapEntryNodePtr) result = bmap_node_insert(&node->children, string[0], new_node); if(TypeOf(result) == Type(Result, Ok)) { next_node = &result.data->node; } trace_node("BUILD-NODE", next_node); } else { next_node = node; trace_node("REUSE-NODE", next_node); } return next_node; }
void WindowsManager::SetWindowsLayout(WindowsLayout layout) { for (auto wnd : layout.windows) { IEditorWindow* editorWindow = o2EditorWindows.mEditorWindows.FindMatch([&](IEditorWindow* x) { return x->mWindow->GetName() == wnd.Key(); }); if (!editorWindow) { o2Debug.Log("Can't restore window with name:" + wnd.Key()); continue; } if (DockableWindow* dockWnd = editorWindow->mWindow) { editorWindow->Show(); *dockWnd->layout = wnd.Value(); } } layout.RestoreDock(&layout.mainDock, o2EditorWindows.mMainDockPlace); for (auto wnd : o2EditorWindows.mEditorWindows) { bool hide = !layout.windows.ContainsKey(wnd->mWindow->GetName()) && wnd->mWindow->GetParent()->GetType() != TypeOf(DockWindowPlace); if (hide) wnd->Hide(); } }
static int EndTry( void ) { int parent_scope; TREEPTR expr; TREEPTR func; TREEPTR tree; TYPEPTR typ; int expr_type; DropBreakLabel(); /* _leave jumps to this label */ parent_scope = BlockStack->parent_index; tree = LeafNode( OPR_TRY ); tree->op.st.try_index = BlockStack->try_index; tree->op.st.parent_scope = parent_scope; AddStmt( tree ); if( (CurToken == T__EXCEPT) || (CurToken == T___EXCEPT) ) { NextToken(); BlockStack->block_type = T__EXCEPT; BlockStack->break_label = NextLabel(); Jump( BlockStack->break_label ); DeadCode = 0; tree = LeafNode( OPR_EXCEPT ); tree->op.st.try_sym_handle = DummyTrySymbol(); tree->op.st.parent_scope = parent_scope; AddStmt( tree ); CompFlags.exception_filter_expr = 1; expr = RValue( BracketExpr() ); CompFlags.exception_filter_expr = 0; CompFlags.exception_handler = 1; typ = TypeOf( expr ); expr_type = DataTypeOf( typ ); if( expr_type != TYPE_VOID ) { if( expr_type > TYPE_ULONG ) { CErr1( ERR_EXPR_MUST_BE_INTEGRAL ); } } func = VarLeaf( SymGetPtr( SymExcept ), SymExcept ); func->op.opr = OPR_FUNCNAME; expr = ExprNode( NULL, OPR_PARM, expr ); expr->expr_type = typ; expr->op.result_type = typ; tree = ExprNode( func, OPR_CALL, expr ); tree->expr_type = GetType( TYPE_VOID ); AddStmt( tree ); return( 1 ); } else if( (CurToken == T__FINALLY) || (CurToken == T___FINALLY) ) { CompFlags.in_finally_block = 1; NextToken(); BlockStack->block_type = T__FINALLY; DeadCode = 0; tree = LeafNode( OPR_FINALLY ); tree->op.st.try_sym_handle = DummyTrySymbol(); tree->op.st.parent_scope = parent_scope; AddStmt( tree ); return( 1 ); } return( 0 ); }
Vector<UnknownPtr> AssetsFoldersTree::GetFoldersTreeNodeChilds(UnknownPtr object) { AssetTree::AssetNode* assetTreeNode = object; if (assetTreeNode) { return assetTreeNode->children. FindAll([](AssetTree::AssetNode* x) { return x->assetType == &TypeOf(FolderAsset); }). Select<UnknownPtr>([](AssetTree::AssetNode* x) { return UnknownPtr(x); }); } else { const AssetTree& assetsTree = o2Assets.GetAssetsTree(); return assetsTree.mRootAssets. FindAll([](AssetTree::AssetNode* x) { return x->assetType == &TypeOf(FolderAsset); }). Select<UnknownPtr>([](AssetTree::AssetNode* x) { return UnknownPtr(x); }); } }
/* check an entry to make sure it's a variable */ void CheckVar(char name) { char tmp_buf[MAX_BUF]; if (!InTable(name)) { Undefined(name); } if (TypeOf(name) != 'v') { sprintf(tmp_buf, "%c is not a variable", name); Abort(tmp_buf); } }
void WindowsManager::InitializeWindows() { auto windowTypes = TypeOf(IEditorWindow).GetDerivedTypes(); for (auto type : windowTypes) { IEditorWindow* newWindow = (IEditorWindow*)type->CreateSample(); mEditorWindows.Add(newWindow); } for (auto wnd : mEditorWindows) wnd->PostInitializeWindow(); }
static void SwitchStmt( void ) { SWITCHPTR sw; TREEPTR tree; TYPEPTR typ; int switch_type; StartNewBlock(); NextToken(); sw = (SWITCHPTR)CMemAlloc( sizeof( SWITCHDEFN ) ); sw->prev_switch = SwitchStack; sw->low_value = ~0l; sw->high_value = 0; sw->case_format = "%ld"; /* assume signed cases */ SwitchStack = sw; switch_type = TYPE_INT; /* assume int */ tree = RValue( BracketExpr() ); typ = TypeOf( tree ); if( typ->decl_type == TYPE_ENUM ) typ = typ->object; if( typ->decl_type == TYPE_UFIELD ) { if( typ->u.f.field_width == (TARGET_INT * 8) ) { sw->case_format = "%lu"; switch_type = TYPE_UINT; } } switch( typ->decl_type ) { case TYPE_USHORT: case TYPE_UINT: sw->case_format = "%lu"; switch_type = TYPE_UINT; case TYPE_CHAR: case TYPE_UCHAR: case TYPE_SHORT: case TYPE_INT: case TYPE_FIELD: case TYPE_UFIELD: break; case TYPE_ULONG: sw->case_format = "%lu"; switch_type = TYPE_ULONG; break; case TYPE_LONG: switch_type = TYPE_LONG; break; default: CErr1( ERR_INVALID_TYPE_FOR_SWITCH ); } tree = ExprNode( 0, OPR_SWITCH, tree ); tree->op.switch_info = sw; AddStmt( tree ); }
WindowsLayout WindowsManager::GetWindowsLayout() { WindowsLayout res; res.mainDock.RetrieveLayout(o2EditorWindows.mMainDockPlace); for (auto widget : EditorUIRoot.GetRootWidget()->GetChildWidgets()) { if (widget->GetType() == TypeOf(DockableWindow)) res.windows.Add(widget->name, *widget->layout); } return res; }
const NodeTypeInfo* NodeTypeManager::RegisterNode( string nodeName , const NodeLayoutDescriptor& layout, NodeUpdater* updater ) { SCOPEDBLOCK("NodeTypeManager::RegisterNode"); auto existing = TypeOf(nodeName); if ( existing != 0 ) return existing; auto info = new NodeTypeInfo; info->_name = nodeName; info->_updater = updater; info->_layout = layout; _types[nodeName] = info; return info; }
static void ReadObject(void* object, void* source, const ObjectType& type, const DataNode& node) { for (auto baseType : type.GetBaseTypes()) { const ObjectType* baseObjectType = dynamic_cast<const ObjectType*>(baseType.type); if (!baseObjectType) continue; void* baseObject = (*baseType.dynamicCastUpFunc)(object); void* baseSourceObject = (*baseType.dynamicCastUpFunc)(source); ReadObject(baseObject, baseSourceObject, *baseObjectType, node); } for (auto field : type.GetFields()) { if (!field->GetAttribute<SerializableAttribute>()) continue; auto fldNode = node.GetNode(field->GetName()); if (fldNode) { if (field->GetType()->IsBasedOn(TypeOf(IObject))) { bool usedConverter = false; for (auto conv : mDataConverters) { if (conv->IsConvertsType(field->GetType())) { conv->FromData(field->GetValuePtr(object), node); usedConverter = true; break; } } if (usedConverter) continue; fldNode->GetValueDelta(*(IObject*)field->GetValuePtr(object), *(IObject*)field->GetValuePtr(source)); } else field->DeserializeFromObject(object, *fldNode); } else field->CopyValue(object, source); } }
bool SearchTerm::is_valid() const { // We can accept also a zero value in these cases if (operator_ == SearchTerm::Op_NumericDate) { return value_.toInt() >= 0; } else if (operator_ == SearchTerm::Op_RelativeDate) { return (value_.toInt() >= 0 && value_.toInt() < second_value_.toInt()); } switch (TypeOf(field_)) { case Type_Text: return !value_.toString().isEmpty(); case Type_Date: return value_.toInt() != 0; case Type_Number: return value_.toInt() >= 0; case Type_Rating: return value_.toFloat() >= 0.0; case Type_Time: return true; case Type_Invalid: return false; } return false; }
static void ParseArg (ArgDesc* Arg, Type* Type) /* Parse one argument but do not push it onto the stack. Make all fields in * Arg valid. */ { /* We have a prototype, so chars may be pushed as chars */ Arg->Flags = CF_FORCECHAR; /* Remember the required argument type */ Arg->ArgType = Type; /* Read the expression we're going to pass to the function */ MarkedExprWithCheck (hie1, &Arg->Expr); /* Remember the actual argument type */ Arg->Type = Arg->Expr.Type; /* Convert this expression to the expected type */ TypeConversion (&Arg->Expr, Type); /* Remember the following code position */ GetCodePos (&Arg->Load); /* If the value is a constant, set the flag, otherwise load it into the * primary register. */ if (ED_IsConstAbsInt (&Arg->Expr) && ED_CodeRangeIsEmpty (&Arg->Expr)) { /* Remember that we have a constant value */ Arg->Flags |= CF_CONST; } else { /* Load into the primary */ LoadExpr (CF_NONE, &Arg->Expr); } /* Remember the following code position */ GetCodePos (&Arg->Push); GetCodePos (&Arg->End); /* Use the type of the argument for the push */ Arg->Flags |= TypeOf (Arg->Expr.Type); }
/* ======================== idSWFScriptVar::PrintToConsole ======================== */ void idSWFScriptVar::PrintToConsole() const { idLib::Printf( "Object type: %s\n", TypeOf() ); if( IsObject() ) { GetObject()->PrintToConsole(); } else if( IsNumeric() ) { idLib::Printf( "%d\n", ToInteger() ); } else if( IsString() ) { idLib::Printf( "%s\n", ToString().c_str() ); } else { idLib::Printf( "unknown\n" ); } }
static void LoadConstant (unsigned Flags, ExprDesc* Expr) /* Load the primary register with some constant value. */ { switch (ED_GetLoc (Expr)) { case E_LOC_ABS: /* Number constant */ g_getimmed (Flags | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0); break; case E_LOC_GLOBAL: /* Global symbol, load address */ g_getimmed ((Flags | CF_EXTERNAL) & ~CF_CONST, Expr->Name, Expr->IVal); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static symbol or literal, load address */ g_getimmed ((Flags | CF_STATIC) & ~CF_CONST, Expr->Name, Expr->IVal); break; case E_LOC_REGISTER: /* Register variable. Taking the address is usually not * allowed. */ if (IS_Get (&AllowRegVarAddr) == 0) { Error ("Cannot take the address of a register variable"); } g_getimmed ((Flags | CF_REGVAR) & ~CF_CONST, Expr->Name, Expr->IVal); break; case E_LOC_STACK: g_leasp (Expr->IVal); break; default: Internal ("Unknown constant type: %04X", Expr->Flags); } }
void DataNode::GetValueRaw(IObject& object) const { struct helper { static void ReadObject(void* object, const ObjectType& type, const DataNode& node) { for (auto baseType : type.GetBaseTypes()) { const ObjectType* baseObjectType = dynamic_cast<const ObjectType*>(baseType.type); if (!baseObjectType) continue; void* baseObject = (*baseType.dynamicCastUpFunc)(object); ReadObject(baseObject, *baseObjectType, node); } for (auto field : type.GetFields()) { auto srlzAttribute = field->GetAttribute<SerializableAttribute>(); if (srlzAttribute) { auto fldNode = node.GetNode(field->GetName()); if (fldNode) field->DeserializeFromObject(object, *fldNode); } } } }; const ObjectType& type = dynamic_cast<const ObjectType&>(object.GetType()); void* objectPtr = type.DynamicCastFromIObject(const_cast<IObject*>(&object)); helper::ReadObject(objectPtr, type, *this); if (object.GetType().IsBasedOn(TypeOf(ISerializable))) ((ISerializable&)object).OnDeserialized(*this); }
void ProcHierarchy(String& hierarchy, Widget* widget, int level) { String sideNames[] = { "Hor", "Ver" }; for (int i = 0; i < level; i++) hierarchy += ' '; hierarchy += widget->GetName(); if (widget->GetType() == TypeOf(DockWindowPlace)) { hierarchy += ": "; hierarchy += (String)(bool)((DockWindowPlace*)widget)->interactable; hierarchy += " "; hierarchy += sideNames[(int)((DockWindowPlace*)widget)->GetResizibleDir()]; RectF rt = widget->layout->GetWorldRect(); hierarchy += (String)rt.left + " " + (String)rt.bottom + " " + (String)rt.right + " " + (String)rt.top; } hierarchy += '\n'; for (auto child : widget->GetChildWidgets()) ProcHierarchy(hierarchy, child, level + 1); }
void NewFunc (SymEntry* Func) /* Parse argument declarations and function body. */ { int C99MainFunc = 0;/* Flag for C99 main function returning int */ SymEntry* Param; /* Get the function descriptor from the function entry */ FuncDesc* D = Func->V.F.Func; /* Allocate the function activation record for the function */ CurrentFunc = NewFunction (Func); /* Reenter the lexical level */ ReenterFunctionLevel (D); /* Check if the function header contains unnamed parameters. These are * only allowed in cc65 mode. */ if ((D->Flags & FD_UNNAMED_PARAMS) != 0 && (IS_Get (&Standard) != STD_CC65)) { Error ("Parameter name omitted"); } /* Declare two special functions symbols: __fixargs__ and __argsize__. * The latter is different depending on the type of the function (variadic * or not). */ AddConstSym ("__fixargs__", type_uint, SC_DEF | SC_CONST, D->ParamSize); if (D->Flags & FD_VARIADIC) { /* Variadic function. The variable must be const. */ static const Type T[] = { TYPE(T_UCHAR | T_QUAL_CONST), TYPE(T_END) }; AddLocalSym ("__argsize__", T, SC_DEF | SC_REF | SC_AUTO, 0); } else { /* Non variadic */ AddConstSym ("__argsize__", type_uchar, SC_DEF | SC_CONST, D->ParamSize); } /* Function body now defined */ Func->Flags |= SC_DEF; /* Special handling for main() */ if (strcmp (Func->Name, "main") == 0) { /* Mark this as the main function */ CurrentFunc->Flags |= FF_IS_MAIN; /* Main cannot be a fastcall function */ if (IsQualFastcall (Func->Type)) { Error ("`main' cannot be declared as __fastcall__"); } /* If cc65 extensions aren't enabled, don't allow a main function that * doesn't return an int. */ if (IS_Get (&Standard) != STD_CC65 && CurrentFunc->ReturnType[0].C != T_INT) { Error ("`main' must always return an int"); } /* Add a forced import of a symbol that is contained in the startup * code. This will force the startup code to be linked in. */ g_importstartup (); /* If main() takes parameters, generate a forced import to a function * that will setup these parameters. This way, programs that do not * need the additional code will not get it. */ if (D->ParamCount > 0 || (D->Flags & FD_VARIADIC) != 0) { g_importmainargs (); } /* Determine if this is a main function in a C99 environment that * returns an int. */ if (IsTypeInt (F_GetReturnType (CurrentFunc)) && IS_Get (&Standard) == STD_C99) { C99MainFunc = 1; } } /* Allocate code and data segments for this function */ Func->V.F.Seg = PushSegments (Func); /* Allocate a new literal pool */ PushLiteralPool (Func); /* If this is a fastcall function, push the last parameter onto the stack */ if (IsQualFastcall (Func->Type) && D->ParamCount > 0) { unsigned Flags; /* Fastcall functions may never have an ellipsis or the compiler is buggy */ CHECK ((D->Flags & FD_VARIADIC) == 0); /* Generate the push */ if (IsTypeFunc (D->LastParam->Type)) { /* Pointer to function */ Flags = CF_PTR; } else { Flags = TypeOf (D->LastParam->Type) | CF_FORCECHAR; } g_push (Flags, 0); } /* Generate function entry code if needed */ g_enter (TypeOf (Func->Type), F_GetParamSize (CurrentFunc)); /* If stack checking code is requested, emit a call to the helper routine */ if (IS_Get (&CheckStack)) { g_stackcheck (); } /* Setup the stack */ StackPtr = 0; /* Walk through the parameter list and allocate register variable space * for parameters declared as register. Generate code to swap the contents * of the register bank with the save area on the stack. */ Param = D->SymTab->SymHead; while (Param && (Param->Flags & SC_PARAM) != 0) { /* Check for a register variable */ if (SymIsRegVar (Param)) { /* Allocate space */ int Reg = F_AllocRegVar (CurrentFunc, Param->Type); /* Could we allocate a register? */ if (Reg < 0) { /* No register available: Convert parameter to auto */ CvtRegVarToAuto (Param); } else { /* Remember the register offset */ Param->V.R.RegOffs = Reg; /* Generate swap code */ g_swap_regvars (Param->V.R.SaveOffs, Reg, CheckedSizeOf (Param->Type)); } } /* Next parameter */ Param = Param->NextSym; } /* Need a starting curly brace */ ConsumeLCurly (); /* Parse local variable declarations if any */ DeclareLocals (); /* Remember the current stack pointer. All variables allocated elsewhere * must be dropped when doing a return from an inner block. */ CurrentFunc->TopLevelSP = StackPtr; /* Now process statements in this block */ while (CurTok.Tok != TOK_RCURLY && CurTok.Tok != TOK_CEOF) { Statement (0); } /* If this is not a void function, and not the main function in a C99 * environment returning int, output a warning if we didn't see a return * statement. */ if (!F_HasVoidReturn (CurrentFunc) && !F_HasReturn (CurrentFunc) && !C99MainFunc) { Warning ("Control reaches end of non-void function"); } /* If this is the main function in a C99 environment returning an int, let * it always return zero. Note: Actual return statements jump to the return * label defined below. * The code is removed by the optimizer if unused. */ if (C99MainFunc) { g_getimmed (CF_INT | CF_CONST, 0, 0); } /* Output the function exit code label */ g_defcodelabel (F_GetRetLab (CurrentFunc)); /* Restore the register variables */ F_RestoreRegVars (CurrentFunc); /* Generate the exit code */ g_leave (); /* Emit references to imports/exports */ EmitExternals (); /* Emit function debug info */ F_EmitDebugInfo (); EmitDebugInfo (); /* Leave the lexical level */ LeaveFunctionLevel (); /* Eat the closing brace */ ConsumeRCurly (); /* Restore the old literal pool, remembering the one for the function */ Func->V.F.LitPool = PopLiteralPool (); /* Switch back to the old segments */ PopSegments (); /* Reset the current function pointer */ FreeFunction (CurrentFunc); CurrentFunc = 0; }
// display the value and type of a given parameter template <typename T> void Display(T t) { std::cout << "Value[" << t << "] type[" << TypeOf(t) << "]" << std::endl; }
QString SearchTerm::ToSql() const { QString col = FieldColumnName(field_); QString date = DateName(date_, true); QString value = value_.toString(); value.replace('\'', "''"); QString second_value; bool special_date_query = (operator_ == SearchTerm::Op_NumericDate || operator_ == SearchTerm::Op_NumericDateNot || operator_ == SearchTerm::Op_RelativeDate); // Floating point problems... // Theoretically 0.0 == 0 stars, 0.1 == 0.5 star, 0.2 == 1 star etc. // but in reality we need to consider anything from [0.05, 0.15) range // to be 0.5 star etc. // To make this simple, I transform the ranges to integeres and then // operate on ints: [0.0, 0.05) -> 0, [0.05, 0.15) -> 1 etc. if (TypeOf(field_) == Type_Rating) { col = "CAST ((" + col + " + 0.05) * 10 AS INTEGER)"; value = "CAST ((" + value + " + 0.05) * 10 AS INTEGER)"; } else if (TypeOf(field_) == Type_Date) { if (!special_date_query) { // We have the exact date // The calendar widget specifies no time so ditch the possible time part // from integers representing the dates. col = "DATE(" + col + ", 'unixepoch', 'localtime')"; value = "DATE(" + value + ", 'unixepoch', 'localtime')"; } else { // We have a numeric date, consider also the time for more precision col = "DATETIME(" + col + ", 'unixepoch', 'localtime')"; second_value = second_value_.toString(); second_value.replace('\'', "''"); if (date == "weeks") { // Sqlite doesn't know weeks, transform them to days date = "days"; value = QString::number(value_.toInt()*7); second_value = QString::number(second_value_.toInt()*7); } } } else if (TypeOf(field_) == Type_Time) { // Convert seconds to nanoseconds value = "CAST (" + value + " *1000000000 AS INTEGER)"; } switch (operator_) { case Op_Contains: return col + " LIKE '%" + value + "%'"; case Op_NotContains: return col + " NOT LIKE '%" + value + "%'"; case Op_StartsWith: return col + " LIKE '" + value + "%'"; case Op_EndsWith: return col + " LIKE '%" + value + "'"; case Op_Equals: if (TypeOf(field_) == Type_Text) return col + " LIKE '" + value + "'"; else if (TypeOf(field_) == Type_Rating || TypeOf(field_) == Type_Date || TypeOf(field_) == Type_Time) return col + " = " + value; else return col + " = '" + value + "'"; case Op_GreaterThan: if (TypeOf(field_) == Type_Rating || TypeOf(field_) == Type_Date || TypeOf(field_) == Type_Time) return col + " > " + value; else return col + " > '" + value + "'"; case Op_LessThan: if (TypeOf(field_) == Type_Rating || TypeOf(field_) == Type_Date || TypeOf(field_) == Type_Time) return col + " < " + value; else return col + " < '" + value + "'"; case Op_NumericDate: return col + " > " + "DATETIME('now', '-" + value + " " + date +"', 'localtime')"; case Op_NumericDateNot: return col + " < " + "DATETIME('now', '-" + value + " " + date +"', 'localtime')"; case Op_RelativeDate: // Consider the time range before the first date but after the second one return "(" + col + " < " + "DATETIME('now', '-" + value + " " + date +"', 'localtime') AND " + col + " > " + "DATETIME('now', '-" + second_value + " " + date +"', 'localtime'))"; case Op_NotEquals: if (TypeOf(field_) == Type_Text) { return col + " <> '" + value + "'"; } else { return col + " <> " + value; } } return QString(); }
static void DoConversion (ExprDesc* Expr, const Type* NewType) /* Emit code to convert the given expression to a new type. */ { Type* OldType; unsigned OldSize; unsigned NewSize; /* Remember the old type */ OldType = Expr->Type; /* If we're converting to void, we're done. Note: This does also cover a * conversion void -> void. */ if (IsTypeVoid (NewType)) { ED_MakeRVal (Expr); /* Never an lvalue */ goto ExitPoint; } /* Don't allow casts from void to something else. */ if (IsTypeVoid (OldType)) { Error ("Cannot convert from `void' to something else"); goto ExitPoint; } /* Get the sizes of the types. Since we've excluded void types, checking * for known sizes makes sense here. */ OldSize = CheckedSizeOf (OldType); NewSize = CheckedSizeOf (NewType); /* lvalue? */ if (ED_IsLVal (Expr)) { /* We have an lvalue. If the new size is smaller than the new one, * we don't need to do anything. The compiler will generate code * to load only the portion of the value that is actually needed. * This works only on a little endian architecture, but that's * what we support. * If both sizes are equal, do also leave the value alone. * If the new size is larger, we must convert the value. */ if (NewSize > OldSize) { /* Load the value into the primary */ LoadExpr (CF_NONE, Expr); /* Emit typecast code */ g_typecast (TypeOf (NewType), TypeOf (OldType) | CF_FORCECHAR); /* Value is now in primary and an rvalue */ ED_MakeRValExpr (Expr); } } else if (ED_IsLocAbs (Expr)) { /* A cast of a constant numeric value to another type. Be sure * to handle sign extension correctly. */ /* Get the current and new size of the value */ unsigned OldBits = OldSize * 8; unsigned NewBits = NewSize * 8; /* Check if the new datatype will have a smaller range. If it * has a larger range, things are ok, since the value is * internally already represented by a long. */ if (NewBits <= OldBits) { /* Cut the value to the new size */ Expr->IVal &= (0xFFFFFFFFUL >> (32 - NewBits)); /* If the new type is signed, sign extend the value */ if (IsSignSigned (NewType)) { if (Expr->IVal & (0x01UL << (NewBits-1))) { /* Beware: Use the safe shift routine here. */ Expr->IVal |= shl_l (~0UL, NewBits); } } } } else {
void LoadExpr (unsigned Flags, struct ExprDesc* Expr) /* Load an expression into the primary register if it is not already there. */ { if (ED_IsLVal (Expr)) { /* Dereferenced lvalue. If this is a bit field its type is unsigned. * But if the field is completely contained in the lower byte, we will * throw away the high byte anyway and may therefore load just the * low byte. */ if (ED_IsBitField (Expr)) { Flags |= (Expr->BitOffs + Expr->BitWidth <= CHAR_BITS)? CF_CHAR : CF_INT; Flags |= CF_UNSIGNED; } else { Flags |= TypeOf (Expr->Type); } if (ED_NeedsTest (Expr)) { Flags |= CF_TEST; } switch (ED_GetLoc (Expr)) { case E_LOC_ABS: /* Absolute: numeric address or const */ g_getstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0); break; case E_LOC_GLOBAL: /* Global variable */ g_getstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static variable or literal in the literal pool */ g_getstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal); break; case E_LOC_REGISTER: /* Register variable */ g_getstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal); break; case E_LOC_STACK: /* Value on the stack */ g_getlocal (Flags, Expr->IVal); break; case E_LOC_PRIMARY: /* The primary register - just test if necessary */ if (Flags & CF_TEST) { g_test (Flags); } break; case E_LOC_EXPR: /* Reference to address in primary with offset in Expr */ g_getind (Flags, Expr->IVal); break; default: Internal ("Invalid location in LoadExpr: 0x%04X", ED_GetLoc (Expr)); } /* Handle bit fields. The actual type may have been casted or * converted, so be sure to always use unsigned ints for the * operations. */ if (ED_IsBitField (Expr)) { unsigned F = CF_INT | CF_UNSIGNED | CF_CONST | (Flags & CF_TEST); /* Shift right by the bit offset */ g_asr (F, Expr->BitOffs); /* And by the width if the field doesn't end on an int boundary */ if (Expr->BitOffs + Expr->BitWidth != CHAR_BITS && Expr->BitOffs + Expr->BitWidth != INT_BITS) { g_and (F, (0x0001U << Expr->BitWidth) - 1U); } } /* Expression was tested */ ED_TestDone (Expr); } else { /* An rvalue */ if (ED_IsLocExpr (Expr)) { if (Expr->IVal != 0) { /* We have an expression in the primary plus a constant * offset. Adjust the value in the primary accordingly. */ Flags |= TypeOf (Expr->Type); g_inc (Flags | CF_CONST, Expr->IVal); } } else { /* Constant of some sort, load it into the primary */ LoadConstant (Flags, Expr); } /* Are we testing this value? */ if (ED_NeedsTest (Expr)) { /* Yes, force a test */ Flags |= TypeOf (Expr->Type); g_test (Flags); ED_TestDone (Expr); } } }
const Type* SpriteViewer::GetViewingObjectType() const { return &TypeOf(Sprite); }
SpriteViewer::SpriteViewer() { PushScopeEnterOnStack scope; auto layout = mnew VerticalLayout(); layout->borderTop = 5; layout->expandWidth = true; layout->expandHeight = false; layout->fitByChildren = true; mViewWidget = layout; auto commonFieldsLayout = mnew VerticalLayout(); commonFieldsLayout->spacing = 5; commonFieldsLayout->expandWidth = true; commonFieldsLayout->expandHeight = false; commonFieldsLayout->fitByChildren = true; layout->AddChild(commonFieldsLayout); const Type& spriteType = TypeOf(Sprite); mImageProperty = dynamic_cast<ImageAssetProperty*>( o2EditorProperties.BuildField(commonFieldsLayout, spriteType, "image", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); mSizePivotProperty = dynamic_cast<Vec2FProperty*>( o2EditorProperties.BuildField(commonFieldsLayout, spriteType, "szPivot", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); mPivotProperty = dynamic_cast<Vec2FProperty*>( o2EditorProperties.BuildField(commonFieldsLayout, spriteType, "pivot", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); mColorProperty = dynamic_cast<ColorProperty*>( o2EditorProperties.BuildField(commonFieldsLayout, spriteType, "color", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); mAlphaProperty = dynamic_cast<FloatProperty*>( o2EditorProperties.BuildField(commonFieldsLayout, spriteType, "transparency", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); mModeProperty = dynamic_cast<EnumProperty*>( o2EditorProperties.BuildField(commonFieldsLayout, spriteType, "mode", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); mModeProperty->onChanged += [&](IPropertyField* x) { OnModeSelected(); }; mHiddenProperties = o2UI.CreateWidget<VerticalLayout>(); mHiddenProperties->expandWidth = true; mHiddenProperties->expandHeight = false; mHiddenProperties->fitByChildren = true; layout->AddChild(mHiddenProperties); // Fill properties mFillPropertiesSpoiler = o2UI.CreateWidget<Spoiler>(); mHiddenProperties->AddChild(mFillPropertiesSpoiler); auto fillSpace = mnew Widget(); fillSpace->layout->minHeight = 5; mFillPropertiesSpoiler->AddChildWidget(fillSpace); mFillProperty = dynamic_cast<FloatProperty*>( o2EditorProperties.BuildField(mFillPropertiesSpoiler, spriteType, "fill", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); // Slice properties mSlicedPropertiesSpoiler = o2UI.CreateWidget<Spoiler>(); mHiddenProperties->AddChild(mSlicedPropertiesSpoiler); auto sliceSpace = mnew Widget(); sliceSpace->layout->minHeight = 5; mSlicedPropertiesSpoiler->AddChildWidget(sliceSpace); mSliceBorderProperty = dynamic_cast<BorderIProperty*>( o2EditorProperties.BuildField(mSlicedPropertiesSpoiler, spriteType, "sliceBorder", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); // Slice properties mTiledPropertiesSpoiler = o2UI.CreateWidget<Spoiler>(); mHiddenProperties->AddChild(mTiledPropertiesSpoiler); auto tiledSpace = mnew Widget(); tiledSpace->layout->minHeight = 5; mTiledPropertiesSpoiler->AddChildWidget(tiledSpace); mTileScaleProperty = dynamic_cast<FloatProperty*>( o2EditorProperties.BuildField(mTiledPropertiesSpoiler, spriteType, "tileScale", "", mFieldProperties, mOnChildFieldChangeCompleted, onChanged)); }
const Type* Asset::IMetaInfo::GetAssetType() const { return &TypeOf(Asset); }
Vector<const Type*> FolderAssetConverter::GetProcessingAssetsTypes() const { Vector<const Type*> res; res.Add(&TypeOf(FolderAsset)); return res; }
const Type& AssetRef::GetAssetType() const { return TypeOf(Asset); }
std::string CInternalFilesZFXY::GetType() { return TypeOf(); }