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 ) );
}
