void    DtPushConst( void ) {
//=====================

// Push constant.

    DXPush( IntegerValue( GetPtr() ) );
}

void    DtFieldSubstring( void ) {
//==========================

// Data initialize a substring character item within a structure.

    sym_id      fd;
    intstar4    base;
    intstar4    first;
    intstar4    last;
    char        name[MAX_SYMLEN+1];

    base = DXPop();
    first = DXPop();
    fd = GetPtr();
    last = GetInt();
    if( last != 0 ) {
        last += first - 1;
    } else {
        last = DXPop();
    }
    GetU16(); // skip typing information
    if( DoSubstring( first, last, fd->u.fd.xt.size ) ) {
        DXPush( base + first - 1 );
        DtItemSize = last - first + 1;
    } else {
        STFieldName( fd, name );
        Error( EV_SSTR_INVALID, name, StmtKeywords[ PR_DATA ] );
    }
}

PIMAGE_NT_HEADERS32 
GetNTHeaders32(LPCVOID p, SIZE_T size)
{
	try
	{
		PIMAGE_NT_HEADERS32 nt;
		PIMAGE_DOS_HEADER dos;

		if(size < sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS))
			return NULL;
		
		dos = (PIMAGE_DOS_HEADER) p;
		if(dos->e_magic != IMAGE_DOS_SIGNATURE)
			return NULL;

		if(dos->e_lfanew + sizeof(IMAGE_NT_HEADERS) > size)
			return NULL;

		nt = (PIMAGE_NT_HEADERS32) GetPtr(dos, dos->e_lfanew);
		if(nt->Signature != IMAGE_NT_SIGNATURE)
			return NULL;

		if(nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
			return NULL;

		return nt;
	}
	catch(...)
	{
	}

	return NULL;
}

void    DtDataDoLoop( void ) {
//======================

// Process implied-DO for DATA statement.

    intstar4    e2;
    intstar4    e3;
    intstar4    iter_count;
    sym_id      do_var;
    obj_ptr     curr_fc;
    intstar4    e1;

    e3 = DXPop();
    e2 = DXPop();
    e1 = DXPop();
    do_var = GetPtr();
    do_var->u.ns.si.ms.u.value = &e1;
    iter_count = ( e2 - e1 + e3 ) / e3;
    curr_fc = FCodeTell( 0 );
    while( iter_count > 0 ) {
        FCodeSeek( curr_fc );
        FCodeSequence();
        *do_var->u.ns.si.ms.u.value += e3;
        iter_count--;
    }
}

void    DtInpStruct( void ) {
//=====================

// Initialize a struct.

    StructInit( ((sym_id)GetPtr())->u.sd.fl.sym_fields );
}

//----------------------------------------------------------
void TContainerRise::Append( int size, char* p )
{
  int oldSize = mSizeUse;
  int newSize = mSizeUse + size;
  Realloc( newSize );
  memcpy( GetPtr() + oldSize, p, size );
}

SReference& SReference::Cdr() const
{
    INTELIB_ASSERT(GetPtr(), IntelibX_unexpected_unbound_value());
    SExpressionCons *tp = DynamicCastGetPtr<SExpressionCons>();
    INTELIB_ASSERT(tp, IntelibX_not_a_cons(*this));
    return tp->Cdr();
}

PBYTE CInfoFishing::GetSendData(void)
{
	int i, nCount;
	PBYTE pData, pDataTmp;
	DWORD dwSize;
	PINFOFISHINGPARAM pInfo;

	nCount	= m_apParam.GetSize ();
	dwSize	= GetSendDataSize ();
	pData	= ZeroNew (dwSize);

	pDataTmp = pData;

	CopyMemoryRenew (pDataTmp, &m_dwFishingID,	sizeof (m_dwFishingID),	pDataTmp);	/* 釣りID */
	CopyMemoryRenew (pDataTmp, &m_nAverage,		sizeof (m_nAverage),	pDataTmp);	/* 釣れる確率 */
	strcpyRenew ((LPSTR)pDataTmp, m_strName, pDataTmp);								/* 釣り場名 */
	CopyMemoryRenew (pDataTmp, &nCount,			sizeof (nCount),		pDataTmp);	/* 釣り情報パラメータ数 */
	for (i = 0; i < nCount; i ++) {
		pInfo = GetPtr (i);
		CopyMemoryRenew (pDataTmp, &pInfo->dwItemTypeID,	sizeof (pInfo->dwItemTypeID),	pDataTmp);	/* アイテム種別ID */
		CopyMemoryRenew (pDataTmp, &pInfo->nAverage,		sizeof (pInfo->nAverage),		pDataTmp);	/* 釣りきる確率 */
	}

	return pData;
}

