void FieldOp( TYPE typ1, TYPE typ2, OPTR op ) { //================================================ // Generate code for a field selection operator. typ1 = typ1; op = op; PushOpn( CITNode->link ); PushOpn( CITNode ); if( CITNode->opn.us & USOPN_FLD ) { // sub-field reference EmitOp( FC_ADD ); DumpTypes( FT_INTEGER, TypeSize( FT_INTEGER ), FT_INTEGER, TypeSize( FT_INTEGER ) ); } else { EmitOp( FC_FIELD_OP ); OutPtr( CITNode->sym_ptr ); if( ( StmtSw & SS_DATA_INIT ) == 0 ) { if( typ2 == FT_CHAR ) { if( ( CITNode->link->opn.us & USOPN_WHAT ) != USOPN_ARR ) { if( ( ( CITNode->link->opn.us & USOPN_WHAT ) != USOPN_NWL ) && ( ( CITNode->link->opn.us & USOPN_WHAT ) != USOPN_ASS ) ) { GFieldSCB( CITNode->link->size ); } EmitOp( FC_MAKE_SCB ); OutPtr( GTempString( 0 ) ); } } } else { OutPtr( CITNode->link->sym_ptr ); } } }
static cmp_type CompatibleType( TYPEPTR typ1, TYPEPTR typ2, bool assignment, bool null_ptr ) { cmp_type ret_val; cmp_type ret_pq; type_modifiers typ1_flags, typ2_flags; int ptr_indir_level; ptr_indir_level = 0; typ1_flags = FLAG_NONE; typ2_flags = FLAG_NONE; ret_pq = OK; typ1 = SkipTypeFluff( typ1 ); // skip typedefs go into enums base typ2 = SkipTypeFluff( typ2 ); if( typ1->decl_type == TYPE_POINTER && typ2->decl_type == TYPE_POINTER ) { // top level pointer typ1_flags = typ1->u.p.decl_flags; typ2_flags = typ2->u.p.decl_flags; // Special dispensation: assigning null pointer constant is allowed even // when the pointer size doesn't match. Required for MS compatibility. if( assignment && !null_ptr ) { type_modifiers subnot; subnot = SUBNOT( typ1_flags, typ2_flags, MASK_QUALIFIERS ); if( subnot ) { // allow void * = unaligned * if( subnot & (MASK_QUALIFIERS & ~FLAG_UNALIGNED) ) { ret_pq = PQ; } else if( subnot & FLAG_UNALIGNED) { align_type align1; align1 = GetTypeAlignment( typ1->object ); if( align1 > 1 ) { ret_pq = PQ; } } } if( (typ1_flags & MASK_ALL_MEM_MODELS) != (typ2_flags & MASK_ALL_MEM_MODELS) ) { target_size size1, size2; size1 = TypeSize( typ1 ); size2 = TypeSize( typ2 ); if( size1 < size2 ) { ret_pq = PT; } else if( size1 > size2 ) { ret_pq = PX; } } } typ1 = typ1->object; typ2 = typ2->object; ++ptr_indir_level; } ret_val = DoCompatibleType( typ1, typ2, ptr_indir_level ); if( ret_val == OK ) { ret_val = ret_pq; } return( ret_val ); }
IFF IFSpecific( TYPE typ ) { //============================== IFF func; IFF magic; sym_id sym; magic = 0; func = CITNode->sym_ptr->ns.si.fi.index; if( IFFlags[ func ].next == MAGIC ) { magic = MAGIC; } else if( IFFlags[ func ].flags & IF_GENERIC ) { for( ; IFFlags[ func ].arg_typ != typ; ) { func = IFFlags[ func ].next; if( func == IF_NO_MORE ) { TypeErr( LI_NO_SPECIFIC, typ ); return( magic ); } } sym = IFSymLookup( IFNames[ func ], strlen( IFNames[ func ] ) ); typ = IFFlags[ func ].ret_typ; // merge flags - don't assign them from CITNode->sym_ptr->ns.flags // since SY_IF_ARGUMENT may be set in sym->flags // Consider: DOUBLE PRECISION X // INTRINSIC DSIN // CALL F( DSIN ) // PRINT *, SIN( X ) // when we process SIN( X ), the specific function DSIN already // has SY_IF_ARGUMENT set sym->ns.flags |= CITNode->sym_ptr->ns.flags | SY_REFERENCED; sym->ns.u1.s.typ = typ; sym->ns.xt.size = TypeSize( typ ); sym->ns.si.fi.index = func; CITNode->sym_ptr = sym; if( IFFlags[ func ].flags & IF_IN_LINE ) { magic = MAGIC; } else { MarkIFUsed( func ); } } else if( IFFlags[ func ].flags & IF_IN_LINE ) { magic = MAGIC; } else { MarkIFUsed( func ); } typ = IFFlags[ func ].ret_typ; CITNode->typ = typ; CITNode->size = TypeSize( typ ); return( magic ); }
static dw_handle BIMakeFundamental( TYPE typ ) { //============================================= // create a new fundamental handle seperate from the one created at birth return( DWFundamental(cBIId, TypeKW(typ), BIMapType(typ), TypeSize(typ)) ); }
call_handle InitInlineCall( int rtn_id ) { //============================================ // Initialize a call to a runtime routine. #if _CPU == 386 || _CPU == 8086 sym_id sym; inline_rtn __FAR *in_entry; uint name_len; if( !CreatedPragmas ) { InitInlinePragmas(); } in_entry = &InlineTab[ rtn_id ]; sym = in_entry->sym_ptr; if( sym == NULL ) { name_len = strlen( in_entry->name ); strcpy( SymBuff, in_entry->name ); sym = STAdd( SymBuff, name_len ); sym->u.ns.flags = SY_USAGE | SY_TYPE | SY_SUBPROGRAM | SY_FUNCTION; sym->u.ns.u1.s.typ = FT_INTEGER_TARG; sym->u.ns.xt.size = TypeSize( sym->u.ns.u1.s.typ ); sym->u.ns.u3.address = NULL; in_entry->sym_ptr = sym; in_entry->aux = AuxLookupName( in_entry->name, name_len ); } return( CGInitCall( CGFEName( sym, in_entry->typ ), in_entry->typ, in_entry->sym_ptr ) ); #else rtn_id = rtn_id; return( 0 ); #endif }
/* Return the size of function parameters or -1 if size could * not be determined (symbol isn't a function or is variadic) */ static unsigned GetParmsSize( SYM_HANDLE sym_handle ) { unsigned total_parm_size = 0; unsigned parm_size; TYPEPTR fn_typ; TYPEPTR *parm_types; TYPEPTR typ; SYM_ENTRY sym; SymGet( &sym, sym_handle ); fn_typ = sym.sym_type; SKIP_TYPEDEFS( fn_typ ); if( fn_typ->decl_type == TYPE_FUNCTION ) { if( fn_typ->u.fn.parms != NULL ) { for( parm_types = fn_typ->u.fn.parms; (typ = *parm_types) != NULL; ++parm_types ) { if( typ->decl_type == TYPE_DOT_DOT_DOT ) { total_parm_size = (unsigned)-1; break; } SKIP_TYPEDEFS( typ ); if( typ->decl_type == TYPE_VOID ) break; parm_size = _RoundUp( TypeSize( typ ), TARGET_INT ); total_parm_size += parm_size; } } } else { total_parm_size = (unsigned)-1; } return( total_parm_size ); }
static void MkConst( intstar4 number ) { //========================================== CITNode->value.intstar4 = number; CITNode->typ = FT_INTEGER; CITNode->size = TypeSize( FT_INTEGER ); CITNode->opn.us = USOPN_CON; }
void PushConst( intstar4 val ) { //================================= // Push an integer constant. EmitOp( FC_PUSH_CONST ); OutPtr( STConst( &val, FT_INTEGER, TypeSize( FT_INTEGER ) ) ); }
//---------------------------------------------------------------------------------------------- int ObjectSerializer::SerializeUserDefinedType(ISerializable *pObj, TypeNode* pType, bool isPtr, fstream& pen) { int size = 0; bool isNull = false; if (isPtr) { // Access the pointer pointed by the pointer to pointer pObj = (*(ISerializable**)pObj); int length = 0; string typeName; char buffer[MaxTypeNameLength + 1]; isNull = (NULL == pObj); pen.write(reinterpret_cast<char*>(&isNull), sizeof(bool)); if (!isNull) { auto objLayout = pObj->GetObjectLayout(); typeName = g_ObjectFactory.FromCName(objLayout.CName()); PerformLateBinding(pObj, pType); length = typeName.size(); _ASSERTE(length <= MaxTypeNameLength); strcpy_s(buffer, typeName.c_str()); buffer[length] = 0; pen.write(buffer, MaxTypeNameLength + 1); Iterator* addresses = objLayout.GetIterator(); unsigned* addr32; for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx) { _ASSERTE(memberIdx < pType->Children.size()); addr32 = reinterpret_cast<unsigned*>(addresses->Current()); SerializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, pen); } } size = sizeof(unsigned); } else { auto objLayout = pObj->GetObjectLayout(); Iterator* addresses = objLayout.GetIterator(); unsigned* addr32; for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx) { _ASSERTE(memberIdx < pType->Children.size()); addr32 = reinterpret_cast<unsigned*>(addresses->Current()); SerializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, pen); } size = objLayout.TypeSize(); } return size; }
void GNullRetIdx( void ) { //===================== // No alternate return. PushConst( 0 ); EmitOp( FC_ASSIGN_ALT_RET ); DumpType( FT_INTEGER, TypeSize( FT_INTEGER ) ); }
/* allocate a value given its type */ struct Value *VariableAllocValueFromType(struct ParseState *Parser, struct ValueType *Typ, int IsLValue, struct Value *LValueFrom, int OnHeap) { int Size = TypeSize(Typ, Typ->ArraySize, FALSE); struct Value *NewValue = VariableAllocValueAndData(Parser, Size, IsLValue, LValueFrom, OnHeap); assert(Size > 0 || Typ == &VoidType); NewValue->Typ = Typ; return NewValue; }
//---------------------------------------------------------------------------------------------- int ObjectSerializer::DeserializeUserDefinedType(ISerializable* pMem, TypeNode* pType, bool isPtr, fstream& eye) { int size = 0; ISerializable* pObj = NULL; bool isNull = false; if (isPtr) { unsigned* addr32; eye.read(reinterpret_cast<char*>(&isNull), sizeof(bool)); addr32 = reinterpret_cast<unsigned*>(pMem); if (!isNull) { string typeName; char buffer[MaxTypeNameLength + 1]; eye.read(buffer, MaxTypeNameLength + 1); typeName = buffer; pObj = static_cast<ISerializable*>(g_ObjectFactory.Create(typeName)); PerformLateBinding(pObj, pType); auto objLayout = pObj->GetObjectLayout(); Iterator* addresses = objLayout.GetIterator(); unsigned* addr32; for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx) { _ASSERTE(memberIdx < pType->Children.size()); addr32 = reinterpret_cast<unsigned*>(addresses->Current()); DeserializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, eye); } } *addr32 = reinterpret_cast<unsigned>(pObj); size = sizeof(unsigned); } else { pObj = reinterpret_cast<ISerializable*>(pMem); auto objLayout = pObj->GetObjectLayout(); Iterator* addresses = objLayout.GetIterator(); unsigned* addr32; for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx) { _ASSERTE(memberIdx < pType->Children.size()); addr32 = reinterpret_cast<unsigned*>(addresses->Current()); DeserializeType(reinterpret_cast<char*>(*addr32), pType->Children[memberIdx].Ptr32, eye); } size = objLayout.TypeSize(); } return size; }
uint32_t CalculateObjectSize(const VMValue object, uint8_t *memoryArea) { auto typeField = GetTypeField(object, memoryArea); if (IsArray(typeField)) { return AlignSize(GetArrayLengthUnchecked(object, memoryArea)*TypeSize(GetArrayValueType(typeField)) + ArrayHeaderSize()); } else { throw std::logic_error("Size calculation not implemented for non-arrays"); } }
void CpIntrinsic(void) { //===================== // Compile INTRINSIC statement. // INTRINSIC FUNC {,FUNC1} . . . unsigned_16 flags; IFF func; sym_id sym_ptr; TYPE func_typ; for(;;) { if( ReqName( NAME_INTRINSIC ) ) { func = IFLookUp(); if( func > 0 ) { func_typ = IFType( func ); sym_ptr = LkSym(); flags = sym_ptr->u.ns.flags; if( ( flags & SY_USAGE ) != 0 ) { if( ( flags & SY_CLASS ) == SY_SUBPROGRAM ) { if( ( flags & SY_INTRINSIC ) != 0 ) { Error( SR_PREV_INTRNSC ); } else if( ( flags & SY_EXTERNAL ) != 0 ) { Error( SR_INTRNSC_EXTRN ); } } else { IllName( sym_ptr ); } } else if( flags & ERR_MASK ) { IllName( sym_ptr ); } else if( ( flags & SY_TYPE ) && ( sym_ptr->u.ns.u1.s.typ != func_typ ) ) { NameTypeErr( TY_TYP_PREV_DEF, sym_ptr ); } else { // we must OR the flags since SY_TYPE and/or SY_REFERENCED // bit might already be set in the symbol table sym_ptr->u.ns.flags |= SY_USAGE | SY_SUBPROGRAM | SY_FUNCTION | SY_INTRINSIC; func_typ = IFType( func ); sym_ptr->u.ns.u1.s.typ = func_typ; sym_ptr->u.ns.xt.size = TypeSize( func_typ ); sym_ptr->u.ns.si.fi.index = func; } } else { Error( SR_NOT_INTRNSC ); } } AdvanceITPtr(); if( !RecComma() ) { break; } } ReqEOS(); }
static void ExpOp( TYPE typ1, TYPE typ2, OPTR op ) { //====================================================== op = op; if( !_IsTypeInteger( typ2 ) ) { Convert(); GenExp( ResultType ); } else { CnvTo( CITNode, ResultType, TypeSize( ResultType ) ); ExpI( typ1, &CITNode->value, ITIntValue( CITNode->link ) ); } }
local void FuncDefn( SYMPTR sym ) { SYM_NAMEPTR sym_name; int sym_len; TYPEPTR typ; /* duplicate name in near space */ sym_name = SymName( sym, CurFuncHandle ); sym_len = far_strlen_plus1( sym_name ); sym->name = CMemAlloc( sym_len ); far_memcpy( sym->name, sym_name, sym_len ); if( sym->flags & SYM_DEFINED ) { CErr2p( ERR_SYM_ALREADY_DEFINED, sym->name ); /* 03-aug-88 */ } typ = sym->sym_type->object; /* get return type */ SKIP_TYPEDEFS( typ ); if( typ->decl_type != TYPE_VOID ) { /* 26-mar-91 */ if( TypeSize( typ ) == 0 ) { CErr( ERR_INCOMPLETE_TYPE, sym_name ); } } sym->flags |= /*SYM_REFERENCED | 18-jan-89 */ SYM_DEFINED; if( !(GenSwitches & NO_OPTIMIZATION) ) { sym->flags |= SYM_OK_TO_RECURSE; /* 25-sep-91 */ } if( sym->stg_class == SC_EXTERN || sym->stg_class == SC_FORWARD ) { sym->stg_class = SC_NULL; /* indicate exported function */ } CompFlags.external_defn_found = 1; if( Toggles & TOGGLE_CHECK_STACK ) sym->flags |= SYM_CHECK_STACK; if( !CompFlags.zu_switch_used ) { if( (sym->attrib & FLAG_INTERRUPT) == FLAG_INTERRUPT ) { /* interrupt function */ TargetSwitches |= FLOATING_SS; /* force -zu switch on */ } else { TargetSwitches &= ~FLOATING_SS; /* turn it back off */ } } if( strcmp( CurFunc->name, "main" ) == 0 || strcmp( CurFunc->name, "wmain" ) == 0 ) { sym->attrib &= ~FLAG_LANGUAGES; // Turn off any language flags sym->attrib |= LANG_WATCALL; // Turn on __watcall calling convention for main } SymReplace( sym, CurFuncHandle ); }
static void FuncDefn( SYMPTR sym ) { SYM_NAMEPTR sym_name; size_t sym_len; TYPEPTR typ; /* duplicate name in near space */ sym_name = SymName( sym, CurFuncHandle ); sym_len = strlen( sym_name ) + 1; sym->name = CMemAlloc( sym_len ); memcpy( sym->name, sym_name, sym_len ); if( sym->flags & SYM_DEFINED ) { CErr2p( ERR_SYM_ALREADY_DEFINED, sym->name ); } typ = sym->sym_type->object; /* get return type */ SKIP_TYPEDEFS( typ ); if( typ->decl_type != TYPE_VOID ) { if( TypeSize( typ ) == 0 ) { CErr2p( ERR_INCOMPLETE_TYPE, sym_name ); } } sym->flags |= SYM_DEFINED /* | SYM_REFERENCED */; if( (GenSwitches & NO_OPTIMIZATION) == 0 ) { sym->flags |= SYM_OK_TO_RECURSE; } if( sym->attribs.stg_class == SC_EXTERN || sym->attribs.stg_class == SC_FORWARD ) { sym->attribs.stg_class = SC_NONE; /* indicate exported function */ } CompFlags.external_defn_found = 1; if( Toggles & TOGGLE_CHECK_STACK ) sym->flags |= SYM_CHECK_STACK; if( !CompFlags.zu_switch_used ) { if( (sym->mods & FLAG_INTERRUPT) == FLAG_INTERRUPT ) { /* interrupt function */ TargetSwitches |= FLOATING_SS; /* force -zu switch on */ } else { TargetSwitches &= ~FLOATING_SS; /* turn it back off */ } } if( CMPLIT( CurFunc->name, "main" ) == 0 || CMPLIT( CurFunc->name, "wmain" ) == 0 ) { sym->mods &= ~MASK_LANGUAGES; // Turn off any language flags sym->mods |= LANG_WATCALL; // Turn on __watcall calling convention for main } SymReplace( sym, CurFuncHandle ); }
local void InitArray( TYPEPTR typ, TYPEPTR ctyp ) { unsigned long n; unsigned long m; unsigned long *pm; unsigned long array_size; unsigned long elem_size; array_size = TypeSize( typ ); n = 0; pm = &m; for( ;; ) { m = n; pm = DesignatedInit( typ, ctyp, pm ); if( pm == NULL ) break; if( m != n ) { elem_size = SizeOfArg( typ->object ); if( typ->u.array->unspecified_dim && m > array_size ) { RelSeekBytes( ( array_size - n ) * elem_size ); ZeroBytes( (m - array_size) * elem_size ); } else { RelSeekBytes( ( m - n ) * elem_size ); } n = m; } n++; if( n > array_size ) { if( !typ->u.array->unspecified_dim ) break; array_size = n; /* clear out the new element just in case */ elem_size = SizeOfArg( typ->object ); ZeroBytes( elem_size ); RelSeekBytes( -elem_size ); } InitSymData( typ->object, ctyp, 1 ); if( CurToken == T_EOF ) break; if( CurToken == T_RIGHT_BRACE ) break; if( DesignatedInSubAggregate( typ->object->decl_type ) ) continue; if( n < array_size || typ == ctyp || typ->u.array->unspecified_dim ) { MustRecog( T_COMMA ); } if( CurToken == T_RIGHT_BRACE ) break; } if( typ->u.array->unspecified_dim ) { typ->u.array->dimension = array_size; } if( array_size > n ) { RelSeekBytes( ( array_size - n ) * SizeOfArg( typ->object ) ); } }
static bool DoGenerate( TYPE typ1, TYPE typ2, uint *res_size ) { //================================================================ if( CITNode->link->opr == OPR_EQU ) { ResultType = typ1; *res_size = CITNode->size; if( (ASType & AST_ASF) || CkAssignOk() ) return( true ); return( false ); } else { if( ( ( typ1 == FT_DOUBLE ) && ( typ2 == FT_COMPLEX ) ) || ( ( typ2 == FT_DOUBLE ) && ( typ1 == FT_COMPLEX ) ) ) { ResultType = FT_DCOMPLEX; *res_size = TypeSize( FT_DCOMPLEX ); Extension( MD_DBLE_WITH_CMPLX ); } else if( ( ( typ1 == FT_TRUE_EXTENDED ) && ( typ2 == FT_COMPLEX ) ) || ( ( typ2 == FT_TRUE_EXTENDED ) && ( typ1 == FT_COMPLEX ) ) || ( ( typ1 == FT_TRUE_EXTENDED ) && ( typ2 == FT_DCOMPLEX ) ) || ( ( typ2 == FT_TRUE_EXTENDED ) && ( typ1 == FT_DCOMPLEX ) ) ) { ResultType = FT_XCOMPLEX; *res_size = TypeSize( FT_XCOMPLEX ); Extension( MD_DBLE_WITH_CMPLX ); } else if( ( typ2 > typ1 ) || ( typ1 == FT_STRUCTURE ) || ( typ1 == FT_NO_TYPE ) ) { ResultType = typ2; *res_size = TypeSize( typ2 ); } else { ResultType = typ1; if( _IsTypeInteger( ResultType ) ) { *res_size = CITNode->size; if( *res_size < CITNode->link->size ) { *res_size = CITNode->link->size; } } else *res_size = TypeSize( typ1 ); } return( true ); } }
//---------------------------------------------------------------------------------------------- int ObjectSerializer::DeserializePair(ISerializable* pObj, TypeNode* pType, fstream& eye) { // Pointer to pair is not supported _ASSERTE(pType->Indirection == false); auto objLayout = pObj->GetObjectLayout(); Iterator* addresses = objLayout.GetIterator(); unsigned* addr32; for (int memberIdx = 0; addresses->MoveNext(); ++memberIdx) { addr32 = reinterpret_cast<unsigned*>(addresses->Current()); DeserializeType(reinterpret_cast<char*>(*addr32), pType->TemplateArguments[memberIdx], eye); } return objLayout.TypeSize(); }
sym_id STShadow( sym_id sym ) { //================================ // Shadow the given symbol. sym_id shadow; if( StmtSw & SS_DATA_INIT ) { // implied do parm shadow = TmpVar( FT_INTEGER, TypeSize( FT_INTEGER ) ); } else { shadow = StaticAlloc( sym->ns.xt.size, sym->ns.u1.s.typ ); } shadow->ns.flags |= SY_SPECIAL_PARM; sym->ns.flags |= SY_SPECIAL_PARM; shadow->ns.si.ms.sym = sym; return( shadow ); }
static void BinOp( TYPE typ1, TYPE typ2, OPTR op ) { //=================================================== byte index; typ2 = typ2; op -= OPTR_FIRST_ARITHOP; index = ResultType - FT_INTEGER_1; if( typ1 != FT_NO_TYPE ) { Convert(); XArithTab[ index * AR_TAB_COLS + op ] ( &CITNode->value, &CITNode->link->value ); } else { CnvTo( CITNode->link , ResultType, TypeSize( ResultType ) ); XUArithTab[ index * UAR_TAB_COLS + op ] ( &CITNode->value, &CITNode->link->value ); CITNode->opn.us = USOPN_CON; } }
//---------------------------------------------------------------------------------------------- int ObjectSerializer::SerializeContainerSet(ISerializable* pObj, TypeNode* pType, fstream& pen) { // Pointer to set is not supported _ASSERTE(pType->Indirection == false); _ASSERTE(pType->TemplateArguments.size() == 1); auto objLayout = pObj->GetObjectLayout(); IContainer* pContainer = dynamic_cast<IContainer*>(pObj); _ASSERTE(pContainer); Iterator* itr = objLayout.GetIterator(); int count = pContainer->ContainerCount(); pen.write(reinterpret_cast<char*>(&count), sizeof(int)); while (itr->MoveNext()) { SerializeType(itr->Current(), pType->TemplateArguments[0], pen); } return objLayout.TypeSize(); }
static void CkIntrinsic( void ) { //============================= // Check for intrinsic functions. // // CASE 1: integer abs // y == abs( -1.0 ) -- this should call generic i.f. abs // // CASE 2: real iabs // y == iabs( -1 ) -- this should give type mismatch error // sym_id sym_ptr; TYPE typ; IFF func; sym_ptr = CITNode->sym_ptr; if( ( CITNode->flags & SY_SUB_PARM ) == 0 ) { typ = CITNode->typ; func = IFLookUp(); if( func > 0 ) { sym_ptr->ns.si.fi.index = func; if( func == IF_ISIZEOF ) { ASType |= AST_ISIZEOF; } sym_ptr->ns.si.fi.num_args = 0; CITNode->flags |= SY_INTRINSIC; IFChkExtension( func ); if( !IFIsGeneric( func ) ) { CITNode->typ = IFType( func ); CITNode->size = TypeSize( CITNode->typ ); sym_ptr->ns.typ = CITNode->typ; sym_ptr->ns.xt.size = CITNode->size; if( ( CITNode->typ != typ ) && ( CITNode->flags & SY_TYPE ) ) { Error( LI_WRONG_TYPE ); } } } } }
void GDataItem( itnode *rpt ) { //================================ // Generate a data item. sym_id data; intstar4 one; if( rpt == NULL ) { one = 1; data = STConst( &one, FT_INTEGER, TypeSize( FT_INTEGER ) ); } else { data = rpt->sym_ptr; } OutPtr( data ); if( CITNode->typ == FT_HEX ) { OutU16( PT_NOTYPE ); } else { GenType( CITNode ); } OutPtr( CITNode->sym_ptr ); }
static void HighColon( void ) { //================================= // must be high bound if( CITNode->opn.ds == DSOPN_PHI ) { // we don't know have access to the symbol table // entry so we can't compute the size CITNode->opn.us = USOPN_SSR; CITNode->typ = FT_INTEGER; CITNode->size = TypeSize( FT_INTEGER ); } else if( SimpleScript( CITNode ) && ( (BkLink->opr == OPR_FBR) || (BkLink->opr == OPR_LBR) ) ) { int ch_size; ch_size = SameScripts( BkLink, CITNode ); if( ch_size > 0 ) { // The size no longer has to be optimal, only constant CITNode->value.st.ss_size = ch_size; CITNode->opn.us |= USOPN_SS1; } } PrepArg(); }
//---------------------------------------------------------------------------------------------- int ObjectSerializer::DeserializeContainerSet(ISerializable* pMem, TypeNode* pType, fstream& eye) { // Pointer to set is not supported _ASSERTE(pType->Indirection == false); auto objLayout = pMem->GetObjectLayout(); IContainer* pContainer = dynamic_cast<IContainer*>(pMem); _ASSERTE(pContainer); int count; eye.read(reinterpret_cast<char*>(&count), sizeof(int)); pContainer->Clear(); char* tempStorage0 = pContainer->GetTemp(); for (int i = 0; i < count; ++i) { DeserializeType(tempStorage0, pType->TemplateArguments[0], eye); pContainer->AddTemp(); } return objLayout.TypeSize(); }
call_handle InitCall( RTCODE rtn_id ) { //====================================== // Initialize a call to a runtime routine. sym_id sym; rt_rtn __FAR *rt_entry; byte typ; int name_len; char __FAR *ptr; rt_entry = &RtnTab[ rtn_id ]; sym = rt_entry->sym_ptr; if( sym == NULL ) { name_len = 0; ptr = rt_entry->name; while( *ptr != NULLCHAR ) { SymBuff[ name_len ] = *ptr; ++name_len; ++ptr; } sym = STAdd( SymBuff, name_len ); sym->u.ns.flags = SY_USAGE | SY_TYPE | SY_SUBPROGRAM | SY_FUNCTION | SY_RT_ROUTINE; if( rt_entry->typ == FT_NO_TYPE ) { sym->u.ns.u1.s.typ = FT_INTEGER_TARG; } else { sym->u.ns.u1.s.typ = rt_entry->typ; } sym->u.ns.xt.size = TypeSize( sym->u.ns.u1.s.typ ); sym->u.ns.u3.address = NULL; sym->u.ns.si.sp.u.imp_segid = AllocImpSegId(); rt_entry->sym_ptr = sym; } typ = F772CGType( sym ); return( CGInitCall( CGFEName( sym, typ ), typ, rt_entry->sym_ptr ) ); }
/* parse an array initialiser and assign to a variable */ int ParseArrayInitialiser(struct ParseState *Parser, struct Value *NewVariable, int DoAssignment) { int ArrayIndex = 0; enum LexToken Token; struct Value *CValue; /* count the number of elements in the array */ if (DoAssignment && Parser->Mode == RunModeRun) { struct ParseState CountParser; int NumElements; ParserCopy(&CountParser, Parser); NumElements = ParseArrayInitialiser(&CountParser, NewVariable, FALSE); if (NewVariable->Typ->Base != TypeArray) AssignFail(Parser, "%t from array initializer", NewVariable->Typ, NULL, 0, 0, NULL, 0); if (NewVariable->Typ->ArraySize == 0) { NewVariable->Typ = TypeGetMatching(Parser->pc, Parser, NewVariable->Typ->FromType, NewVariable->Typ->Base, NumElements, NewVariable->Typ->Identifier, TRUE); VariableRealloc(Parser, NewVariable, TypeSizeValue(NewVariable, FALSE)); } #ifdef DEBUG_ARRAY_INITIALIZER PRINT_SOURCE_POS; printf("array size: %d \n", NewVariable->Typ->ArraySize); #endif } /* parse the array initialiser */ Token = LexGetToken(Parser, NULL, FALSE); while (Token != TokenRightBrace) { if (LexGetToken(Parser, NULL, FALSE) == TokenLeftBrace) { /* this is a sub-array initialiser */ int SubArraySize = 0; struct Value *SubArray = NewVariable; if (Parser->Mode == RunModeRun && DoAssignment) { SubArraySize = TypeSize(NewVariable->Typ->FromType, NewVariable->Typ->FromType->ArraySize, TRUE); SubArray = VariableAllocValueFromExistingData(Parser, NewVariable->Typ->FromType, (union AnyValue *)(&NewVariable->Val->ArrayMem[0] + SubArraySize * ArrayIndex), TRUE, NewVariable); #ifdef DEBUG_ARRAY_INITIALIZER int FullArraySize = TypeSize(NewVariable->Typ, NewVariable->Typ->ArraySize, TRUE); PRINT_SOURCE_POS; PRINT_TYPE(NewVariable->Typ) printf("[%d] subarray size: %d (full: %d,%d) \n", ArrayIndex, SubArraySize, FullArraySize, NewVariable->Typ->ArraySize); #endif if (ArrayIndex >= NewVariable->Typ->ArraySize) ProgramFail(Parser, "too many array elements"); } LexGetToken(Parser, NULL, TRUE); ParseArrayInitialiser(Parser, SubArray, DoAssignment); } else { struct Value *ArrayElement = NULL; if (Parser->Mode == RunModeRun && DoAssignment) { struct ValueType * ElementType = NewVariable->Typ; int TotalSize = 1; int ElementSize = 0; /* int x[3][3] = {1,2,3,4} => handle it just like int x[9] = {1,2,3,4} */ while (ElementType->Base == TypeArray) { TotalSize *= ElementType->ArraySize; ElementType = ElementType->FromType; /* char x[10][10] = {"abc", "def"} => assign "abc" to x[0], "def" to x[1] etc */ if (LexGetToken(Parser, NULL, FALSE) == TokenStringConstant && ElementType->FromType->Base == TypeChar) break; } ElementSize = TypeSize(ElementType, ElementType->ArraySize, TRUE); #ifdef DEBUG_ARRAY_INITIALIZER PRINT_SOURCE_POS; printf("[%d/%d] element size: %d (x%d) \n", ArrayIndex, TotalSize, ElementSize, ElementType->ArraySize); #endif if (ArrayIndex >= TotalSize) ProgramFail(Parser, "too many array elements"); ArrayElement = VariableAllocValueFromExistingData(Parser, ElementType, (union AnyValue *)(&NewVariable->Val->ArrayMem[0] + ElementSize * ArrayIndex), TRUE, NewVariable); } /* this is a normal expression initialiser */ if (!ExpressionParse(Parser, &CValue)) ProgramFail(Parser, "expression expected"); if (Parser->Mode == RunModeRun && DoAssignment) { ExpressionAssign(Parser, ArrayElement, CValue, FALSE, NULL, 0, FALSE); VariableStackPop(Parser, CValue); VariableStackPop(Parser, ArrayElement); } } ArrayIndex++; Token = LexGetToken(Parser, NULL, FALSE); if (Token == TokenComma) { LexGetToken(Parser, NULL, TRUE); Token = LexGetToken(Parser, NULL, FALSE); } else if (Token != TokenRightBrace) ProgramFail(Parser, "comma expected"); } if (Token == TokenRightBrace) LexGetToken(Parser, NULL, TRUE); else ProgramFail(Parser, "'}' expected"); return ArrayIndex; }
static void Convert( void ) { //=============================== CnvTo( CITNode, ResultType, TypeSize( ResultType ) ); CnvTo( CITNode->link , ResultType, TypeSize( ResultType ) ); }