encounter
/
MWCC
mirror of https://git.wuffs.org/MWCC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
MWCC/compiler_and_linker/unsorted/CExprConvMatch.c

2519 lines
81 KiB
C
Raw Normal View History

dump lots more code
2022-12-29 12:32:55 +00:00
#include "compiler/CExpr.h"
getting close to done
2023-01-10 11:05:21 +00:00
#include "compiler/CABI.h"
#include "compiler/CClass.h"
#include "compiler/CDecl.h"
#include "compiler/CError.h"
#include "compiler/CInt64.h"
#include "compiler/CFunc.h"
#include "compiler/CMachine.h"
#include "compiler/CMangler.h"
#include "compiler/CObjC.h"
#include "compiler/CParser.h"
#include "compiler/CScope.h"
#include "compiler/CTemplateFunc.h"
#include "compiler/CodeGen.h"
#include "compiler/CompilerTools.h"
#include "compiler/objects.h"
#include "compiler/scopes.h"
#include "compiler/templates.h"
#ifdef __MWERKS__
#pragma options align=mac68k
#endif
typedef struct StandardConv {
Type *type1;
Type *type2;
UInt32 qual1;
UInt32 qual2;
Boolean x10; // unknown
Boolean x11;
Boolean x12;
Boolean x13;
Boolean x14;
Boolean x15;
} StandardConv;
typedef enum EImplicitConvType {
ICT_0,
ICT_1,
ICT_2,
ICT_3
} EImplicitConvType;
typedef struct ImplicitConv {
EImplicitConvType type;
union {
struct {
Object *x2;
StandardConv standardConv;
} ic2;
struct {
StandardConv standardConv;
} ic3;
} u;
} ImplicitConv;
typedef struct ConversionTypeList {
struct ConversionTypeList *next;
Object *func;
Type *type;
UInt32 qual;
} ConversionTypeList;
typedef struct Match {
struct Match *next;
Object *object;
Object *specialfunc;
Type *type;
UInt32 qual;
Type *type2;
UInt32 qual2;
ImplicitConv conv[3];
} Match;
#ifdef __MWERKS__
#pragma options align=reset
#endif
// forward decls
static ENode *CExpr_DerivedToBase(ENode *expr, Type *type2, UInt32 qual2, Boolean flag1, Boolean flag2, Boolean flag3);
static Type *CExpr_GetImplictObjectParamType(Object *object, UInt32 *qual) {
Type *type;
CError_ASSERT(98, IS_TYPE_FUNC(object->type));
CError_ASSERT(99, TYPE_FUNC(object->type)->flags & FUNC_FLAGS_METHOD);
CError_ASSERT(100, !TYPE_METHOD(object->type)->x26);
CError_ASSERT(101, TYPE_METHOD(object->type)->args);
type = CDecl_NewRefPointerType(TYPE(TYPE_METHOD(object->type)->theclass));
*qual = TYPE_METHOD(object->type)->args->qual & Q_CV;
return type;
}
static Type *CExpr_GetParamType(Object *object, int index, UInt32 *qual) {
FuncArg *arg;
CError_ASSERT(120, IS_TYPE_FUNC(object->type));
CError_ASSERT(121, arg = TYPE_FUNC(object->type)->args);
if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type)))
CError_ASSERT(125, arg = arg->next);
while (index > 0) {
CError_ASSERT(129, arg = arg->next);
index--;
}
*qual = arg->qual & Q_CV;
return arg->type;
}
static Boolean CExpr_HasNParams(Object *object, int count) {
FuncArg *arg;
int i;
CError_ASSERT(146, IS_TYPE_FUNC(object->type));
CError_ASSERT(147, arg = TYPE_FUNC(object->type)->args);
if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type)))
arg = arg->next;
i = 0;
while (arg) {
arg = arg->next;
i++;
}
return i == count;
}
typedef enum TypeCompareMode {
TCM_0,
TCM_1,
TCM_2
} TypeCompareMode;
static Boolean CExpr_TypeCompare(Type *typeA, UInt32 qualA, Type *typeB, UInt32 qualB, TypeCompareMode mode) {
if (typeA->type != typeB->type)
return 0;
switch (mode) {
case TCM_0:
while (1) {
switch (typeA->type) {
case TYPEPOINTER:
typeA = TPTR_TARGET(typeA);
typeB = TPTR_TARGET(typeB);
if (typeA->type != typeB->type)
return 0;
continue;
case TYPEMEMBERPOINTER:
if (!is_typesame(TYPE_MEMBER_POINTER(typeA)->ty2, TYPE_MEMBER_POINTER(typeB)->ty2))
return 0;
typeA = TYPE_MEMBER_POINTER(typeA)->ty1;
typeB = TYPE_MEMBER_POINTER(typeB)->ty1;
if (typeA->type != typeB->type)
return 0;
continue;
}
break;
}
break;
case TCM_1:
switch (typeA->type) {
case TYPEPOINTER:
if ((qualA & Q_CV) != (qualB & Q_CV))
return 0;
typeA = TPTR_TARGET(typeA);
typeB = TPTR_TARGET(typeB);
break;
case TYPEMEMBERPOINTER:
if ((qualA & Q_CV) != (qualB & Q_CV))
return 0;
if (!is_typesame(TYPE_MEMBER_POINTER(typeA)->ty2, TYPE_MEMBER_POINTER(typeB)->ty2))
return 0;
typeA = TYPE_MEMBER_POINTER(typeA)->ty1;
typeB = TYPE_MEMBER_POINTER(typeB)->ty1;
break;
}
break;
case TCM_2:
if ((qualA & Q_CV) != (qualB & Q_CV))
return 0;
break;
}
return is_typesame(typeA, typeB);
}
static int CExpr_IsReferenceCompatible(Type *typeA, UInt32 qualA, Type *typeB, UInt32 qualB) {
if (CParser_IsSameOrMoreCVQualified(CParser_GetCVTypeQualifiers(typeA, qualA), CParser_GetCVTypeQualifiers(typeB, qualB))) {
if (CExpr_TypeCompare(typeA, qualA, typeB, qualB, TCM_1))
return 1;
if (IS_TYPE_CLASS(typeB) && IS_TYPE_CLASS(typeA)) {
short depth;
Boolean isambigbase;
if (CClass_GetBasePath(TYPE_CLASS(typeB), TYPE_CLASS(typeA), &depth, &isambigbase))
return 2;
}
}
return 0;
}
static Boolean CExpr_IsBaseOf(TypeClass *baseclass, TypeClass *superclass) {
ClassList *base;
for (base = superclass->bases; base; base = base->next) {
if (base->base == baseclass || CExpr_IsBaseOf(baseclass, base->base))
return 1;
}
return 0;
}
static Boolean CExpr_IsBetterClassConversion(TypeClass *a, TypeClass *b, TypeClass *c, TypeClass *d) {
if (a == c)
return CExpr_IsBaseOf(d, b);
if (b == d)
return CExpr_IsBaseOf(a, c);
return 0;
}
inline Boolean Inline_501D40(Type *a, Type *b) {
return (a == TYPE(&stbool)) && (IS_TYPE_POINTER_ONLY(b) || IS_TYPE_MEMBERPOINTER(b));
}
static Boolean CExpr_IsBetterStandardConv(StandardConv *a, StandardConv *b) {
Boolean flag10;
Boolean flag3;
flag10 = 1;
flag3 = 0;
if (b->x11) {
if (!a->x11)
flag3 = 1;
} else {
if (a->x11)
flag10 = 0;
}
if (b->x12) {
if (!a->x12)
flag3 = 1;
} else {
if (a->x12)
flag10 = 0;
}
if (b->x13) {
if (a->x13) {
if (Inline_501D40(b->type2, b->type1)) {
if (!Inline_501D40(a->type2, a->type1))
return 1;
} else {
if (Inline_501D40(a->type2, a->type1))
return 0;
}
} else {
flag3 = 1;
}
} else {
if (a->x13)
flag10 = 0;
}
if (flag10 && flag3)
return 1;
if (!a->x13) {
if (b->x13)
return 1;
if (a->x12) {
if (!b->x12)
return 0;
} else {
if (b->x12)
return 1;
}
} else {
if (!b->x13)
return 0;
}
if (
IS_TYPE_POINTER_ONLY(a->type1) &&
IS_TYPE_CLASS(TPTR_TARGET(a->type1)) &&
IS_TYPE_POINTER_ONLY(a->type2) &&
IS_TYPE_POINTER_ONLY(b->type1) &&
IS_TYPE_CLASS(TPTR_TARGET(b->type1)) &&
IS_TYPE_POINTER_ONLY(b->type2)
)
{
if (TPTR_TARGET(b->type2) == &stvoid) {
if (TPTR_TARGET(a->type2) == &stvoid) {
if (CExpr_IsBaseOf(TYPE_CLASS(TPTR_TARGET(a->type1)), TYPE_CLASS(TPTR_TARGET(b->type1))))
return 1;
} else {
if (TPTR_TARGET(a->type1) == TPTR_TARGET(b->type1) && IS_TYPE_CLASS(TPTR_TARGET(a->type2)))
return 1;
}
} else if (IS_TYPE_CLASS(TPTR_TARGET(a->type2)) && IS_TYPE_CLASS(TPTR_TARGET(b->type2))) {
if (CExpr_IsBetterClassConversion(
TYPE_CLASS(TPTR_TARGET(a->type1)),
TYPE_CLASS(TPTR_TARGET(a->type2)),
TYPE_CLASS(TPTR_TARGET(b->type1)),
TYPE_CLASS(TPTR_TARGET(b->type2))
))
return 1;
}
}
if (
IS_TYPE_CLASS(a->type1) &&
IS_TYPE_CLASS(a->type2) &&
IS_TYPE_CLASS(b->type1) &&
IS_TYPE_CLASS(b->type2) &&
CExpr_IsBetterClassConversion(
TYPE_CLASS(a->type1),
TYPE_CLASS(a->type2),
TYPE_CLASS(b->type1),
TYPE_CLASS(b->type2)
)
)
return 1;
if (
IS_TYPE_MEMBERPOINTER(a->type1) &&
IS_TYPE_MEMBERPOINTER(a->type2) &&
IS_TYPE_MEMBERPOINTER(b->type1) &&
IS_TYPE_MEMBERPOINTER(b->type2) &&
IS_TYPE_CLASS(TYPE_MEMBER_POINTER(a->type1)->ty2) &&
IS_TYPE_CLASS(TYPE_MEMBER_POINTER(a->type2)->ty2) &&
IS_TYPE_CLASS(TYPE_MEMBER_POINTER(b->type1)->ty2) &&
IS_TYPE_CLASS(TYPE_MEMBER_POINTER(b->type2)->ty2) &&
CExpr_IsBetterClassConversion(
TYPE_CLASS(TYPE_MEMBER_POINTER(b->type1)->ty2),
TYPE_CLASS(TYPE_MEMBER_POINTER(b->type2)->ty2),
TYPE_CLASS(TYPE_MEMBER_POINTER(a->type1)->ty2),
TYPE_CLASS(TYPE_MEMBER_POINTER(a->type2)->ty2)
)
)
return 1;
if (
a->x14 &&
b->x14 &&
CExpr_TypeCompare(a->type2, a->qual2, b->type2, b->qual2, TCM_1) &&
CParser_IsMoreCVQualified(
CParser_GetTypeQualifiers(b->type2, b->qual2),
CParser_GetTypeQualifiers(a->type2, a->qual2)
)
)
return 1;
return 0;
}
static Boolean CExpr_IsBetterImplicitConv(ImplicitConv *a, ImplicitConv *b) {
if (a->type > b->type)
return 1;
if (a->type != b->type)
return 0;
if (a->type == ICT_3)
return CExpr_IsBetterStandardConv(&a->u.ic3.standardConv, &b->u.ic3.standardConv);
if (a->type == ICT_2 && a->u.ic2.x2 == b->u.ic2.x2 && CExpr_IsBetterStandardConv(&a->u.ic2.standardConv, &b->u.ic2.standardConv))
return 1;
return 0;
}
typedef enum SSCRMode {
SSCR_0,
SSCR_1,
SSCR_2
} SSCRMode;
static Boolean CExpr_SetupStandardConversionResult(ENode *expr, Type *type2, UInt32 qual2, SSCRMode mode, Boolean x14, Boolean refFlag, StandardConv *result) {
UInt32 cv1;
UInt32 cv2;
if (x14) {
if (!CParser_IsConst(type2, qual2)) {
if (!refFlag && !CExpr_IsLValue(expr))
return 0;
if (mode != SSCR_0 && !IS_TYPE_CLASS(type2))
return 0;
}
cv2 = CParser_GetTypeQualifiers(type2, qual2) & Q_CV;
cv1 = CParser_GetTypeQualifiers(expr->rtype, ENODE_QUALS(expr)) & Q_CV;
if (cv2 != cv1 && !CParser_IsMoreCVQualified(cv2, cv1))
return 0;
}
memclrw(result, sizeof(StandardConv));
result->type2 = type2;
result->qual2 = qual2;
result->type1 = expr->rtype;
result->qual1 = ENODE_QUALS(expr);
result->x14 = x14;
switch (mode) {
case SSCR_0:
break;
case SSCR_1:
result->x12 = 1;
break;
case SSCR_2:
result->x13 = 1;
break;
default:
CError_FATAL(581);
}
return 1;
}
typedef enum MysteryEnum {
ME_0,
ME_1,
ME_255 = 255
} MysteryEnum;
inline MysteryEnum Inline_501FF0(UInt32 qual1, UInt32 qual2) {
if ((qual1 & Q_CV) == (qual2 & Q_CV))
return ME_0;
if (((qual2 & Q_CONST) && !(qual1 & Q_CONST)) || ((qual2 & Q_VOLATILE) && !(qual1 & Q_VOLATILE)))
return ME_255;
return ME_1;
}
static Boolean CExpr_SetQualConversionResult(Type *type1, UInt32 qual1, Type *type2, UInt32 qual2, StandardConv *result) {
Boolean flag = 1;
UInt32 cv1;
UInt32 cv2;
while (1) {
cv1 = CParser_GetCVTypeQualifiers(type1, qual1);
cv2 = CParser_GetCVTypeQualifiers(type2, qual2);
switch (Inline_501FF0(cv1, cv2)) {
case ME_0:
break;
case ME_1:
result->x11 = 1;
if (!flag)
return 0;
break;
default:
return 0;
}
if (!(cv1 & Q_CONST))
flag = 0;
if (IS_TYPE_POINTER_ONLY(type1)) {
CError_ASSERT(635, IS_TYPE_POINTER_ONLY(type2));
type1 = TPTR_TARGET(type1);
type2 = TPTR_TARGET(type2);
} else {
if (!IS_TYPE_MEMBERPOINTER(type1))
return 1;
CError_ASSERT(642, IS_TYPE_MEMBERPOINTER(type2));
type1 = TYPE_MEMBER_POINTER(type1)->ty1;
type2 = TYPE_MEMBER_POINTER(type2)->ty1;
}
}
}
static Boolean CExpr_OverloadFuncMatch(NameSpaceObjectList *list, TemplArg *templargs, Type *type, ENode **outExpr) {
Object *object;
TemplFuncInstance *inst;
ENode *expr;
FuncArg *arg;
int i;
ObjectList *objlist;
Object *object26;
ObjectList *objlist25;
ObjectList *objlist24;
Boolean flag23;
if (!IS_TYPE_POINTER_ONLY(type) || !IS_TYPE_FUNC(type = TPTR_TARGET(type)))
return 0;
object26 = NULL;
objlist25 = NULL;
objlist24 = NULL;
flag23 = 0;
while (list) {
object = OBJECT(list->object);
if (object->otype == OT_OBJECT) {
if (IS_TEMPL_FUNC(object->type)) {
if (!flag23 && CTempl_CanDeduceFunc(object, TYPE_FUNC(type), templargs)) {
CError_ASSERT(685, inst = CTempl_DeduceFunc(object, TYPE_FUNC(type), templargs, NULL, 0));
if (is_typesame(inst->object->type, type)) {
objlist = lalloc(sizeof(ObjectList));
objlist->next = objlist24;
objlist->object = object;
objlist24 = objlist;
if (object26 && object26 != inst->object) {
objlist = lalloc(sizeof(ObjectList));
objlist->next = objlist25;
objlist->object = inst->object;
objlist25 = objlist;
} else {
object26 = inst->object;
}
}
}
} else if (is_typesame(object->type, type)) {
if (object26 && flag23) {
Object *checkA, *checkB;
checkA = object;
if (checkA->datatype == DALIAS)
checkA = checkA->u.alias.object;
checkB = object26;
if (checkB->datatype == DALIAS)
checkB = checkB->u.alias.object;
if (checkA != checkB) {
objlist = lalloc(sizeof(ObjectList));
objlist->next = objlist25;
objlist->object = object;
objlist25 = objlist;
}
} else {
objlist25 = NULL;
object26 = object;
}
flag23 = 1;
}
}
list = list->next;
}
if (object26) {
if (outExpr) {
if (objlist25) {
i = 0;
for (arg = TYPE_FUNC(object->type)->args; arg; arg = arg->next)
i++;
if (!flag23 && (object = CTempl_PartialOrdering(objlist24->object, objlist24->next, i))) {
CError_ASSERT(741, inst = CTempl_DeduceFunc(object, TYPE_FUNC(type), templargs, NULL, 0));
object26 = inst->object;
} else {
CError_OverloadedFunctionError(object26, objlist25);
}
}
expr = CExpr_MakeObjRefNode(object26, 1);
*outExpr = expr;
expr->rtype = CDecl_NewPointerType(object26->type);
expr->flags = object->qual & ENODE_FLAG_QUALS;
object26->flags |= OBJECT_FLAGS_UNUSED;
if (object26->datatype == DINLINEFUNC)
CError_Error(CErrorStr175);
}
return 1;
}
return 0;
}
static Boolean CExpr_StandardConversionMatch(ENode *expr, Type *type2, UInt32 qual2, Boolean x14, StandardConv *result) {
Type *type1;
UInt32 qual1;
Boolean refFlag;
Type *inner2;
Type *inner1;
SSCRMode mode;
NameSpaceObjectList list;
if (IS_TYPE_REFERENCE(type2)) {
type2 = TPTR_TARGET(type2);
if (IS_TYPE_POINTER_ONLY(type2))
expr = pointer_generation(expr);
refFlag = 1;
} else {
if (
(IS_TYPE_ARRAY(expr->rtype) && !IS_TYPE_ARRAY(type2)) ||
(IS_TYPE_FUNC(expr->rtype) && !IS_TYPE_FUNC(type2))
)
expr = pointer_generation(expr);
refFlag = 0;
}
type1 = expr->rtype;
qual1 = ENODE_QUALS(expr);
if (IS_TYPE_POINTER_ONLY(type2)) {
if (ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval)) {
if (IS_TYPE_INT(type1) || (!copts.cplusplus && IS_TYPE_ENUM(type1)))
return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
}
if (
IS_TYPE_INT(expr->rtype) &&
ENODE_IS_INDIRECT_TO(expr, EOBJREF) &&
(expr->data.monadic->data.objref->qual & Q_10000) &&
CInt64_IsZero(&expr->data.monadic->data.objref->u.data.u.intconst)
)
return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
if (ENODE_IS(expr, EOBJLIST))
return CExpr_OverloadFuncMatch(expr->data.objlist.list, expr->data.objlist.templargs, type2, NULL) &&
CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
if (ENODE_IS(expr, EOBJREF) && IS_TEMPL_FUNC(expr->data.objref->type)) {
list.next = NULL;
list.object = OBJ_BASE(expr->data.objref);
return CExpr_OverloadFuncMatch(&list, NULL, type2, NULL) &&
CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
}
if (IS_TYPE_POINTER_ONLY(type1)) {
if (
ENODE_IS(expr, ESTRINGCONST) &&
TPTR_TARGET(type2) == TPTR_TARGET(type1) &&
!(qual2 & Q_CONST) &&
(
TPTR_TARGET(type2) == TYPE(&stchar) ||
TPTR_TARGET(type2) == TYPE(&stunsignedchar) ||
TPTR_TARGET(type2) == CParser_GetWCharType()
)
)
{
if (
CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result) &&
CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1 & ~Q_CONST, result)
)
{
result->x11 = 1;
return 1;
} else {
return 0;
}
}
if (copts.objective_c && CObjC_IsCompatibleType(expr->rtype, type2))
return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
if (IS_TYPE_VOID(TPTR_TARGET(type2)) || (!copts.cplusplus && IS_TYPE_VOID(TPTR_TARGET(type1)))) {
if (CExpr_SetupStandardConversionResult(expr, type2, qual2, IS_TYPE_VOID(TPTR_TARGET(type1)) ? SSCR_0 : SSCR_2, refFlag, x14, result)) {
switch (Inline_501FF0(qual2, CParser_GetCVTypeQualifiers(TPTR_TARGET(type1), qual1))) {
case ME_1:
result->x11 = 1;
case ME_0:
return 1;
default:
return 0;
}
} else {
return 0;
}
}
inner2 = TPTR_TARGET(type2);
inner1 = TPTR_TARGET(type1);
while (1) {
if (inner2->type != inner1->type)
break;
switch (inner2->type) {
case TYPEPOINTER:
inner2 = TPTR_TARGET(inner2);
inner1 = TPTR_TARGET(inner1);
continue;
case TYPEMEMBERPOINTER:
if (!is_typesame(TYPE_MEMBER_POINTER(inner2)->ty2, TYPE_MEMBER_POINTER(inner1)->ty2))
break;
inner2 = TYPE_MEMBER_POINTER(inner2)->ty1;
inner1 = TYPE_MEMBER_POINTER(inner1)->ty1;
if (!IS_TYPE_POINTER_ONLY(inner2) && !IS_TYPE_MEMBERPOINTER(inner2)) {
if (!is_memberpointerequal(inner2, inner1))
break;
if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result))
return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
else
return 0;
}
continue;
default:
if (!is_typesame(inner2, inner1))
break;
if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result))
return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
else
return 0;
}
break;
}
if (IS_TYPE_CLASS(TPTR_TARGET(type2)) && IS_TYPE_CLASS(TPTR_TARGET(type1))) {
short depth;
Boolean isambigbase;
if (CClass_GetBasePath(TYPE_CLASS(TPTR_TARGET(type1)), TYPE_CLASS(TPTR_TARGET(type2)), &depth, &isambigbase)) {
if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
else
return 0;
}
}
}
if (copts.mpwc_relax && !copts.cplusplus && IS_TYPE_POINTER_ONLY(type1)) {
if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
return 1;
}
return 0;
}
if (is_typesame(type2, type1))
return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
if (type2 == TYPE(&stbool)) {
switch (type1->type) {
case TYPEINT:
case TYPEFLOAT:
case TYPEENUM:
case TYPEMEMBERPOINTER:
case TYPEPOINTER:
return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result);
default:
return 0;
}
}
if (IS_TYPE_MEMBERPOINTER(type2)) {
if (ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval)) {
if (IS_TYPE_INT(type1) || (!copts.cplusplus && IS_TYPE_ENUM(type1)))
return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result);
}
if (ENODE_IS(expr, EMEMBER)) {
expr = getpointertomemberfunc(expr, type2, 0);
type1 = expr->rtype;
}
if (IS_TYPE_MEMBERPOINTER(type1)) {
short depth;
Boolean isambigbase;
CError_ASSERT(996, IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type2)->ty2) && IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type1)->ty2));
if (!is_memberpointerequal(TYPE_MEMBER_POINTER(type2)->ty1, TYPE_MEMBER_POINTER(type1)->ty1))
return 0;
if (
TYPE_MEMBER_POINTER(type2)->ty2 == TYPE_MEMBER_POINTER(type1)->ty2 ||
CClass_GetBasePath(TYPE_CLASS(TYPE_MEMBER_POINTER(type2)->ty2), TYPE_CLASS(TYPE_MEMBER_POINTER(type1)->ty2), &depth, &isambigbase)
)
{
if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
return CExpr_SetQualConversionResult(TYPE_MEMBER_POINTER(type2)->ty1, qual2, TYPE_MEMBER_POINTER(type1)->ty1, qual1, result);
else
return 0;
}
}
return 0;
}
mode = SSCR_2;
switch (type1->type) {
case TYPEINT:
switch (type2->type) {
case TYPEINT:
if (TYPE_INTEGRAL(type1)->integral < IT_INT) {
if (type2 == TYPE(&stsignedint)) {
if (type1->size < type2->size || !is_unsigned(type1))
mode = SSCR_1;
} else if (type2 == TYPE(&stunsignedint)) {
if (type2->size == type1->size && is_unsigned(type1))
mode = SSCR_1;
}
}
break;
case TYPEFLOAT:
break;
case TYPEENUM:
if (copts.cplusplus)
return 0;
break;
default:
return 0;
}
break;
case TYPEFLOAT:
switch (type2->type) {
case TYPEINT:
break;
case TYPEFLOAT:
if (type2 == TYPE(&stdouble)) {
if (type1 == TYPE(&stfloat) || type1 == TYPE(&stshortdouble))
mode = SSCR_1;
}
break;
case TYPEENUM:
if (copts.cplusplus)
return 0;
break;
default:
return 0;
}
break;
case TYPEENUM:
switch (type2->type) {
case TYPEINT:
if (TYPE_INTEGRAL(TYPE_ENUM(expr->rtype)->enumtype)->integral < IT_INT) {
if (type1->size == type2->size && is_unsigned(TYPE_ENUM(type1)->enumtype)) {
if (type2 == TYPE(&stunsignedint))
mode = SSCR_1;
} else {
if (type2 == TYPE(&stsignedint))
mode = SSCR_1;
}
} else {
if (TYPE_ENUM(type1)->enumtype == type2)
mode = SSCR_1;
}
break;
case TYPEFLOAT:
break;
case TYPEENUM:
if (copts.cplusplus)
return 0;
break;
default:
return 0;
}
break;
case TYPECLASS: {
short depth;
Boolean isambigbase;
if (!IS_TYPE_CLASS(type1) || !CClass_GetBasePath(TYPE_CLASS(type1), TYPE_CLASS(type2), &depth, &isambigbase))
return 0;
break;
}
default:
return 0;
}
return CExpr_SetupStandardConversionResult(expr, type2, qual2, mode, refFlag, x14, result);
}
static ENode *CExpr_UserConversion(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result, Boolean flag1, Boolean isExplicit, Boolean flag3) {
Object *object28;
Object *object27;
Object *object26;
ObjectList *objlist25;
ObjectList *objlist24;
ObjectList *objlist;
TypeFunc *tfunc23;
Type *tmptype23;
NameSpaceObjectList *list22;
Boolean flag22;
Boolean flag21;
FuncArg *arg21;
Boolean flag20;
ENode *newExpr;
ENode *funcref;
ENode *tmpExpr;
ENodeList *arglist;
UInt32 q1;
UInt32 q2;
StandardConv sc3;
StandardConv sc2;
StandardConv sc1;
ConversionIterator convIter;
ENodeList myarglist;
ObjectList myobjlist;
BClassList path;
object28 = NULL;
object27 = NULL;
objlist25 = NULL;
objlist24 = NULL;
if (type2->size == 0)
CDecl_CompleteType(type2);
if (expr->rtype->size == 0)
CDecl_CompleteType(expr->rtype);
if (IS_TYPE_CLASS(expr->rtype)) {
CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr->rtype));
flag22 = 1;
while ((object26 = CExpr_ConversionIteratorNext(&convIter))) {
tfunc23 = TYPE_FUNC(object26->type);
if (tfunc23->flags & FUNC_FLAGS_100000) {
object26 = CTempl_DeduceFromConversion(object26, type2, qual2);
if (!object26)
continue;
tfunc23 = TYPE_FUNC(object26->type);
}
if (flag3) {
if (
!IS_TYPE_REFERENCE(tfunc23->functype) ||
!CExpr_IsReferenceCompatible(type2, qual2, TPTR_TARGET(tfunc23->functype), tfunc23->qual)
)
continue;
}
CError_ASSERT(1230, tfunc23->args && IS_TYPE_POINTER_ONLY(tfunc23->args->type));
q1 = ENODE_QUALS(expr);
q2 = tfunc23->args->qual;
if ((q1 & Q_CV) != (q2 & Q_CV)) {
if (!flag22)
continue;
if ((q1 & Q_CONST) && !(q2 & Q_CONST))
continue;
if ((q1 & Q_VOLATILE) && !(q2 & Q_VOLATILE))
continue;
flag21 = 1;
} else {
flag21 = 0;
}
newExpr = CExpr_NewENode(ETEMP);
newExpr->rtype = tfunc23->functype;
newExpr->flags = tfunc23->qual & ENODE_FLAG_QUALS;
flag20 = 0;
if (IS_TYPE_REFERENCE(newExpr->rtype)) {
newExpr->rtype = TPTR_TARGET(newExpr->rtype);
if (!CParser_IsConst(newExpr->rtype, tfunc23->qual)) {
newExpr = makemonadicnode(newExpr, EINDIRECT);
newExpr->data.monadic->rtype = TYPE(&void_ptr);
newExpr = makemonadicnode(newExpr, EINDIRECT);
newExpr->data.monadic->rtype = TYPE(&void_ptr);
flag20 = 1;
}
}
if (CExpr_StandardConversionMatch(newExpr, type2, qual2, 0, &sc1)) {
if (flag22 && !flag21) {
object28 = NULL;
objlist25 = NULL;
flag22 = 0;
}
if (object28 && object28 != object26) {
if (CExpr_IsBetterStandardConv(&sc3, &sc1))
continue;
if (!CExpr_IsBetterStandardConv(&sc1, &sc3)) {
objlist = lalloc(sizeof(ObjectList));
objlist->next = objlist25;
objlist->object = object28;
objlist25 = objlist;
} else {
objlist25 = NULL;
}
}
object28 = object26;
sc3 = sc1;
sc3.x15 = flag20;
}
}
}
if (!flag3 && IS_TYPE_CLASS(type2) && (list22 = CClass_Constructor(TYPE_CLASS(type2)))) {
for (; list22; list22 = list22->next) {
object26 = OBJECT(list22->object);
if (
object26->otype == OT_OBJECT &&
IS_TYPE_FUNC(tfunc23 = TYPE_FUNC(object26->type)) &&
(isExplicit || !(object26->qual & Q_EXPLICIT))
)
{
if (tfunc23->flags & FUNC_FLAGS_100000) {
myarglist.next = NULL;
myarglist.node = expr;
object26 = CTempl_DeduceFromFunctionCall(object26, NULL, &myarglist);
if (!object26)
continue;
tfunc23 = TYPE_FUNC(object26->type);
}
if (!(arg21 = tfunc23->args))
continue;
if (!(arg21 = arg21->next))
continue;
if ((TYPE_CLASS(type2)->flags & CLASS_FLAGS_20) && !(arg21 = arg21->next))
continue;
if (arg21 == &elipsis)
continue;
if (arg21->next && !arg21->next->dexpr && arg21->next != &elipsis)
continue;
tmptype23 = arg21->type;
if (IS_TYPE_REFERENCE(tmptype23)) {
tmptype23 = TPTR_TARGET(tmptype23);
if (!CParser_IsConst(tmptype23, arg21->qual) && !CExpr_IsLValue(expr))
continue;
}
if (CExpr_StandardConversionMatch(expr, tmptype23, arg21->qual, 0, &sc1)) {
if (object27) {
if (!object26->u.func.inst && !object27->u.func.inst)
continue;
if (CExpr_IsBetterStandardConv(&sc2, &sc1))
continue;
if (!CExpr_IsBetterStandardConv(&sc1, &sc2)) {
if (!object26->u.func.inst && object27->u.func.inst) {
objlist24 = NULL;
} else {
objlist = lalloc(sizeof(ObjectList));
objlist->next = objlist25;
objlist->object = object28;
objlist25 = objlist;
}
} else {
objlist25 = NULL;
}
}
object27 = object26;
sc2 = sc1;
}
}
}
}
if (object28 && object27) {
if (!CExpr_IsBetterStandardConv(&sc2, &sc3)) {
if (!CExpr_IsBetterStandardConv(&sc3, &sc2)) {
if (result) {
result->type = ICT_2;
result->u.ic2.x2 = object28;
result->u.ic2.standardConv = sc3;
}
if (flag1) {
myobjlist.next = NULL;
myobjlist.object = object27;
CError_OverloadedFunctionError(object28, &myobjlist);
}
} else {
object27 = NULL;
}
} else {
object28 = NULL;
}
}
if (object28) {
if (result) {
result->type = ICT_2;
result->u.ic2.x2 = object28;
result->u.ic2.standardConv = sc3;
}
if (!flag1)
return expr;
if (objlist25)
CError_OverloadedFunctionError(object28, objlist25);
tfunc23 = TYPE_FUNC(object28->type);
CError_ASSERT(1416, IS_TYPEFUNC_METHOD(tfunc23));
funcref = create_objectrefnode(object28);
object28->flags |= OBJECT_FLAGS_UNUSED;
arglist = lalloc(sizeof(ENodeList));
arglist->next = NULL;
expr = getnodeaddress(expr, 0);
arglist->node = CExpr_AssignmentPromotion(
expr,
CDecl_NewPointerType(TYPE(TYPE_METHOD(tfunc23)->theclass)),
expr->flags,
0);
newExpr = lalloc(sizeof(ENode));
newExpr->type = EFUNCCALL;
newExpr->cost = 4;
newExpr->rtype = tfunc23->functype;
newExpr->flags = tfunc23->qual & ENODE_FLAG_QUALS;
newExpr->data.funccall.funcref = funcref;
newExpr->data.funccall.args = arglist;
newExpr->data.funccall.functype = TYPE_FUNC(object28->type);
newExpr = CExpr_AdjustFunctionCall(newExpr);
newExpr = checkreference(newExpr);
if (newExpr->rtype != type2) {
if (flag3) {
tmpExpr = CExpr_DerivedToBase(newExpr, type2, qual2, 1, 0, 1);
if (tmpExpr)
return tmpExpr;
}
newExpr = CExpr_Convert(newExpr, type2, qual2, 0, 1);
}
return newExpr;
}
if (object27) {
if (result) {
result->type = ICT_2;
result->u.ic2.x2 = object27;
result->u.ic2.standardConv = sc2;
}
if (!flag1)
return expr;
if (objlist24)
CError_OverloadedFunctionError(object27, objlist24);
arglist = lalloc(sizeof(ENodeList));
arglist->next = NULL;
arglist->node = expr;
if (TYPE_CLASS(type2)->flags & CLASS_FLAGS_20) {
arglist->next = lalloc(sizeof(ENodeList));
arglist->next->node = expr;
arglist->next->next = NULL;
arglist->node = intconstnode(TYPE(&stsignedshort), 1);
}
path.next = NULL;
path.type = type2;
tmpExpr = makemonadicnode(create_temp_node(type2), EINDIRECT);
tmpExpr->rtype = type2;
newExpr = CExpr_GenericFuncCall(
&path, tmpExpr, 0, object27, NULL, NULL, arglist, 0, 0, 1
);
if (ENODE_IS2(newExpr, EFUNCCALL, EFUNCCALLP)) {
newExpr->rtype = CDecl_NewPointerType(type2);
newExpr = makemonadicnode(newExpr, EINDIRECT);
newExpr->rtype = type2;
}
return newExpr;
}
return NULL;
}
static Boolean CExpr_UserConversionMatch(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result) {
Boolean flag;
if (IS_TYPE_REFERENCE(type2)) {
type2 = TPTR_TARGET(type2);
flag = !CParser_IsConst(type2, qual2);
} else {
expr = pointer_generation(expr);
flag = 0;
}
if (CExpr_UserConversion(expr, type2, qual2, result, 0, 0, flag))
return 1;
return 0;
}
static Boolean CExpr_ImplicitConversionMatch(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result) {
if (CExpr_StandardConversionMatch(expr, type2, qual2, 0, &result->u.ic3.standardConv)) {
result->type = ICT_3;
return 1;
}
if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type2) || (IS_TYPE_REFERENCE(type2) && IS_TYPE_CLASS(TPTR_TARGET(type2)))) {
if (CExpr_UserConversionMatch(expr, type2, qual2, result)) {
result->type = ICT_2;
return 1;
}
}
return 0;
}
Boolean CExpr_CanImplicitlyConvert(ENode *expr, Type *type2, UInt32 qual2) {
ImplicitConv result;
return CExpr_ImplicitConversionMatch(expr, type2, qual2, &result);
}
static ENode *CExpr_DerivedToBase(ENode *expr, Type *type2, UInt32 qual2, Boolean flag1, Boolean nullcheckflag, Boolean pathcheckflag) {
BClassList *path;
short depth;
Boolean isambigbase;
if (
IS_TYPE_CLASS(type2) &&
IS_TYPE_CLASS(expr->rtype) &&
(path = CClass_GetBasePath(TYPE_CLASS(expr->rtype), TYPE_CLASS(type2), &depth, &isambigbase))
)
{
if (isambigbase)
CError_Error(CErrorStr188);
if (flag1)
CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC);
if (pathcheckflag) {
expr = getnodeaddress(expr, 0);
expr = makemonadicnode(CExpr_ClassPointerCast(path, expr, nullcheckflag), EINDIRECT);
expr->rtype = type2;
expr->flags = qual2 & ENODE_FLAG_QUALS;
}
return expr;
}
else {
return NULL;
}
}
static ENode *CExpr_ClassReferenceConversion(ENode *expr, Type *type2, UInt32 qual2, Boolean pathcheckflag) {
int refcompat;
if (CExpr_IsLValue(expr) && IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype)) {
refcompat = CExpr_IsReferenceCompatible(type2, 0, expr->rtype, 0);
if (refcompat > 0) {
if (refcompat == 2) {
CError_ASSERT(1668, IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype));
expr = CExpr_DerivedToBase(expr, type2, qual2, pathcheckflag, 0, 1);
}
expr->flags = qual2 & ENODE_FLAG_QUALS;
return expr;
}
refcompat = CExpr_IsReferenceCompatible(expr->rtype, 0, type2, 0);
if (refcompat > 0) {
expr = CClass_ClassPointerCast(
getnodeaddress(expr, 0),
TYPE_CLASS(expr->rtype), TYPE_CLASS(type2),
1, 1, pathcheckflag
);
CError_ASSERT(1680, IS_TYPE_POINTER_ONLY(expr->rtype));
expr = makemonadicnode(expr, EINDIRECT);
expr->rtype = type2;
expr->flags = qual2 & ENODE_FLAG_QUALS;
return expr;
}
}
if (IS_TYPE_CLASS(expr->rtype)) {
if ((expr = CExpr_UserConversion(expr, type2, qual2, NULL, 1, 0, 1)))
return expr;
}
return NULL;
}
static ENode *CExpr_BindToReference(ENode *expr, Type *type2, UInt32 qual2) {
UInt32 cv;
int refcompat;
ENode *tmp;
cv = CParser_GetCVTypeQualifiers(type2, qual2);
if (CExpr_IsLValue(expr)) {
refcompat = CExpr_IsReferenceCompatible(type2, qual2, expr->rtype, ENODE_QUALS(expr));
if (refcompat > 0) {
if (refcompat == 2) {
CError_ASSERT(1718, IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype));
expr = CExpr_DerivedToBase(expr, type2, qual2, 1, 0, 1);
}
return getnodeaddress(expr, 0);
}
} else if (IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype)) {
refcompat = CExpr_IsReferenceCompatible(type2, qual2, expr->rtype, ENODE_QUALS(expr));
if (refcompat > 0) {
if (refcompat == 2)
expr = CExpr_DerivedToBase(expr, type2, qual2, 1, 0, 1);
return getnodeaddress(expr, 0);
}
}
if (IS_TYPE_CLASS(expr->rtype)) {
if ((tmp = CExpr_UserConversion(expr, type2, qual2, NULL, 1, 0, 1)))
return getnodeaddress(tmp, 0);
}
if (!(cv & Q_CONST))
CError_Error(CErrorStr228);
if (cv & Q_VOLATILE)
CError_Error(CErrorStr259);
if (expr->rtype != type2)
expr = CExpr_Convert(expr, type2, qual2, 0, 1);
if (!CExpr_IsLValue(expr)) {
expr = CExpr_LValue(expr, 0, 0);
if (!ENODE_IS(expr, EINDIRECT))
expr = get_address_of_temp_copy(expr, 1);
else
expr = getnodeaddress(expr, 0);
} else {
expr = getnodeaddress(expr, 0);
}
return expr;
}
ENode *CExpr_Convert(ENode *expr, Type *type, UInt32 qual, Boolean isExplicit, Boolean flag2) {
UInt32 cv;
ENode *refExpr;
ENode *newExpr;
Type *typeCopy;
NameSpaceObjectList myList;
cv = qual & Q_CV;
if (copts.cpp_extensions && is_typesame(expr->rtype, type) && !ENODE_IS(expr, EOBJLIST)) {
expr = CExpr_RewriteConst(expr);
expr->rtype = type;
expr->flags &= ~ENODE_FLAG_QUALS;
expr->flags |= cv;
return expr;
}
if (type == TYPE(&stvoid)) {
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = type;
expr->flags = cv;
return expr;
}
if (IS_TYPE_REFERENCE(type)) {
if (isExplicit) {
refExpr = CExpr_ClassReferenceConversion(expr, TPTR_TARGET(type), qual, flag2);
if (refExpr)
return refExpr;
expr = getnodeaddress(expr, 0);
typeCopy = galloc(sizeof(TypePointer));
*TYPE_POINTER(typeCopy) = *TYPE_POINTER(type);
TPTR_QUAL(typeCopy) &= ~Q_REFERENCE;
expr = CExpr_Convert(expr, typeCopy, qual, 0, flag2);
expr = makemonadicnode(expr, EINDIRECT);
expr->rtype = TPTR_TARGET(type);
expr->flags = cv;
return expr;
} else {
return CExpr_BindToReference(expr, TPTR_TARGET(type), qual);
}
}
if (
(IS_TYPE_ARRAY(expr->rtype) && !IS_TYPE_ARRAY(type)) ||
(IS_TYPE_FUNC(expr->rtype) && !IS_TYPE_FUNC(type))
)
{
expr = pointer_generation(expr);
} else {
expr = CExpr_RewriteConst(expr);
}
if (ENODE_IS(expr, EOBJLIST)) {
if (CExpr_OverloadFuncMatch(expr->data.objlist.list, expr->data.objlist.templargs, type, &refExpr))
return refExpr;
} else if (ENODE_IS(expr, EOBJREF) && IS_TEMPL_FUNC(expr->data.objref->type)) {
myList.next = NULL;
myList.object = OBJ_BASE(expr->data.objref);
if (CExpr_OverloadFuncMatch(&myList, NULL, type, &refExpr))
return refExpr;
} else if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type)) {
if (expr->rtype->size == 0)
CDecl_CompleteType(expr->rtype);
if (IS_TYPE_CLASS(type)) {
CanAllocObject(type);
if (!CClass_CopyConstructor(TYPE_CLASS(type)) || CClass_IsTrivialCopyClass(TYPE_CLASS(type))) {
if (expr->rtype == type)
return expr;
refExpr = CExpr_DerivedToBase(expr, type, qual, flag2, 0, 1);
if (refExpr)
return refExpr;
}
}
refExpr = CExpr_UserConversion(expr, type, qual, NULL, 1, isExplicit, 0);
if (refExpr) {
refExpr->flags = cv;
return refExpr;
}
} else if (!isExplicit && is_typesame(expr->rtype, type)) {
if (ENODE_IS(expr, EINDIRECT) && ENODE_QUALS(expr) != cv)
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = type;
expr->flags = cv;
return expr;
} else {
if (
copts.warn_implicitconv &&
!isExplicit &&
IS_TYPE_INT_OR_FLOAT(type) &&
IS_TYPE_INT_OR_FLOAT(expr->rtype)
)
CExpr_CheckArithmConversion(expr, type);
switch (type->type) {
case TYPEINT:
if (type == TYPE(&stbool)) {
switch (expr->rtype->type) {
case TYPEINT:
case TYPEFLOAT:
case TYPEENUM:
case TYPEMEMBERPOINTER:
case TYPEPOINTER:
return CExpr_ConvertToBool(expr, isExplicit);
}
} else {
switch (expr->rtype->type) {
case TYPEENUM:
expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
case TYPEINT:
case TYPEFLOAT:
do_int_float_conversion:
if (
ENODE_IS(expr, ETYPCON) &&
expr->rtype->type == type->type &&
expr->rtype->size == type->size &&
is_unsigned(expr->rtype) == is_unsigned(type) &&
ENODE_QUALS(expr) == qual
)
{
expr->rtype = type;
expr->flags |= ENODE_FLAG_80;
return expr;
} else {
refExpr = promote(expr, type);
refExpr->flags = cv;
return refExpr;
}
break;
case TYPEPOINTER:
if (expr->rtype->size > type->size && copts.warn_ptr_int_conv)
CError_Warning(CErrorStr382);
if (ENODE_IS(expr, ETYPCON)) {
ENode *inner = expr->data.monadic;
if (ENODE_IS(inner, EINTCONST)) {
inner->rtype = type;
inner->flags = cv;
inner->data.intval = CExpr_IntConstConvert(type, TYPE(&stunsignedlong), inner->data.intval);
return inner;
}
}
if (type->size != 4) {
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = TYPE(&stunsignedlong);
}
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = type;
expr->flags = cv;
return expr;
}
}
break;
case TYPEFLOAT:
switch (expr->rtype->type) {
case TYPEENUM:
expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
case TYPEINT:
case TYPEFLOAT:
goto do_int_float_conversion;
}
break;
case TYPEENUM:
expr = CExpr_Convert(expr, TYPE_ENUM(type)->enumtype, qual, isExplicit, flag2);
if (!ENODE_IS(expr, EINTCONST))
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = type;
expr->flags = cv;
return expr;
case TYPEPOINTER:
switch (expr->rtype->type) {
case TYPEENUM:
expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
case TYPEINT:
if (expr->rtype->size != 4) {
if (!ENODE_IS(expr, EINTCONST))
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = TYPE(&stunsignedlong);
}
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = type;
expr->flags = cv;
return expr;
case TYPEPOINTER:
if (IS_TYPE_CLASS(TPTR_TARGET(expr->rtype)) && IS_TYPE_CLASS(TPTR_TARGET(type)))
expr = CExpr_SafeClassPointerCast(expr, TYPE_CLASS(TPTR_TARGET(expr->rtype)), TYPE_CLASS(TPTR_TARGET(type)), 1, flag2);
if (!ENODE_IS(expr, ETYPCON))
expr = makemonadicnode(expr, ETYPCON);
expr->rtype = type;
expr->flags = cv;
return expr;
}
break;
case TYPEMEMBERPOINTER:
if (!IS_TYPE_MEMBERPOINTER(expr->rtype))
expr = CExpr_MemberPointerConversion(expr, TYPE_MEMBER_POINTER(type), 1);
if (IS_TYPE_MEMBERPOINTER(expr->rtype)) {
expr = PointerToMemberCast(expr, TYPE_MEMBER_POINTER(expr->rtype), TYPE_MEMBER_POINTER(type), flag2);
expr->flags = cv;
return expr;
}
break;
}
}
if (isExplicit) {
if ((newExpr = CodeGen_HandleTypeCast(expr, type, qual)))
return newExpr;
}
CError_Error(
isExplicit ? CErrorStr247 : CErrorStr209,
expr->rtype, ENODE_QUALS(expr),
type, qual);
return nullnode();
}
ENode *CExpr_AssignmentPromotion(ENode *expr, Type *type2, UInt32 qual2, Boolean flag) {
ImplicitConv result;
if (copts.old_argmatch)
return oldassignmentpromotion(expr, type2, qual2, flag);
if (ENODE_IS(expr, EMEMBER))
expr = getpointertomemberfunc(expr, type2, 1);
if (!CExpr_ImplicitConversionMatch(expr, type2, qual2, &result)) {
CError_Error(CErrorStr209, expr->rtype, ENODE_QUALS(expr), type2, qual2);
return nullnode();
}
return CExpr_Convert(expr, type2, qual2, 0, flag);
}
static Boolean CExpr_IsBetterMatch(Match *a, Match *b, int count) {
ImplicitConv *convA;
ImplicitConv *convB;
int i;
Boolean flag;
convA = a->conv;
convB = b->conv;
flag = 0;
if (convA->type != ICT_0 && convB->type != ICT_0) {
if (CExpr_IsBetterImplicitConv(convB, convA))
return 0;
if (CExpr_IsBetterImplicitConv(convA, convB))
flag = 1;
}
for (i = 0; i < count; i++) {
if (CExpr_IsBetterImplicitConv(++convB, ++convA))
return 0;
if (CExpr_IsBetterImplicitConv(convA, convB))
flag = 1;
}
if (flag)
return 1;
if (b->object) {
CError_ASSERT(2165, IS_TYPE_FUNC(b->object->type));
if (b->object->u.func.inst) {
if (!a->object)
return 1;
CError_ASSERT(2169, IS_TYPE_FUNC(a->object->type));
if (!a->object->u.func.inst)
return 1;
CError_ASSERT(2174, a->specialfunc && b->specialfunc);
if (CTempl_FuncIsMoreSpecialized(a->specialfunc, b->specialfunc))
return 1;
}
}
return 0;
}
static Boolean CExpr_MatchArgs(Object *func, ENodeList *argexprs, ENode *expr, ImplicitConv *convs) {
FuncArg *args;
ENode *newExpr;
Type *type;
args = TYPE_FUNC(func->type)->args;
if (!(TYPE_FUNC(func->type)->flags & FUNC_FLAGS_METHOD)) {
convs->type = ICT_0;
} else if (TYPE_METHOD(func->type)->x26) {
convs->type = ICT_0;
} else if (TYPE_FUNC(func->type)->flags & FUNC_FLAGS_1000) {
convs->type = ICT_0;
args = args->next;
} else {
if (!expr)
return 0;
newExpr = lalloc(sizeof(ENode));
newExpr->type = EINTCONST;
newExpr->cost = 0;
newExpr->flags = expr->flags;
newExpr->rtype = CDecl_NewPointerType(expr->rtype);
newExpr->data.intval = cint64_zero;
if (func->datatype == DALIAS) {
CError_ASSERT(2231, func->u.alias.member);
type = CDecl_NewPointerType(func->u.alias.member->type);
} else {
type = args->type;
}
if (!CExpr_ImplicitConversionMatch(newExpr, type, args->qual, convs))
return 0;
args = args->next;
}
convs++;
while (1) {
if (!args || args->type == &stvoid) {
if (argexprs)
return 0;
else
return 1;
}
if (args == &elipsis || args == &oldstyle) {
while (argexprs) {
convs->type = ICT_1;
argexprs = argexprs->next;
convs++;
}
return 1;
}
if (!argexprs)
return args->dexpr != NULL;
if (!CExpr_ImplicitConversionMatch(argexprs->node, args->type, args->qual, convs))
return 0;
argexprs = argexprs->next;
args = args->next;
convs++;
}
}
static Object *CExpr_GetMatchObject(Match *match, HashNameNode *name) {
Object *object;
FuncArg *arg;
TypeFunc *tfunc;
if (match->object)
return match->object;
tfunc = lalloc(sizeof(TypeFunc));
memclrw(tfunc, sizeof(TypeFunc));
tfunc->type = TYPEFUNC;
tfunc->functype = &stvoid;
arg = lalloc(sizeof(FuncArg));
memclrw(arg, sizeof(FuncArg));
arg->type = match->type;
arg->qual = match->qual;
tfunc->args = arg;
if (match->type2) {
arg = lalloc(sizeof(FuncArg));
memclrw(arg, sizeof(FuncArg));
arg->type = match->type2;
arg->qual = match->qual2;
tfunc->args->next = arg;
}
object = lalloc(sizeof(Object));
memclrw(object, sizeof(Object));
object->name = name;
object->datatype = DFUNC;
object->nspace = cscope_root;
object->type = TYPE(tfunc);
return object;
}
static Match *CExpr_FindBestMatch(Match *matches, int count, HashNameNode *name, ObjectList **outList, ENodeList *argExprs) {
Match *scan;
Match *best;
ObjectList *listHead;
ObjectList *list;
best = matches;
for (scan = matches->next; scan; scan = scan->next) {
if (CExpr_IsBetterMatch(scan, best, count))
best = scan;
}
for (scan = matches, listHead = NULL; scan; scan = scan->next) {
if (scan != best && !CExpr_IsBetterMatch(best, scan, count)) {
list = lalloc(sizeof(ObjectList));
list->next = listHead;
list->object = CExpr_GetMatchObject(scan, name);
listHead = list;
}
}
if (!outList) {
if (listHead)
CError_OverloadedFunctionError(CExpr_GetMatchObject(best, name), listHead);
} else {
*outList = listHead;
}
return best;
}
void CExpr_FuncArgMatch(NameSpaceObjectList *list, TemplArg *templargs, ENodeList *argexprs, Match13 *match13, ENode *expr, Boolean flag) {
NameSpaceObjectList *i;
NameSpaceObjectList *j;
Match *match;
Match *matches;
Object *object;
Object *object2;
Object *specialfunc;
ENodeList *argscan;
int argcount;
for (argscan = argexprs, argcount = 0; argscan; argscan = argscan->next) {
CDecl_CompleteType(argscan->node->rtype);
argcount++;
}
matches = NULL;
match = lalloc(sizeof(Match) + ((argcount - 2) * sizeof(ImplicitConv)));
for (i = list; i; i = i->next) {
object = OBJECT(i->object);
if (
object->otype == OT_OBJECT &&
IS_TYPE_FUNC(object->type) &&
(!flag || !(object->qual & Q_EXPLICIT))
)
{
if (object->datatype == DALIAS && (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_METHOD)) {
for (j = list; j; j = j->next) {
if (j == i)
continue;
object2 = OBJECT(j->object);
if (
object2->otype == OT_OBJECT &&
IS_TYPE_METHOD(object2->type) &&
(TYPE_FUNC(object2->type)->flags & FUNC_FLAGS_CV) == (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_CV)
)
{
FuncArg *argsA;
FuncArg *argsB;
argsA = TYPE_FUNC(object->type)->args;
if (argsA && !TYPE_METHOD(object->type)->x26)
argsA = argsA->next;
argsB = TYPE_FUNC(object2->type)->args;
if (argsB && !TYPE_METHOD(object2->type)->x26)
argsB = argsB->next;
if (is_arglistsame(argsA, argsB))
break;
}
}
if (j)
continue;
}
if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
specialfunc = object;
object = CTempl_DeduceFromFunctionCall(object, templargs, argexprs);
if (!object)
continue;
} else {
if (templargs)
continue;
specialfunc = NULL;
}
if (CExpr_MatchArgs(object, argexprs, expr, match->conv)) {
match->object = object;
match->specialfunc = specialfunc;
match->next = matches;
matches = match;
match = lalloc(sizeof(Match) + ((argcount - 2) * sizeof(ImplicitConv)));
}
}
}
if (matches) {
matches = CExpr_FindBestMatch(matches, argcount, NULL, &match13->list, argexprs);
match13->obj = matches->object;
}
}
static ConversionTypeList *CExpr_BuildConversionTypeList(ENode *expr) {
ConversionTypeList *first;
ConversionTypeList *list;
Object *object;
Type *type;
ConversionIterator convIter;
if (!IS_TYPE_CLASS(expr->rtype)) {
first = lalloc(sizeof(ConversionTypeList));
first->next = NULL;
first->func = NULL;
first->type = expr->rtype;
first->qual = ENODE_QUALS(expr);
if (IS_TYPE_ENUM(first->type))
first->qual = 0;
} else {
first = NULL;
CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr->rtype));
while ((object = CExpr_ConversionIteratorNext(&convIter))) {
type = TYPE_FUNC(object->type)->functype;
if (IS_TYPE_REFERENCE(type))
type = TPTR_TARGET(type);
if (!IS_TYPE_CLASS(type)) {
list = lalloc(sizeof(ConversionTypeList));
list->next = first;
list->func = object;
list->type = type;
list->qual = TYPE_FUNC(object->type)->qual & Q_CV;
first = list;
}
}
}
return first;
}
static Type *CExpr_NextPromotedIntegralType(int *p) {
switch (++(*p)) {
case 1: return TYPE(&stsignedint);
case 2: return TYPE(&stunsignedint);
case 3: return TYPE(&stsignedlong);
case 4: return TYPE(&stunsignedlong);
case 5:
if (copts.longlong)
return TYPE(&stsignedlonglong);
else
return NULL;
case 6:
if (copts.longlong)
return TYPE(&stunsignedlonglong);
else
return NULL;
}
return NULL;
}
static Type *CExpr_NextArithmeticType(int *p) {
switch (++(*p)) {
case 1: return TYPE(&stbool);
case 2: return TYPE(&stchar);
case 3: return TYPE(&stsignedchar);
case 4: return TYPE(&stunsignedchar);
case 5: return TYPE(&stwchar);
case 6: return TYPE(&stsignedshort);
case 7: return TYPE(&stunsignedshort);
case 8: return TYPE(&stsignedint);
case 9: return TYPE(&stunsignedint);
case 10: return TYPE(&stsignedlong);
case 11: return TYPE(&stunsignedlong);
case 12: return TYPE(&stfloat);
case 13: return TYPE(&stdouble);
case 14: return TYPE(&stlongdouble);
case 15:
if (copts.longlong)
return TYPE(&stsignedlonglong);
else
return NULL;
case 16:
if (copts.longlong)
return TYPE(&stunsignedlonglong);
else
return NULL;
}
return NULL;
}
static Type *CExpr_NextPromotedArithmeticType(int *p) {
switch (++(*p)) {
case 1: return TYPE(&stsignedint);
case 2: return TYPE(&stunsignedint);
case 3: return TYPE(&stsignedlong);
case 4: return TYPE(&stunsignedlong);
case 5: return TYPE(&stdouble);
case 6: return TYPE(&stlongdouble);
case 7:
if (copts.longlong)
return TYPE(&stsignedlonglong);
else
return NULL;
case 8:
if (copts.longlong)
return TYPE(&stunsignedlonglong);
else
return NULL;
}
return NULL;
}
static Match *CExpr_MatchBuiltin(Match *matches, ENode *left, Type *leftType, UInt32 leftQual, ENode *right, Type *rightType, UInt32 rightQual) {
Match *scan;
Match mymatch;
if (CExpr_ImplicitConversionMatch(left, leftType, leftQual, &mymatch.conv[0])) {
if (!right || CExpr_ImplicitConversionMatch(right, rightType, rightQual, &mymatch.conv[1])) {
if (right) {
for (scan = matches; scan; scan = scan->next) {
if (
!scan->object &&
is_typesame(scan->type, leftType) &&
scan->qual == leftQual &&
is_typesame(scan->type2, rightType) &&
scan->qual2 == rightQual
)
return matches;
}
}
mymatch.next = matches;
mymatch.object = NULL;
mymatch.specialfunc = NULL;
mymatch.type = leftType;
mymatch.qual = leftQual;
mymatch.type2 = rightType;
mymatch.qual2 = rightQual;
matches = lalloc(sizeof(Match));
*matches = mymatch;
}
}
return matches;
}
static Match *CExpr_CheckIncDecBuiltin(Match *matches, short token, ENode *expr1, ENode *expr2) {
Object *object;
Type *type;
TypeFunc *tfunc;
ConversionIterator convIter;
if (IS_TYPE_CLASS(expr1->rtype)) {
CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr1->rtype));
while ((object = CExpr_ConversionIteratorNext(&convIter))) {
tfunc = TYPE_FUNC(object->type);
if (IS_TYPE_REFERENCE(tfunc->functype)) {
type = TPTR_TARGET(tfunc->functype);
switch (type->type) {
case TYPEINT:
if (type == TYPE(&stbool) && token == TK_DECREMENT)
break;
case TYPEFLOAT:
case TYPEPOINTER:
if (!CParser_IsConst(type, tfunc->qual)) {
matches = CExpr_MatchBuiltin(
matches,
expr1, type, tfunc->qual,
expr2, expr2 ? TYPE(&stsignedint) : NULL, 0
);
}
break;
}
}
}
}
return matches;
}
static Match *CExpr_CheckUnaryBuiltin(Match *matches, short token, ENode *expr) {
ConversionTypeList *typelist;
Type *type;
int typenum;
switch (token) {
case TK_INCREMENT:
case TK_DECREMENT:
return CExpr_CheckIncDecBuiltin(matches, token, expr, NULL);
case '!':
matches = CExpr_MatchBuiltin(matches, expr, TYPE(&stbool), 0, NULL, NULL, 0);
break;
case '~':
typenum = 0;
while ((type = CExpr_NextPromotedIntegralType(&typenum))) {
matches = CExpr_MatchBuiltin(matches, expr, type, 0, NULL, NULL, 0);
}
break;
case '*':
case '+':
for (typelist = CExpr_BuildConversionTypeList(expr); typelist; typelist = typelist->next) {
if (IS_TYPE_POINTER_ONLY(typelist->type))
matches = CExpr_MatchBuiltin(matches, expr, typelist->type, typelist->qual, NULL, NULL, 0);
}
if (token != '+')
break;
case '-':
typenum = 0;
while ((type = CExpr_NextPromotedArithmeticType(&typenum))) {
matches = CExpr_MatchBuiltin(matches, expr, type, 0, NULL, NULL, 0);
}
break;
}
return matches;
}
static Match *CExpr_CheckBinaryBuiltin(Match *matches, ENode *left, short token, ENode *right) {
int typenum1;
int typenum2;
Type *type1;
Type *type2;
Type *ptrdiff;
Boolean allowPtrDiffOnRight;
Boolean allowPtrCV;
Boolean allowPtrDiffOnLeft;
Boolean allowMemberPtrs;
Boolean allowEnum;
ConversionTypeList *leftList;
ConversionTypeList *rightList;
ConversionTypeList *scan;
switch (token) {
case TK_INCREMENT:
case TK_DECREMENT:
return CExpr_CheckIncDecBuiltin(matches, token, left, right);
case '*':
case '+':
case '-':
case '/':
case ':':
case '<':
case '>':
case TK_LOGICAL_EQ:
case TK_LOGICAL_NE:
case TK_LESS_EQUAL:
case TK_GREATER_EQUAL:
typenum1 = 0;
while ((type1 = CExpr_NextPromotedArithmeticType(&typenum1))) {
typenum2 = 0;
while ((type2 = CExpr_NextPromotedArithmeticType(&typenum2))) {
matches = CExpr_MatchBuiltin(matches, left, type1, 0, right, type2, 0);
}
}
break;
case '%':
case '&':
case '^':
case '|':
case TK_SHL:
case TK_SHR:
typenum1 = 0;
while ((type1 = CExpr_NextPromotedIntegralType(&typenum1))) {
typenum2 = 0;
while ((type2 = CExpr_NextPromotedIntegralType(&typenum2))) {
matches = CExpr_MatchBuiltin(matches, left, type1, 0, right, type2, 0);
}
}
return matches;
case TK_LOGICAL_OR:
case TK_LOGICAL_AND:
return CExpr_MatchBuiltin(matches, left, TYPE(&stbool), 0, right, TYPE(&stbool), 0);
}
allowEnum = 0;
allowMemberPtrs = 0;
allowPtrCV = 0;
allowPtrDiffOnLeft = 0;
allowPtrDiffOnRight = 0;
switch (token) {
case '+':
case '[':
allowPtrDiffOnLeft = 1;
allowPtrDiffOnRight = 1;
break;
case '-':
allowPtrCV = 1;
allowPtrDiffOnRight = 1;
break;
case ':':
case TK_LOGICAL_EQ:
case TK_LOGICAL_NE:
allowMemberPtrs = 1;
case '<':
case '>':
case TK_LESS_EQUAL:
case TK_GREATER_EQUAL:
allowPtrCV = 1;
allowEnum = 1;
break;
default:
return matches;
}
leftList = CExpr_BuildConversionTypeList(left);
rightList = CExpr_BuildConversionTypeList(right);
ptrdiff = CABI_GetPtrDiffTType();
for (scan = leftList; ; scan = scan->next) {
if (!scan) {
scan = rightList;
if (!rightList)
break;
rightList = NULL;
}
type1 = scan->type;
if (IS_TYPE_REFERENCE(type1))
type1 = TPTR_TARGET(type1);
switch (type1->type) {
case TYPEENUM:
if (allowEnum)
matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, type1, scan->qual);
break;
case TYPEPOINTER:
if (allowPtrDiffOnRight)
matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, ptrdiff, 0);
if (allowPtrDiffOnLeft)
matches = CExpr_MatchBuiltin(matches, left, ptrdiff, 0, right, type1, scan->qual);
if (allowPtrCV) {
if (IS_TYPE_POINTER_ONLY(TPTR_TARGET(type1))) {
type2 = galloc(sizeof(TypePointer));
*TYPE_POINTER(type2) = *TYPE_POINTER(type1);
TPTR_QUAL(type2) |= Q_CONST | Q_VOLATILE;
matches = CExpr_MatchBuiltin(matches, left, type2, scan->qual, right, type2, scan->qual);
} else {
matches = CExpr_MatchBuiltin(matches, left, type1, Q_CONST | Q_VOLATILE, right, type1, Q_CONST | Q_VOLATILE);
}
}
break;
case TYPEMEMBERPOINTER:
if (allowMemberPtrs)
matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, type1, scan->qual);
break;
}
}
return matches;
}
static Boolean CExpr_MatchOperands(ENode *left, Type *leftType, UInt32 leftQual, ENode *right, Type *rightType, UInt32 rightQual, ImplicitConv *twoResults, Boolean flag) {
if (flag) {
if (!CExpr_StandardConversionMatch(left, leftType, leftQual, 1, &twoResults[0].u.ic3.standardConv))
return 0;
twoResults[0].type = ICT_3;
} else {
if (!CExpr_ImplicitConversionMatch(left, leftType, leftQual, &twoResults[0]))
return 0;
}
if (right) {
if (!CExpr_ImplicitConversionMatch(right, rightType, rightQual, &twoResults[1]))
return 0;
}
return 1;
}
Boolean CExpr_CondOperatorMatch(ENode *left, ENode *right, Conversion *conv) {
Match *match;
if ((match = CExpr_CheckBinaryBuiltin(NULL, left, ':', right))) {
match = CExpr_FindBestMatch(match, 1, GetHashNameNode("operator?:"), NULL, NULL);
CError_ASSERT(2931, !match->object);
conv->x0 = NULL;
conv->left = CExpr_Convert(left, match->type, match->qual, 0, 1);
conv->right = CExpr_Convert(right, match->type2, match->qual2, 0, 1);
return 1;
}
return 0;
}
Boolean CExpr_OperatorMatch(short token, ENode *left, ENode *right, Conversion *conv) {
HashNameNode *name;
ENodeList *argExprs;
BClassList *path;
int hasArg;
Match *matches;
Object *object;
Object *specialfunc;
NameSpaceObjectList *list;
Type *leftType;
UInt32 leftQual;
Type *rightType;
UInt32 rightQual;
CScopeParseResult pr;
NameSpaceObjectList myList;
Match myMatch;
if (!IS_TYPE_CLASS(left->rtype)) {
if (!IS_TYPE_ENUM(left->rtype)) {
if (!right || !(IS_TYPE_CLASS(right->rtype) || IS_TYPE_ENUM(right->rtype)))
return 0;
}
} else {
CDecl_CompleteType(left->rtype);
}
name = CMangler_OperatorName(token);
path = NULL;
argExprs = lalloc(sizeof(ENodeList));
argExprs->node = left;
if (right) {
argExprs->next = lalloc(sizeof(ENodeList));
argExprs->next->node = right;
argExprs->next->next = NULL;
hasArg = 1;
} else {
argExprs->next = NULL;
hasArg = 0;
}
matches = NULL;
if (IS_TYPE_CLASS(left->rtype) && CScope_FindClassMemberObject(TYPE_CLASS(left->rtype), &pr, name)) {
if (token != '=' || (pr.bcl_18->type == left->rtype && !pr.bcl_18->next)) {
if (pr.obj_10) {
myList.next = NULL;
myList.object = pr.obj_10;
pr.nsol_14 = &myList;
} else {
CError_ASSERT(3009, pr.nsol_14);
}
for (list = pr.nsol_14; list; list = list->next) {
object = OBJECT(list->object);
if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
specialfunc = object;
object = CTempl_DeduceFromFunctionCall(object, NULL, argExprs->next);
if (!object)
continue;
} else {
specialfunc = NULL;
}
leftType = CExpr_GetImplictObjectParamType(object, &leftQual);
if (right) {
if (!CExpr_HasNParams(object, 1))
continue;
rightType = CExpr_GetParamType(object, 0, &rightQual);
} else {
if (!CExpr_HasNParams(object, 0))
continue;
}
if (CExpr_MatchOperands(left, leftType, leftQual, right, rightType, rightQual, myMatch.conv, 1)) {
myMatch.object = object;
myMatch.specialfunc = specialfunc;
myMatch.next = matches;
matches = lalloc(sizeof(Match));
*matches = myMatch;
path = pr.bcl_18;
}
}
}
}
}
if (CScope_FindNonClassObject(cscope_current, &pr, name)) {
if (pr.obj_10) {
myList.next = NULL;
myList.object = pr.obj_10;
pr.nsol_14 = &myList;
}
} else {
pr.nsol_14 = NULL;
}
if (copts.arg_dep_lookup)
pr.nsol_14 = CScope_ArgumentDependentNameLookup(pr.nsol_14, name, argExprs, 1);
for (list = pr.nsol_14; list; list = list->next) {
object = OBJECT(list->object);
if (object->otype == OT_OBJECT && IS_TYPE_NONMETHOD(object->type)) {
if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
specialfunc = object;
object = CTempl_DeduceFromFunctionCall(object, NULL, argExprs);
if (!object)
continue;
} else {
specialfunc = NULL;
}
leftType = CExpr_GetParamType(object, 0, &leftQual);
if (right) {
if (!CExpr_HasNParams(object, 2))
continue;
rightType = CExpr_GetParamType(object, 1, &rightQual);
} else {
if (!CExpr_HasNParams(object, 1))
continue;
}
if (CExpr_MatchOperands(left, leftType, leftQual, right, rightType, rightQual, myMatch.conv, 0)) {
myMatch.object = object;
myMatch.specialfunc = specialfunc;
myMatch.next = matches;
matches = lalloc(sizeof(Match));
*matches = myMatch;
}
}
}
if (right)
matches = CExpr_CheckBinaryBuiltin(matches, left, token, right);
else
matches = CExpr_CheckUnaryBuiltin(matches, token, left);
if (matches) {
conv->x0 = NULL;
conv->left = NULL;
conv->right = NULL;
matches = CExpr_FindBestMatch(matches, hasArg, name, NULL, argExprs);
object = matches->object;
if (!object) {
if (IS_TYPE_CLASS(left->rtype))
conv->left = CExpr_Convert(left, matches->type, matches->qual, 0, 1);
else
conv->left = left;
if (right) {
if (IS_TYPE_CLASS(right->rtype))
conv->right = CExpr_Convert(right, matches->type2, matches->qual2, 0, 1);
else
conv->right = right;
}
return 1;
}
if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type))) {
CError_ASSERT(3125, path);
left = CExpr_GenericFuncCall(path, argExprs->node, 0, object, NULL, NULL, argExprs->next, 0, 0, 1);
} else {
left = CExpr_GenericFuncCall(NULL, NULL, 0, object, NULL, NULL, argExprs, 0, 0, 1);
}
conv->x0 = checkreference(left);
return 1;
}
return 0;
}
static ENode *CExpr_ClassCopyInit(TypeClass *tclass, ENode *expr1, ENode *expr2) {
Object *best;
NameSpaceObjectList *list;
ObjectList *objlist;
ObjectList *objlistEntry;
ENodeList *argExprs;
FuncArg *arg;
Type *type;
Object *object;
ImplicitConv bestConv;
ImplicitConv conv;
BClassList path;
ConversionIterator convIter;
best = NULL;
objlist = NULL;
for (list = CClass_Constructor(tclass); list; list = list->next) {
object = OBJECT(list->object);
if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type) && !(object->qual & Q_EXPLICIT)) {
arg = TYPE_FUNC(object->type)->args;
CError_ASSERT(3199, arg);
arg = arg->next;
if (tclass->flags & CLASS_FLAGS_20) {
CError_ASSERT(3203, arg);
arg = arg->next;
}
if (
arg &&
arg != &elipsis &&
(!arg->next || arg->next->dexpr) &&
CExpr_ImplicitConversionMatch(expr2, arg->type, arg->qual, &conv)
)
{
if (!best || CExpr_IsBetterImplicitConv(&conv, &bestConv)) {
best = object;
bestConv = conv;
objlist = NULL;
} else if (!CExpr_IsBetterImplicitConv(&bestConv, &conv)) {
objlistEntry = lalloc(sizeof(ObjectList));
objlistEntry->next = objlist;
objlistEntry->object = object;
objlist = objlistEntry;
}
}
}
}
if (IS_TYPE_CLASS(expr2->rtype)) {
CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr2->rtype));
while ((object = CExpr_ConversionIteratorNext(&convIter))) {
type = TYPE_FUNC(object->type)->functype;
if (IS_TYPE_REFERENCE(type))
type = TPTR_TARGET(type);
if (
IS_TYPE_CLASS(type) &&
(tclass == TYPE_CLASS(type) || CClass_IsBaseClass(tclass, TYPE_CLASS(type), NULL, 0, 0))
)
{
CError_ASSERT(3248, TYPE_FUNC(object->type)->args &&
IS_TYPE_POINTER_ONLY(TYPE_FUNC(object->type)->args->type));
type = galloc(sizeof(TypePointer));
*TYPE_POINTER(type) = *TYPE_POINTER(TYPE_FUNC(object->type)->args->type);
TPTR_QUAL(type) = Q_REFERENCE;
if (CExpr_ImplicitConversionMatch(expr2, type, TYPE_FUNC(object->type)->args->qual, &conv)) {
if (!best || CExpr_IsBetterImplicitConv(&conv, &bestConv)) {
best = object;
bestConv = conv;
objlist = NULL;
} else if (!CExpr_IsBetterImplicitConv(&bestConv, &conv)) {
objlistEntry = lalloc(sizeof(ObjectList));
objlistEntry->next = objlist;
objlistEntry->object = object;
objlist = objlistEntry;
}
}
}
}
}
if (objlist)
CError_OverloadedFunctionError(best, objlist);
if (!best) {
CError_Error(CErrorStr209, expr2->rtype, ENODE_QUALS(expr2), tclass, 0);
return expr1;
}
CError_ASSERT(3284, IS_TYPE_POINTER_ONLY(expr1->rtype));
expr1 = makemonadicnode(expr1, EINDIRECT);
expr1->rtype = TYPE(tclass);
argExprs = lalloc(sizeof(ENodeList));
argExprs->node = expr2;
if (tclass->flags & CLASS_FLAGS_20) {
argExprs->next = lalloc(sizeof(ENodeList));
argExprs->next->next = NULL;
argExprs->next->node = intconstnode(TYPE(&stsignedshort), 1);
} else {
argExprs->next = NULL;
}
path.next = NULL;
path.type = TYPE(tclass);
expr1 = CExpr_GenericFuncCall(&path, expr1, 0, best, NULL, NULL, argExprs, 0, 0, 1);
if (ENODE_IS2(expr1, EFUNCCALL, EFUNCCALLP))
expr1->rtype = CDecl_NewPointerType(TYPE(tclass));
expr1 = makemonadicnode(expr1, EINDIRECT);
expr1->rtype = TYPE(tclass);
return expr1;
}