void    DtSubstring( void ) {
//=====================

// Data initialize a character substring.

    intstar4    first;
    intstar4    last;
    sym_id      cv;

    cv = GetPtr();
    GetU16();   // skip typing information
    first = DXPop();
    if( cv != NULL ) {
        if( DtFlags & DT_SS_NO_HIGH ) {
            last = cv->u.ns.xt.size;
            DtFlags &= ~DT_SS_NO_HIGH;
        } else {
            last = DXPop();
        }
    } else {
        last = first + GetInt() - 1;
    }
    if( !DoSubstring( first, last, InitVar->u.ns.xt.size ) ) {
        NameStmtErr( EV_SSTR_INVALID, InitVar, PR_DATA );
    }
    DtOffset += first - 1;
    DtItemSize = last - first + 1;
}

RadioButton::RadioButton(Gui & mGui,int x,int y, std::string Txt)
{

    Init(mGui);
    mText = new Text(Txt,x + mPositionTex[0].w,y);
    setPosition(x,y);
    mGui.AddClassGui(GetPtr());
}

PBYTE CInfoFishing::GetWriteData(int nNo, PDWORD pdwSize)
{
	int i, nCount, *pnTmp;
	PBYTE pRet, pSrc;
	DWORD dwSize, *pdwTmp;
	PINFOFISHINGPARAM pInfo;

	pRet		= NULL;
	pSrc		= NULL;
	dwSize		= GetDataSizeNo (nNo);
	*pdwSize	= dwSize;
	nCount		= m_apParam.GetSize ();

	if (dwSize == 0) {
		goto Exit;
	}
	pRet = new BYTE[dwSize];

	switch (nNo) {
	case 0:		pSrc = (PBYTE)&m_dwFishingID;		break;	/* 釣りID */
	case 1:		pSrc = (PBYTE)&m_nAverage;			break;	/* 釣れる確率 */
	case 2:		pSrc = (PBYTE)(LPCSTR)m_strName;	break;	/* 釣り場名 */
	case 3:		pSrc = (PBYTE)&nCount;				break;	/* 釣り情報パラメータ数 */
	case 4:		/* アイテム種別ID */
		pdwTmp = (PDWORD)pRet;
		for (i = 0; i < nCount; i ++) {
			pInfo = GetPtr (i);
			pdwTmp[i] = pInfo->dwItemTypeID;
		}
		break;
	case 5:		/* 釣りきる確率 */
		pnTmp = (int *)pRet;
		for (i = 0; i < nCount; i ++) {
			pInfo = GetPtr (i);
			pnTmp[i] = pInfo->nAverage;
		}
		break;
	}

	if (pSrc) {
		CopyMemory (pRet, pSrc, dwSize);
	}

Exit:
	return pRet;
}

//----------------------------------------------------------
void TContainerRise::AddData(char*p, int size)
{
  int oldSize = GetSize();
  int newSize = oldSize + size;
  Realloc(newSize);
  char* pBound = GetPtr();
  memcpy(pBound + oldSize, p, size);
}

void CLibInfoCharCli::RenewMotionInfo(DWORD dwCharID)
{
	int i, nCount;
	PCInfoCharCli pChar;

	if (dwCharID) {
		pChar = (PCInfoCharCli)GetPtr (dwCharID);
		RenewMotionInfo (pChar);

	} else {
		nCount = GetCount ();
		for (i = 0; i < nCount; i ++) {
			pChar = (PCInfoCharCli)GetPtr (i);
			RenewMotionInfo (pChar);
		}
	}
}

CWord::SHomIt::SHomIt(const THomonymVector& homonyms)
    : Current(homonyms.begin())
    , Begin(homonyms.begin())
    , End(homonyms.end())
{
    if (Ok() && GetPtr()->IsDeleted())
        operator++();
}

