TYPE TypeTargetSizeT( // GET TYPE OF TARGET'S size_t
void )
{
TYPE type; // - return type
if( IsHugeData() ) {
type = GetBasicType( TYP_ULONG );
} else {
type = GetBasicType( TYP_UINT );
}
return( type );
}
static void genInitFiniReference( // GENERATE INIT/FINI REFERENCE TO FUNCTION
SYMBOL func, // - function to be called
unsigned priority, // - priority
NAME name, // - name for reference
fe_seg_id tgt_seg ) // - segment # of target segment
{
SYMBOL init_ref; // - reference to mod-init. function
TYPE type; // - used to build type
SegmentMarkUsed( tgt_seg );
type = MakePointerTo( func->sym_type );
init_ref = SymCreateFileScope( type
, SC_STATIC
, SF_INITIALIZED | SF_REFERENCED
, name );
init_ref->segid = tgt_seg;
if( tgt_seg == SEG_INIT_REF ) {
CgFrontInitRef();
} else {
CgFrontFiniRef();
}
CgFrontDataPtr( IC_DATA_LABEL, init_ref );
#if _INTEL_CPU
CgFrontDataPtr( IC_SET_TYPE, GetBasicType( TYP_UCHAR ) );
if( IsBigCode() ) {
CgFrontDataInt( IC_DATA_INT, 1 );
} else {
CgFrontDataInt( IC_DATA_INT, 0 );
}
CgFrontDataInt( IC_DATA_INT, priority );
#elif _CPU == _AXP
CgFrontDataPtr( IC_SET_TYPE, GetBasicType( TYP_UINT ) );
CgFrontDataInt( IC_DATA_INT, 0 );
CgFrontDataInt( IC_DATA_INT, priority );
#else
#error BAD _CPU
#endif
CgFrontDataPtr( IC_SET_TYPE, type );
CgFrontDataInt( IC_DATA_PTR_OFFSET, 0 );
CgFrontDataPtr( IC_DATA_PTR_SYM, func );
#if _CPU == 8086
if( !IsBigCode() ) {
CgFrontDataInt( IC_DATA_INT, 0 );
}
#elif COMP_CFG_COFF == 1
CgFrontDataPtr( IC_SET_TYPE, GetBasicType( TYP_USHORT ) );
CgFrontDataInt( IC_DATA_INT, 0 );
#endif
}
PTREE MakeDeleteCall( // MAKE A CALL TO 'OPERATOR DELETE'
SYMBOL del_sym, // - symbol for 'op del'
PTREE ptr, // - parm 1 for delete
TYPE class_parm ) // - if non-NULL, use size as second parm
{
PTREE size_arg; // - size argument for call
PTREE args; // - arguments for call
PTREE expr; // - final expression
arg_list *del_args; // - op del arguments
del_args = SymFuncArgList( del_sym );
args = NULL;
if( class_parm != NULL ) {
size_arg = NodeOffset( class_parm->u.c.info->size );
size_arg = NodeConvert( del_args->type_list[1], size_arg );
args = NodeArgument( args, size_arg );
}
ptr = NodeConvert( del_args->type_list[0], ptr );
args = NodeArgument( args, ptr );
expr = NodeMakeCall( del_sym, GetBasicType( TYP_VOID ), NULL );
expr = CallArgsArrange( del_sym->sym_type
, expr
, args
, NULL
, NULL
, NULL );
return expr;
}
const AnalysisResult PrimitiveTypeSpecifier::AnalyzeAssignmentTo(
const_shared_ptr<TypeSpecifier> other,
const TypeTable& type_table) const {
auto resolved_other_result = NestedTypeSpecifier::Resolve(other,
type_table);
if (ErrorList::IsTerminator(resolved_other_result.GetErrors())) {
auto resolved_other = resolved_other_result.GetData();
auto widening_analysis = resolved_other->AnalyzeWidening(type_table,
*this);
if (widening_analysis != AnalysisResult::INCOMPATIBLE) {
return widening_analysis;
}
auto other_as_primitive = dynamic_pointer_cast<
const PrimitiveTypeSpecifier>(resolved_other);
if (other_as_primitive) {
const BasicType other_type = other_as_primitive->GetBasicType();
if (other_type != BasicType::NONE) {
if (m_basic_type == other_type) {
return AnalysisResult::EQUIVALENT;
} else if (m_basic_type < other_type) {
return AnalysisResult::UNAMBIGUOUS;
}
}
}
}
return INCOMPATIBLE;
}
int CDatum::GetArrayCount (void) const
// GetArrayCount
//
// Returns the number of items in the datum.
//
// NOTE: Unlike GetCount, this only returns 1 for everything except arrays.
{
switch (m_dwData & AEON_TYPE_MASK)
{
case AEON_TYPE_STRING:
return (m_dwData == 0 ? 0 : 1);
case AEON_TYPE_NUMBER:
return 1;
case AEON_TYPE_COMPLEX:
if (GetBasicType() == typeArray)
return raw_GetComplex()->GetCount();
else
return 1;
default:
ASSERT(false);
return 0;
}
}
/* static */ wxString
wxDbgHelpDLL::DumpSymbol(wxPSYMBOL_INFO pSym, void *pVariable)
{
wxString s;
wxSYMBOL_INFO symDeref = *pSym;
switch ( DereferenceSymbol(&symDeref, &pVariable) )
{
default:
// Suppress gcc warnings about unhandled enum values, don't assert
// to avoid problems during fatal crash generation.
break;
case SYMBOL_TAG_UDT:
// show UDT recursively
s = DumpUDT(&symDeref, pVariable);
break;
case SYMBOL_TAG_BASE_TYPE:
// variable of simple type, show directly
BasicType bt = GetBasicType(&symDeref);
if ( bt )
{
s = DumpBaseType(bt, pSym->Size, pVariable);
}
break;
}
return s;
}
static SYMBOL segDefineLabel( // DEFINE LABEL FOR SEGMENT, IF REQ'D
PC_SEGMENT *seg ) // - current segment
{
SYMBOL label; // - reference symbol
char *name; // - label's name
SYMBOL func; // - function being compiled
label = seg->label;
if( label == NULL ) {
func = ScopeFunctionInProgress();
if( ( func != NULL ) && ( func->segid == seg->seg_id ) ) {
label = func;
}
}
if( label == NULL ) {
label = SymMakeDummy( GetBasicType( TYP_CHAR ), &name );
label->segid = seg->seg_id;
if( label->segid == SEG_STACK ) {
label->id = SC_AUTO;
} else {
label->id = SC_STATIC;
InsertSymbol( GetFileScope(), label, name );
}
seg->label = label;
_markUsed( seg, TRUE );
}
return label;
}
unsigned StaticInitFuncBeg( // START INITIALIZATION OF STATIC IN FUNCTION
void )
{
CGLABEL init_label; // - label #
INIT_VAR *init_var;
CgFrontStatInit();
init_var = FunctionBodyGetInit( NULL );
if( init_var->var == NULL ) {
init_var->var = staticInitFuncVar();
} else {
init_var->mask <<= 1;
if( init_var->mask >= 0x100 ) {
++init_var->var->sym_type->u.a.array_size;
init_var->mask = 1;
}
}
if( CompFlags.bm_switch_used ) {
SYMBOL rtf;
rtf = RunTimeCallSymbol( RTF_STATIC_INIT );
CgFrontSymbol( rtf );
CgSetType( GetBasicType( TYP_SINT ) );
CgFrontCodePtr( IC_CALL_SETUP, rtf );
CgSetType( GetBasicType( TYP_SINT ) );
CgFrontCodeUint( IC_LEAF_CONST_INT, init_var->mask );
CgFrontCode( IC_CALL_PARM );
moduleInitVar( init_var->var, false );
CgFrontCode( IC_CALL_PARM );
CgFrontCode( IC_CALL_EXEC );
} else {
moduleInitVar( init_var->var, true );
CgFrontCodeUint( IC_OPR_UNARY, CO_FETCH );
CgFrontCodeUint( IC_LEAF_CONST_INT, init_var->mask );
CgFrontCodeUint( IC_OPR_BINARY, CO_AND );
}
CgFrontCodeUint( IC_LEAF_CONST_INT, 0 );
CgFrontCodeUint( IC_OPR_BINARY, CO_NE );
init_label = CgFrontLabelCs();
CgFrontGotoNear( IC_LABEL_CS, O_IF_TRUE, init_label );
if( !CompFlags.bm_switch_used ) {
moduleInitVar( init_var->var, true );
CgFrontCodeUint( IC_LEAF_CONST_INT, init_var->mask );
CgFrontCodeUint( IC_OPR_BINARY, CO_OR_EQUAL );
CgFrontCode( IC_EXPR_DONE );
}
return( init_label );
}
TYPE TypeSegAddr( // GET INTERNAL TYPE OF BASE :> ADDRESS
void )
{
TYPE type; // - resultant type
type = GetBasicType( TYP_VOID );
return( makePointerToModType( type, TF1_NEAR ) );
}
bool PrimitiveTypeSpecifier::operator ==(const TypeSpecifier& other) const {
try {
const PrimitiveTypeSpecifier& as_primitive =
dynamic_cast<const PrimitiveTypeSpecifier&>(other);
return GetBasicType() == as_primitive.GetBasicType();
} catch (std::bad_cast& e) {
return false;
}
}
void CgFrontResultBoolean( // SET RESULTANT TYPE TO BE BOOLEAN
void )
{
CGFILE_GEN *gen; // - generation data
gen = getGenData();
gen->emit_type = GetBasicType( TYP_BOOL );
gen->curr_type = gen->emit_type;
}
// make sure to get a predefined type so that the type system is not
// exercised in the back end
//
static SYMBOL rtSymbolCreate( // CREATE NEW RUN-TIME SYMBOL
RTS_TYPE runtime_type, // - run-time type definition
NAME name ) // - name of run-time function
{
SYMBOL sym; // - new symbol
TYPE sym_type; // - symbol's type
symbol_flag flags; // - symbol's flags
flags = SF_REFERENCED;
if( runtime_type & RTS_FUNCTION ) {
if( runtime_type & RTS_POINTER ) {
sym_type = TypePtrVoidFunOfVoid();
} else if( runtime_type & RTS_HANDLER ) {
sym_type = TypeVoidHandlerFunOfVoid();
} else {
sym_type = TypeVoidFunOfVoid();
}
if( runtime_type & RTS_INLINE ) {
sym_type = AddFunctionFlag( sym_type, TF1_INTRINSIC );
}
if( runtime_type & RTS_CAN_THROW ) {
flags |= SF_LONGJUMP;
} else if( runtime_type & RTS_NO_THROW ) {
flags |= SF_NO_LONGJUMP;
} else if( runtime_type & RTS_IG_THROW ) {
RepoFunAdd( name, RFFLAG_IG_LONGJUMP );
}
if( runtime_type & RTS_IS_THROW ) {
flags |= SF_IS_THROW;
}
} else if( runtime_type & RTS_BASE_VOID ) {
if( runtime_type & RTS_POINTER ) {
sym_type = TypePtrToVoid();
} else {
sym_type = GetBasicType( TYP_VOID );
}
} else {
sym_type = GetBasicType( TYP_SINT );
}
sym = SymCreate( sym_type, SC_EXTERN, flags, name, GetInternalScope() );
LinkageSet( sym, "C" );
return sym;
}
const string PrimitiveTypeSpecifier::ToString(
const_shared_ptr<void> value) const {
ostringstream buffer;
const BasicType type = GetBasicType();
switch (type) {
case BasicType::BOOLEAN: {
const_shared_ptr<bool> cast_value = static_pointer_cast<const bool>(
value);
if (*cast_value == true) {
buffer << "true";
} else {
buffer << "false";
}
break;
}
case BasicType::BYTE: {
const_shared_ptr<std::uint8_t> cast_value = static_pointer_cast<
const std::uint8_t>(value);
buffer << "0x" << std::setfill('0') << std::setw(2) << std::hex
<< uppercase << unsigned(*cast_value);
break;
}
case BasicType::INT: {
const_shared_ptr<int> cast_value = static_pointer_cast<const int>(
value);
buffer << *cast_value;
break;
}
case BasicType::DOUBLE: {
const_shared_ptr<double> cast_value = static_pointer_cast<const double>(
value);
buffer << *cast_value;
break;
}
case BasicType::STRING: {
const_shared_ptr<string> cast_value = static_pointer_cast<const string>(
value);
buffer << "\"" << *cast_value << "\"";
break;
}
default:
assert(false);
}
return buffer.str();
}
bool CDatum::IsNumber (void) const
// IsNumber
//
// Returns TRUE if this is a number
{
switch (GetBasicType())
{
case typeInteger32:
case typeInteger64:
case typeIntegerIP:
case typeDouble:
return true;
default:
return false;
}
}
TYPE TypeBinArithResult( // TYPE OF BINARY ARITHMETIC RESULT
TYPE op1, // - type[1]
TYPE op2 ) // - type[2]
{
type_id id1; // - id for type(1)
type_id id2; // - id for type(2)
id1 = integralPromote( op1 );
id2 = integralPromote( op2 );
if( id1 > id2 ) {
type_id tmp;
tmp = id1;
id1 = id2;
id2 = tmp;
}
#if _CPU != 8086
if( ( id1 == TYP_UINT ) && ( id2 == TYP_SLONG ) ) {
id2 = TYP_ULONG;
}
#endif
return( GetBasicType( id2 ) );
}
bool CDatum::IsEqual (CDatum dValue) const
// IsEqual
//
// Returns TRUE if the values are equal
{
switch (GetBasicType())
{
case typeNil:
return dValue.IsNil();
case typeTrue:
return !dValue.IsNil();
case typeInteger32:
case typeInteger64:
case typeIntegerIP:
case typeDouble:
return (dValue.IsNumber() && CNumberValue(*this).Compare(dValue) == 0);
case typeString:
return (dValue.GetBasicType() == typeString && strEquals(*this, dValue));
case typeDateTime:
return (dValue.GetBasicType() == typeDateTime && ((const CDateTime &)*this == (const CDateTime &)dValue));
// LATER
case typeArray:
case typeBinary:
case typeStruct:
case typeSymbol:
return false;
default:
ASSERT(false);
return false;
}
}
CDatum CDatum::GetArrayElement (int iIndex) const
// GetArrayElement
//
// Gets the appropriate element
{
ASSERT(iIndex >= 0);
switch (m_dwData & AEON_TYPE_MASK)
{
case AEON_TYPE_COMPLEX:
{
if (GetBasicType() == typeArray)
return raw_GetComplex()->GetElement(iIndex);
else
return (iIndex == 0 ? *this : CDatum());
}
default:
return (iIndex == 0 ? *this : CDatum());
}
}
/* static */ wxString
wxDbgHelpDLL::DumpSymbol(PSYMBOL_INFO pSym, void *pVariable)
{
wxString s;
SYMBOL_INFO symDeref = *pSym;
switch ( DereferenceSymbol(&symDeref, &pVariable) )
{
case SYMBOL_TAG_UDT:
// show UDT recursively
s = DumpUDT(&symDeref, pVariable);
break;
case SYMBOL_TAG_BASE_TYPE:
// variable of simple type, show directly
BasicType bt = GetBasicType(&symDeref);
if ( bt )
{
s = DumpBaseType(bt, pSym->Size, pVariable);
}
break;
}
return s;
}
/* static */
wxDbgHelpDLL::SymbolTag
wxDbgHelpDLL::DereferenceSymbol(PSYMBOL_INFO pSym, void **ppData)
{
SymbolTag tag = SYMBOL_TAG_NULL;
for ( ;; )
{
if ( !DoGetTypeInfo(pSym, TI_GET_SYMTAG, &tag) )
break;
if ( tag != SYMBOL_TAG_POINTER_TYPE )
break;
ULONG tiNew;
if ( !DoGetTypeInfo(pSym, TI_GET_TYPEID, &tiNew) ||
tiNew == pSym->TypeIndex )
break;
pSym->TypeIndex = tiNew;
// remove one level of indirection except for the char strings: we want
// to dump "char *" and not a single "char" for them
if ( ppData && *ppData && GetBasicType(pSym) != BASICTYPE_CHAR )
{
DWORD_PTR *pData = (DWORD_PTR *)*ppData;
if ( ::IsBadReadPtr(pData, sizeof(DWORD_PTR *)) )
{
break;
}
*ppData = (void *)*pData;
}
}
return tag;
}
static void moduleInitVar( // GENERATE REFERENCE TO MODULE-INIT VAR.
SYMBOL var, // - variable
bool base_type ) // - base_type or pointer to it
{
unsigned offset; // - offset to be tested
TYPE type; // - type for flags variable
type = var->sym_type;
offset = type->u.a.array_size - 1;
if( offset != 0 ) {
CgSetType( GetBasicType( TYP_UINT ) );
CgFrontCodeUint( IC_LEAF_CONST_INT, offset );
CgFrontSymbol( var );
CgSetType( MakePointerTo( type->of ) );
CgFrontCodeUint( IC_OPR_BINARY, CO_PLUS );
} else {
CgFrontSymbol( var );
}
if( base_type ) {
CgSetType( type->of );
} else {
CgSetType( MakePointerTo( type->of ) );
}
}
LONG CuDlgDomPropDbSeq::OnUpdateData (WPARAM wParam, LPARAM lParam)
{
// cast received parameters
int nNodeHandle = (int)wParam;
LPIPMUPDATEPARAMS pUps = (LPIPMUPDATEPARAMS)lParam;
ASSERT (nNodeHandle != -1);
ASSERT (pUps);
// ignore selected actions on filters
switch (pUps->nIpmHint)
{
case 0:
case FILTER_DOM_SYSTEMOBJECTS: // eligible
//case FILTER_DOM_BASEOWNER:
case FILTER_DOM_OTHEROWNER:
break;
case FILTER_DOM_BKREFRESH:
// eligible if UpdateType is compatible with DomGetFirst/Next object type,
// or is ot_virtnode, which means refresh for all whatever the type is
if (pUps->pSFilter->UpdateType != OT_VIRTNODE &&
pUps->pSFilter->UpdateType != OT_PROCEDURE)
return 0L;
break;
case FILTER_SETTING_CHANGE:
VDBA_OnGeneralSettingChange(&m_cListCtrl);
return 0L;
default:
return 0L; // nothing to change on the display
}
ResetDisplay();
// Get info on the current item
LPTREERECORD lpRecord = (LPTREERECORD)pUps->pStruct;
ASSERT (lpRecord);
//
// Get list of Proc for the replication
//
m_Data.m_uaDbSeq.RemoveAll();
int iret;
LPUCHAR aparentsTemp[MAXPLEVEL];
UCHAR buf[MAXOBJECTNAME];
UCHAR bufOwner[MAXOBJECTNAME];
UCHAR bufComplim[MAXOBJECTNAME];
// parent preparation - added static type.
int basicType = GetBasicType(lpRecord->recType);
switch (basicType) {
case OT_DATABASE:
aparentsTemp[0] = lpRecord->objName;
break;
case OT_STATIC_SEQUENCE:
aparentsTemp[0] = lpRecord->extra;
break;
default:
ASSERT(FALSE);
return 0L;
}
aparentsTemp[1] = aparentsTemp[2] = NULL;
m_Data.m_objType = basicType;
memset (&bufComplim, '\0', sizeof(bufComplim));
memset (&bufOwner, '\0', sizeof(bufOwner));
iret = DOMGetFirstObject(nNodeHandle,
OT_SEQUENCE,
1, // level,
aparentsTemp, // Temp mandatory!
pUps->pSFilter->bWithSystem, // bwithsystem
(LPUCHAR)pUps->pSFilter->lpOtherOwner, // lpowner
buf,
bufOwner,
bufComplim);
if (iret != RES_SUCCESS && iret != RES_ENDOFDATA) {
// Erroneous case!
CuNameWithOwner errItem(VDBA_MfcResourceString (IDS_DATA_UNAVAILABLE));//"<Data Unavailable>"
m_Data.m_uaDbSeq.Add(errItem);
}
else {
while (iret == RES_SUCCESS) {
CuNameWithOwner item((const char*)buf, (const char*)bufOwner);
m_Data.m_uaDbSeq.Add(item);
iret = DOMGetNextObject(buf, bufOwner, bufComplim);
}
}
if (m_Data.m_uaDbSeq.GetCount() == 0) {
CuNameWithOwner noItem(VDBA_MfcResourceString (IDS_E_NO_SEQUENCE));//"<No Sequence>"
m_Data.m_uaDbSeq.Add(noItem);
}
// Refresh display
RefreshDisplay();
return 0L;
}
wxString
wxDbgHelpDLL::DumpField(PSYMBOL_INFO pSym, void *pVariable, unsigned level)
{
wxString s;
// avoid infinite recursion
if ( level > 100 )
{
return s;
}
SymbolTag tag = SYMBOL_TAG_NULL;
if ( !DoGetTypeInfo(pSym, TI_GET_SYMTAG, &tag) )
{
return s;
}
switch ( tag )
{
case SYMBOL_TAG_UDT:
case SYMBOL_TAG_BASE_CLASS:
s = DumpUDT(pSym, pVariable, level);
break;
case SYMBOL_TAG_DATA:
if ( !pVariable )
{
s = _T("NULL");
}
else // valid location
{
wxDbgHelpDLL::DataKind kind;
if ( !DoGetTypeInfo(pSym, TI_GET_DATAKIND, &kind) ||
kind != DATA_MEMBER )
{
// maybe it's a static member? we're not interested in them...
break;
}
// get the offset of the child member, relative to its parent
DWORD ofs = 0;
if ( !DoGetTypeInfo(pSym, TI_GET_OFFSET, &ofs) )
break;
pVariable = (void *)((DWORD_PTR)pVariable + ofs);
// now pass to the type representing the type of this member
SYMBOL_INFO sym = *pSym;
if ( !DoGetTypeInfo(pSym, TI_GET_TYPEID, &sym.TypeIndex) )
break;
ULONG64 size;
DoGetTypeInfo(&sym, TI_GET_LENGTH, &size);
switch ( DereferenceSymbol(&sym, &pVariable) )
{
case SYMBOL_TAG_BASE_TYPE:
{
BasicType bt = GetBasicType(&sym);
if ( bt )
{
s = DumpBaseType(bt, size, pVariable);
}
}
break;
case SYMBOL_TAG_UDT:
case SYMBOL_TAG_BASE_CLASS:
s = DumpUDT(&sym, pVariable, level);
break;
}
}
if ( !s.empty() )
{
s = GetSymbolName(pSym) + _T(" = ") + s;
}
break;
}
if ( !s.empty() )
{
s = wxString(_T('\t'), level + 1) + s + _T('\n');
}
return s;
}
TYPE TypeUnArithResult( // TYPE OF UNARY ARITHMETIC RESULT
TYPE op1 ) // - type
{
return( GetBasicType( integralPromote( op1 ) ) );
}
static boolean convertEllipsisArg(// CONVERT AN ELLIPSIS (...) ARGUMENT
PTREE arg ) // - argument
{
boolean retn; // - return: TRUE ==> ok
PTREE right; // - argument
PTREE afun; // - &[ function ]
TYPE type; // - node type
switch( NodeAddrOfFun( PTreeOpRight( arg ), &afun ) ) {
case ADDR_FN_MANY :
case ADDR_FN_MANY_USED :
PTreeErrorExpr( arg->u.subtree[1], ERR_ELLIPSE_ADDR_OVERLOAD );
retn = FALSE;
break;
default :
right = NodeRvalue( arg->u.subtree[1] );
arg->u.subtree[1] = right;
type = TypedefModifierRemove( right->type );
switch( type->id ) {
case TYP_CHAR :
case TYP_SCHAR :
case TYP_UCHAR :
case TYP_SSHORT :
case TYP_WCHAR :
case TYP_USHORT :
type = TypeUnArithResult( type );
right = NodeConvert( type, right );
arg_finish( right, arg );
retn = TRUE;
break;
case TYP_FLOAT :
type = GetBasicType( TYP_DOUBLE );
right = NodeConvert( type, right );
arg_finish( right, arg );
retn = TRUE;
break;
case TYP_ARRAY :
type = PointerTypeForArray( right->type );
right = NodeConvert( type, right );
arg_finish( right, arg );
retn = TRUE;
break;
case TYP_MEMBER_POINTER :
ConvertMembPtrConst( &arg->u.subtree[1] );
arg_fillout( arg );
retn = TRUE;
break;
case TYP_POINTER :
if( NULL == FunctionDeclarationType( type->of ) ) {
type_flag def_flags;
type_flag act_flags;
type_flag arg_flags;
TYPE base_type;
PTREE cnv;
base_type = TypeGetActualFlags( type->of, &arg_flags );
act_flags = arg_flags & TF1_MEM_MODEL;
def_flags = DefaultMemoryFlag( type->of );
if( ( ( def_flags & TF1_FAR )
&&( act_flags != TF1_HUGE )
&&( act_flags != TF1_FAR ) )
||( ( def_flags & TF1_HUGE )
&&( act_flags != TF1_HUGE ) )
) {
type = MakeModifiedType( base_type
, ( arg_flags
& ~TF1_MEM_MODEL )
| def_flags );
type = MakePointerTo( type );
cnv = CastImplicit( arg->u.subtree[1]
, type
, CNV_EXPR
, NULL );
arg->u.subtree[1] = cnv;
DbgVerify( PT_ERROR != cnv->op
, "convertEllipsisArg -- failed ptr.cnv" );
arg_fillout( arg );
retn = TRUE;
} else {
arg_fillout( arg );
retn = TRUE;
}
} else {
arg_fillout( arg );
retn = TRUE;
}
break;
case TYP_CLASS :
retn = passStructOnStack( arg, WARN_ELLIPSIS_CLASS_ARG );
break;
default :
arg_fillout( arg );
retn = TRUE;
break;
}
break;
}
return retn;
}
LONG CuDlgDomPropTblInteg::OnUpdateData (WPARAM wParam, LPARAM lParam)
{
// cast received parameters
int nNodeHandle = (int)wParam;
LPIPMUPDATEPARAMS pUps = (LPIPMUPDATEPARAMS)lParam;
ASSERT (nNodeHandle != -1);
ASSERT (pUps);
// ignore selected actions on filters
switch (pUps->nIpmHint)
{
case 0:
case FILTER_DOM_SYSTEMOBJECTS: // eligible
//case FILTER_DOM_BASEOWNER:
//case FILTER_DOM_OTHEROWNER:
break;
case FILTER_DOM_BKREFRESH:
// eligible if UpdateType is compatible with DomGetFirst/Next object type,
// or is ot_virtnode, which means refresh for all whatever the type is
if (pUps->pSFilter->UpdateType != OT_VIRTNODE &&
pUps->pSFilter->UpdateType != OT_INTEGRITY)
return 0L;
break;
case FILTER_SETTING_CHANGE:
VDBA_OnGeneralSettingChange(&m_cListCtrl);
return 0L;
default:
return 0L; // nothing to change on the display
}
// Get info on the current item
LPTREERECORD lpRecord = (LPTREERECORD)pUps->pStruct;
ASSERT (lpRecord);
ResetDisplay();
//
// Get list of Tbl for the replication
//
m_Data.m_uaTblInteg.RemoveAll();
int iret;
UCHAR buf[MAXOBJECTNAME];
UCHAR bufOwner[MAXOBJECTNAME];
UCHAR bufComplim[MAXOBJECTNAME];
//
// CHECK EXISTENCE SINCE REGISTERED TABLE MIGHT NOT REALLY EXIST YET
//
int resultType;
UCHAR resultObjectName[MAXOBJECTNAME];
UCHAR resultOwnerName[MAXOBJECTNAME];
UCHAR resultExtraData[MAXOBJECTNAME];
char* parentStrings[3];
parentStrings[0] = (char*)lpRecord->extra; // DBName
parentStrings[1] = parentStrings[2] = NULL;
// preparation for get limited info - added static type - added all related granted types
LPUCHAR lpName = NULL;
LPUCHAR lpOwner = NULL;
int basicType = GetBasicType(lpRecord->recType);
m_Data.m_objType = basicType;
switch (basicType) {
case OT_TABLE:
case OT_SCHEMAUSER_TABLE:
lpName = (LPUCHAR)lpRecord->objName;
lpOwner = (LPUCHAR)lpRecord->ownerName;
break;
case OT_STATIC_INTEGRITY:
lpName = (LPUCHAR)lpRecord->extra2;
lpOwner = (LPUCHAR)lpRecord->tableOwner;
break;
default:
ASSERT(FALSE);
return 0L;
}
iret = DOMGetObjectLimitedInfo(nNodeHandle,
lpName, // object name,
lpOwner, // object owner
OT_TABLE, // iobjecttype
1, // level
(unsigned char **)parentStrings, // parenthood
TRUE, // bwithsystem
&resultType,
resultObjectName,
resultOwnerName,
resultExtraData
);
if (iret == RES_ENDOFDATA)
iret = RES_ERR; // Non-existent: ERROR !!!
if (iret == RES_SUCCESS) {
LPUCHAR aparentsTemp[MAXPLEVEL];
// prepare parenthood with schema where relevant
aparentsTemp[0] = lpRecord->extra; // DBName
UCHAR bufParent1[MAXOBJECTNAME];
aparentsTemp[1] = bufParent1;
x_strcpy((char *)buf, (const char *)resultObjectName);
StringWithOwner(buf, resultOwnerName, aparentsTemp[1]); // schema.name
aparentsTemp[2] = NULL;
memset (&bufComplim, '\0', sizeof(bufComplim));
memset (&bufOwner, '\0', sizeof(bufOwner));
iret = DOMGetFirstObject(nNodeHandle,
OT_INTEGRITY,
2, // level,
aparentsTemp, // Temp mandatory!
pUps->pSFilter->bWithSystem, // bwithsystem
NULL, // lpowner
buf,
bufOwner,
bufComplim);
}
if (iret != RES_SUCCESS && iret != RES_ENDOFDATA) {
// Erroneous case!
CuNameWithOwner errItem(VDBA_MfcResourceString (IDS_DATA_UNAVAILABLE));//"<Data Unavailable>"
m_Data.m_uaTblInteg.Add(errItem);
}
else {
while (iret == RES_SUCCESS) {
CuNameWithOwner item((const char*)buf, _T("")); // no owner
m_Data.m_uaTblInteg.Add(item);
iret = DOMGetNextObject(buf, bufOwner, bufComplim);
}
}
if (m_Data.m_uaTblInteg.GetCount() == 0) {
CuNameWithOwner noItem(VDBA_MfcResourceString (IDS_E_NO_INTEGRITY));//"<No Integrity>"
m_Data.m_uaTblInteg.Add(noItem);
}
// Refresh display
RefreshDisplay();
return 0L;
}
PTREE AnalyseCall( // ANALYSIS FOR CALL
PTREE expr, // - call expression
CALL_DIAG *diagnostic ) // - diagnostics used for function problems
{
PTREE *r_args; // - reference( arguments )
PTREE *r_func; // - reference( function )
PTREE *ptlist; // - nodes for arguments
PTREE left; // - left operand ( the function )
PTREE right; // - right operand ( the arguments )
PTREE this_node; // - node for "this" computation
PTREE deref_args; // - member pointer dereference args
PTREE last_arg; // - last argument
PTREE static_fn_this; // - "this" for a static member
PTREE templ_args; // - explicit template arguments
SYMBOL sym; // - function symbol
SYMBOL caller_sym; // - function that is doing the call
TYPE type; // - temporary type
TYPE fn_type; // - function type
type_flag fn_mod; // - function modifier flags
unsigned count; // - # args, caller
arg_list *alist; // - arg_list for caller
intrinsic_mapping *intr_map;// - mapping for intrinsic function
SEARCH_RESULT *result; // - searching result
boolean membptr_deref; // - TRUE ==> member pointer dereference
boolean has_ellipsis; // - TRUE ==> ellipsis in argument list
boolean virtual_call; // - TRUE ==> virtual call
TEMP_PT_LIST default_list; // - default PTREE list
TEMP_ARG_LIST default_args; // - default arg_list
FNOV_DIAG fnov_diag; // - diagnosis information;
r_args = PTreeRefRight( expr );
last_arg = *r_args;
right = NodeReverseArgs( &count, last_arg );
*r_args = right;
r_func = PTreeRefLeft( expr );
left = *r_func;
membptr_deref = FALSE;
this_node = NULL;
intr_map = NULL;
static_fn_this = NULL;
virtual_call = FALSE;
switch( left->cgop ) {
case CO_DOT:
case CO_ARROW:
this_node = left->u.subtree[0];
left->u.subtree[0] = NULL;
left = NodePruneTop( left );
*r_func = left;
r_func = PTreeRefLeft( expr );
left = *r_func;
if( ( left->op == PT_ID ) && ( left->cgop == CO_NAME_DTOR ) ) {
/* dtor of a non-class type */
left = NodePruneTop( *r_func );
/* NYI: verify dtor call has no arguments */
expr->u.subtree[0] = NULL;
NodeFreeDupedExpr( expr );
expr = NodeConvert( GetBasicType( TYP_VOID ), this_node );
expr = NodeComma( expr, left );
return( expr );
}
break;
case CO_CALL_EXEC_IND:
if( left->flags & PTF_CALLED_ONLY ) {
/* member pointer dereference being called */
deref_args = left->u.subtree[1];
this_node = NodeDupExpr( &(deref_args->u.subtree[1]) );
membptr_deref = TRUE;
}
break;
}
alist = ArgListTempAlloc( &default_args, count );
ptlist = PtListAlloc( default_list, count );
NodeBuildArgList( alist, ptlist, right, count );
if( this_node == NULL ) {
alist->qualifier = FunctionThisQualifier();
} else {
alist->qualifier = BaseTypeClassFlags( NodeType( this_node ) );
}
if( NodeIsBinaryOp( left, CO_TEMPLATE ) ) {
DbgAssert( left->u.subtree[0]->op == PT_SYMBOL );
templ_args = left->u.subtree[1];
left->u.subtree[1] = NULL;
left = NodePruneTop( left );
*r_func = left;
r_func = PTreeRefLeft( expr );
left = *r_func;
} else {
templ_args = NULL;
}
if( left->op == PT_SYMBOL ) {
FNOV_RESULT ovret;
SYMBOL orig; // - original symbol
sym = left->u.symcg.symbol;
orig = sym;
if( left->cgop == CO_NAME_CONVERT ) {
ovret = UdcOverloadedDiag( &sym
, left->u.symcg.result
, sym
, SymFuncReturnType( sym )
, alist->qualifier
, &fnov_diag );
} else {
ovret = FuncOverloadedDiag( &sym
, left->u.symcg.result
, sym
, alist
, ptlist
, templ_args
, &fnov_diag );
}
switch( ovret ) {
case FNOV_AMBIGUOUS :
CallDiagAmbiguous( expr, diagnostic->msg_ambiguous, &fnov_diag );
NodeFreeDupedExpr( this_node );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return( expr );
case FNOV_NO_MATCH :
if( this_node == NULL ) {
if( SymIsThisFuncMember( orig ) ) {
this_node = NodeThisCopyLocation( left );
}
}
if( this_node != NULL ) {
if( ( ! SymIsCtor( orig ) )
&&( ! SymIsDtor( orig ) )
&&( CNV_OK != AnalysePtrCV
( this_node
, TypeThisSymbol( orig
, this_node->flags & PTF_LVALUE )
, NodeType( this_node )
, CNV_FUNC_THIS ) ) ) {
PTreeErrorNode( expr );
InfSymbolDeclaration( orig );
NodeFreeDupedExpr( this_node );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return( expr );
}
}
CallDiagNoMatch( expr
, diagnostic->msg_no_match_one
, diagnostic->msg_no_match_many
, this_node
, orig
, &fnov_diag );
NodeFreeDupedExpr( this_node );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return( expr );
}
FnovFreeDiag( &fnov_diag );
left->u.symcg.symbol = sym;
result = left->u.symcg.result;
if( this_node == NULL ) {
if( SymIsThisFuncMember( sym ) ) {
if( result->use_this ) {
this_node = NodeThisCopyLocation( left );
if( this_node == NULL ) {
PTreeErrorExpr( expr, ERR_INVALID_NONSTATIC_ACCESS );
InfSymbolDeclaration( sym );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return( expr );
}
} else {
PTreeErrorExpr( expr, ERR_BARE_FUNCTION_ACCESS );
InfSymbolDeclaration( sym );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return( expr );
}
}
}
if( ! AnalyseSymbolAccess( expr, left, this_node, &diagAccess ) ) {
NodeFreeDupedExpr( this_node );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return( expr );
}
type = sym->sym_type;
fn_type = TypeGetActualFlags( type, &fn_mod );
if( fn_type->flag & TF1_INTRINSIC ) {
intr_map = intrinsicMapping( sym );
if( intr_map == NULL ) {
outputCallTriggeredWarning( expr, sym );
}
}
if( fn_mod & TF1_FAR16 ) {
/* we are calling a far16 function */
caller_sym = ScopeFunctionInProgress();
caller_sym->flag |= SF_FAR16_CALLER;
}
left->type = type;
if( this_node == NULL ) {
if( SymIsThisFuncMember( sym ) ) {
this_node = NodeThisCopyLocation( left );
}
} else {
if( SymIsStaticFuncMember( sym ) ) {
#ifdef OLD_STATIC_MEMBER_ACCESS
NodeFreeDupedExpr( this_node );
#else
static_fn_this = this_node;
#endif
this_node = NULL;
}
}
if( this_node != NULL ) {
TYPE pted;
pted = TypePointedAtModified( this_node->type );
if( pted == NULL ) {
pted = this_node->type;
}
if( TypeTruncByMemModel( pted ) ) {
if( SymIsCtor( sym ) ) {
PTreeErrorExpr( this_node, ERR_CTOR_OBJ_MEM_MODEL );
} else if( SymIsDtor( sym ) ) {
PTreeErrorExpr( this_node, ERR_DTOR_OBJ_MEM_MODEL );
} else {
PTreeErrorExpr( this_node, ERR_THIS_OBJ_MEM_MODEL );
}
InfSymbolDeclaration( sym );
PTreeErrorNode( expr );
NodeFreeDupedExpr( this_node );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
NodeFreeDupedExpr( static_fn_this );
return( expr );
}
if( adjustForVirtualCall( &this_node, r_func, result ) ) {
virtual_call = TRUE;
expr->cgop = CO_CALL_EXEC_IND;
left = VfunSetupCall( expr->u.subtree[0] );
left = VfnDecorateCall( left, sym );
} else {
expr->cgop = CO_CALL_EXEC;
left = NodeUnaryCopy( CO_CALL_SETUP, expr->u.subtree[0] );
SymMarkRefed( sym );
}
} else {
NodeFreeSearchResult( left );
expr->cgop = CO_CALL_EXEC;
left = NodeUnaryCopy( CO_CALL_SETUP, expr->u.subtree[0] );
SymMarkRefed( sym );
}
} else {
if( ! membptr_deref ) {
/* i.e, p->foo() where foo is a pointer to a function */
NodeFreeDupedExpr( this_node );
this_node = NULL;
}
sym = NULL;
left = expr->u.subtree[0];
type = TypedefModifierRemove( left->type );
if( type->id == TYP_POINTER ) {
type = type->of;
}
fn_type = TypeGetActualFlags( type, &fn_mod );
if( fn_mod & TF1_FAR16 ) {
/* we are calling a far16 function */
caller_sym = ScopeFunctionInProgress();
caller_sym->flag |= SF_FAR16_CALLER;
}
if( ! TypeHasNumArgs( type, count ) ) {
PTreeErrorExpr( expr, ERR_PARM_COUNT_MISMATCH_POINTER );
CErr2p( INF_FUNCTION_TYPE, type );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
NodeFreeDupedExpr( static_fn_this );
return( expr );
}
expr->cgop = CO_CALL_EXEC_IND;
left = VfunSetupCall( left );
}
expr->u.subtree[0] = left;
#if _CPU == _AXP
if( intr_map != NULL && intr_map->cgop == CO_VASTART ) {
expr = convertVaStart( expr, alist, type );
} else {
expr = NodeConvertCallArgList( expr, count, type, &expr->u.subtree[1] );
}
#else
expr = NodeConvertCallArgList( expr, count, type, &expr->u.subtree[1] );
#endif
if( expr->op != PT_ERROR ) {
TYPE ftype; // - function type
PTREE cdtor; // - CDTOR node
PTREE callnode; // - call node
PTREE retnnode; // - return node (for struct return)
callnode = expr;
if( this_node == NULL ) {
cdtor = NULL;
} else {
this_node = NodeArg( this_node );
if( virtual_call ) {
this_node->flags |= PTF_ARG_THIS_VFUN;
}
if( sym != NULL && SymIsDtor( sym ) ) {
cdtor = NodeArg( NodeCDtorArg( DTOR_NULL ) );
} else {
cdtor = NULL;
}
}
ftype = type;
type = TypedefModifierRemove( type );
has_ellipsis = TypeHasEllipsisArg( type );
type = type->of;
{
TYPE tgt = TypeReference( type );
if( tgt == NULL ) {
expr->type = type;
} else {
expr->type = tgt;
expr->flags |= PTF_LVALUE;
}
}
if( sym != NULL ) {
if( ! AddDefaultArgs( sym, expr ) ) {
NodeFreeDupedExpr( cdtor );
NodeFreeDupedExpr( this_node );
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return expr;
}
}
if( NULL != TypeReference( type ) ) {
expr->flags |= PTF_LVALUE;
}
if( OMR_CLASS_REF == ObjModelArgument( type ) ) {
retnnode = NodeTemporary( type );
retnnode = PTreeCopySrcLocation( retnnode, expr );
} else {
retnnode = NULL;
}
expr = CallArgsArrange( ftype
, callnode
, callnode->u.subtree[1]
, this_node
, cdtor
, retnnode );
if( retnnode != NULL ) {
expr = NodeDtorExpr( expr, retnnode->u.symcg.symbol );
if( SymRequiresDtoring( retnnode->u.symcg.symbol ) ) {
expr = PtdCtoredExprType( expr, NULL, type );
}
}
type = StructType( type );
if( type != NULL && ! TypeDefined( type ) ) {
PTreeErrorExpr( expr, ERR_RETURN_UNDEFD_TYPE );
}
if( intr_map != NULL && expr->op != PT_ERROR ) {
#if _CPU == _AXP
if( intr_map->cgop == CO_VASTART ) {
expr = transformVaStart( expr );
} else {
expr = PTreeIntrinsicOperator( expr, intr_map->cgop );
}
#else
expr = PTreeIntrinsicOperator( expr, intr_map->cgop );
#endif
expr->flags |= PTF_MEANINGFUL | PTF_SIDE_EFF;
}
}
if( static_fn_this != NULL ) {
expr = NodeCommaIfSideEffect( static_fn_this, expr );
}
ArgListTempFree( alist, count );
PtListFree( ptlist, count );
return expr;
}
PTREE AsmStmt( void )
/*******************/
{
boolean uses_auto;
AUX_INFO *aux_info;
unsigned skip_token;
unsigned skip_alt_token;
PTREE expr;
TYPE fn_type;
TYPE ret_type;
SYMBOL sym;
char *fn_name;
auto VBUF code_buffer;
ppstate_t save_ppstate;
save_ppstate = PPState;
PPState = PPS_EOL;
PPStateAsm = TRUE;
VbufInit( &code_buffer );
NextTokenSkipEOL();
AsmSysInit();
if( ( CurToken == T_LEFT_BRACE ) || ( CurToken == T_ALT_LEFT_BRACE ) ) {
NextTokenSkipEOL();
for(;;) {
getAsmLine( &code_buffer );
if( CurToken == T_RIGHT_BRACE ) break;
if( CurToken == T_ALT_RIGHT_BRACE ) break;
if( CurToken == T_EOF ) break;
NextTokenSkipEOL();
}
skip_token = T_RIGHT_BRACE;
skip_alt_token = T_ALT_RIGHT_BRACE;
} else {
getAsmLine( &code_buffer );
skip_token = skip_alt_token = T_NULL;
}
PPStateAsm = FALSE;
PPState = save_ppstate;
if( ( CurToken == skip_token ) || ( CurToken == skip_alt_token ) ) {
NextToken();
}
if( AsmCodeAddress != 0 ) {
fn_name = NameDummy();
aux_info = AsmSysCreateAux( fn_name );
uses_auto = AsmSysInsertFixups( &code_buffer );
if( uses_auto ) {
AsmSysUsesAuto();
}
AsmSysDone();
ret_type = GetBasicType( TYP_VOID );
fn_type = MakeModifiableFunction( ret_type, NULL );
fn_type->u.f.pragma = aux_info;
fn_type = CheckDupType( fn_type );
sym = SymCreateFileScope( fn_type, SC_NULL, SF_NULL, fn_name );
LinkageSet( sym, "C" );
expr = genFnCall( fn_name );
} else {
expr = NULL;
}
AsmSysFini();
VbufFree( &code_buffer );
return( expr );
}
const_shared_ptr<Result> PrimitiveTypeSpecifier::GetType(
const TypeTable& type_table, AliasResolution resolution) const {
auto basic_type = GetBasicType();
auto result_type = PrimitiveType::FromBasicType(basic_type);
return make_shared<Result>(result_type, ErrorList::GetTerminator());
}
// this function is meant to be called from under debugger to see the
// proprieties of the given type id
extern "C" void DumpTI(ULONG ti)
{
SYMBOL_INFO sym = { sizeof(SYMBOL_INFO) };
sym.ModBase = 0x400000; // it's a constant under Win32
sym.TypeIndex = ti;
wxDbgHelpDLL::SymbolTag tag = wxDbgHelpDLL::SYMBOL_TAG_NULL;
DoGetTypeInfo(&sym, TI_GET_SYMTAG, &tag);
DoGetTypeInfo(&sym, TI_GET_TYPEID, &ti);
OutputDebugString(wxString::Format(_T("Type 0x%x: "), sym.TypeIndex));
wxString name = wxDbgHelpDLL::GetSymbolName(&sym);
if ( !name.empty() )
{
OutputDebugString(wxString::Format(_T("name=\"%s\", "), name.c_str()));
}
DWORD nested;
if ( !DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) )
{
nested = FALSE;
}
OutputDebugString(wxString::Format(_T("tag=%s%s"),
nested ? _T("nested ") : wxEmptyString,
TagString(tag).c_str()));
if ( tag == wxDbgHelpDLL::SYMBOL_TAG_UDT )
{
wxDbgHelpDLL::UdtKind udtKind;
if ( DoGetTypeInfo(&sym, TI_GET_UDTKIND, &udtKind) )
{
OutputDebugString(_T(" (") + UdtKindString(udtKind) + _T(')'));
}
}
wxDbgHelpDLL::DataKind kind = wxDbgHelpDLL::DATA_UNKNOWN;
if ( DoGetTypeInfo(&sym, TI_GET_DATAKIND, &kind) )
{
OutputDebugString(wxString::Format(
_T(", kind=%s"), KindString(kind).c_str()));
if ( kind == wxDbgHelpDLL::DATA_MEMBER )
{
DWORD ofs = 0;
if ( DoGetTypeInfo(&sym, TI_GET_OFFSET, &ofs) )
{
OutputDebugString(wxString::Format(_T(" (ofs=0x%x)"), ofs));
}
}
}
wxDbgHelpDLL::BasicType bt = GetBasicType(&sym);
if ( bt )
{
OutputDebugString(wxString::Format(_T(", type=%s"),
TypeString(bt).c_str()));
}
if ( ti != sym.TypeIndex )
{
OutputDebugString(wxString::Format(_T(", next ti=0x%x"), ti));
}
OutputDebugString(_T("\r\n"));
}
// The following can be extended for more types, if required
//
TYPE TypeFromCgType( // GET C++ TYPE FOR cg_type
cg_type cgtype ) // - code-gen type
{
TYPE type; // - C++ type
switch( cgtype ) {
case TY_UINT_1 :
type = GetBasicType( TYP_UCHAR );
break;
case TY_INT_1 :
type = GetBasicType( TYP_SCHAR );
break;
case TY_UINT_2 :
type = GetBasicType( TYP_USHORT );
break;
case TY_INT_2 :
type = GetBasicType( TYP_SSHORT );
break;
case TY_UINT_4 :
#if( TARGET_INT == 4 )
type = GetBasicType( TYP_UINT );
#else
type = GetBasicType( TYP_ULONG );
#endif
break;
case TY_INT_4 :
#if( TARGET_INT == 4 )
type = GetBasicType( TYP_SINT );
#else
type = GetBasicType( TYP_SLONG );
#endif
break;
case TY_INT_8 :
type = GetBasicType( TYP_SLONG64 );
break;
case TY_UINT_8 :
type = GetBasicType( TYP_ULONG64 );
break;
case TY_BOOLEAN :
case TY_INTEGER :
type = GetBasicType( TYP_SINT );
break;
case TY_UNSIGNED :
type = GetBasicType( TYP_UINT );
break;
default :
type = MakeInternalType( BETypeLength( cgtype ) );
break;
}
return type;
}