//-----------------------------------------------------------------------------
// Name: CArrayList::Contains
// Desc: Returns whether the list contains an entry identical to the 
//       specified entry data.
//-----------------------------------------------------------------------------
bool CArrayList::Contains( void* pEntryData )
{
    for( UINT iEntry = 0; iEntry < m_NumEntries; iEntry++ )
    {
        if( m_ArrayListType == AL_VALUE )
        {
            if( memcmp( GetPtr(iEntry), pEntryData, m_BytesPerEntry ) == 0 )
                return true;
        }
        else
        {
            if( GetPtr(iEntry) == pEntryData )
                return true;
        }
    }
    return false;
}

	i32	CShaderManager::PrepareResource(ResourceWeakPtr *const ppRes)
	{
		xst_assert2( ppRes && (*ppRes).IsValid() );
		auto pRes = *ppRes;
		Resources::IShader* pShader = (Resources::IShader*)pRes.GetPtr();
		pShader->m_eProfile = this->m_eShaderProfile;
		pShader->m_eShaderLanguage = this->m_eShaderLang;
		pShader->m_eShaderType = this->m_eShaderType;
		if( XST_FAILED( m_pRenderSystem->GetShaderSystem()->PrepareResource( pRes.GetPtr() ) ) )
		{
			return XST_FAIL;
		}
		//pRes->m_iResourceState = ResourceStates::PREPARED;
		pShader->m_iResourceState = Resources::ResourceStates::PREPARED;

		return XST_OK;
	}

PRInt64
nsAttrValue::SizeOf() const
{
  PRInt64 size = sizeof(*this);

  switch (BaseType()) {
    case eStringBase:
    {
      // TODO: we might be counting the string size more than once.
      // This should be fixed with bug 677487.
      nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
      size += str ? str->StorageSize() : 0;
      break;
    }
    case eOtherBase:
    {
      MiscContainer* container = GetMiscContainer();

      if (!container) {
        break;
      }

      size += sizeof(*container);

      void* otherPtr = MISC_STR_PTR(container);
      // We only count the size of the object pointed by otherPtr if it's a
      // string. When it's an atom, it's counted separatly.
      if (otherPtr &&
          static_cast<ValueBaseType>(container->mStringBits & NS_ATTRVALUE_BASETYPE_MASK) == eStringBase) {
        // TODO: we might be counting the string size more than once.
        // This should be fixed with bug 677487.
        nsStringBuffer* str = static_cast<nsStringBuffer*>(otherPtr);
        size += str ? str->StorageSize() : 0;
      }

      // TODO: mCSSStyleRule and mSVGValue might be owned by another object
      // which would make us count them twice, bug 677493.
      if (Type() == eCSSStyleRule && container->mCSSStyleRule) {
        // TODO: Add SizeOf() to StyleRule, bug 677503.
        size += sizeof(*container->mCSSStyleRule);
      } else if (Type() == eSVGValue && container->mSVGValue) {
        // TODO: Add SizeOf() to nsSVGValue, bug 677504.
        size += sizeof(*container->mSVGValue);
      } else if (Type() == eAtomArray && container->mAtomArray) {
        size += sizeof(container->mAtomArray) + sizeof(nsTArrayHeader);
        size += container->mAtomArray->Capacity() * sizeof(nsCOMPtr<nsIAtom>);
        // Don't count the size of each nsIAtom, they are counted separatly.
      }

      break;
    }
    case eAtomBase:    // Atoms are counted separatly.
    case eIntegerBase: // The value is in mBits, nothing to do.
      break;
  }

  return size;
}

void    FCStmtDefineLabel( void ) {
//===========================

    sym_id      sn;

    sn = GetPtr();
    CGControl( O_LABEL, NULL, GetStmtLabel( sn ) );
    RefStmtLabel( sn );
}

void    FCStmtJmpAlways( void ) {
//=========================

    sym_id      sn;

    sn = GetPtr();
    CGControl( O_GOTO, NULL, GetStmtLabel( sn ) );
    RefStmtLabel( sn );
}

void    FCOutStruct( void ) {
//=====================

// Output a structure.

    IORtnTable = OutRtn;
    TmpStructPtr = MkTmp( XPop(), TY_POINTER );
    StructIO( ((sym_id)GetPtr())->u.sd.fl.fields );
}