boolean NodeConvertArgument( // CONVERT AN ARGUMENT VALUE PTREE *a_expr, // - addr( argument value ) TYPE proto ) // - prototype type { boolean retn; // - return: TRUE ==> conversion ok if( NULL != ArrayType( proto ) ) { proto = PointerTypeForArray( proto ); } else { // ( const int ) prototype should be ( int ) at this point proto = TypedefModifierRemoveOnly( proto ); } *a_expr = CastImplicit( *a_expr, proto, CNV_FUNC_ARG, &diagArgConv ); retn = (*a_expr)->op != PT_ERROR; return retn; }
PTREE AnalyseReturnClassVal // RETURN CLASS VALUE ( PTREE expr ) // - expression for return { TYPE retn_type; // - return type TYPE retn_class; // - class for return PTREE tgt; // - target expression CNV_DIAG* diag; // - diagnosis retn_type = expr->u.subtree[0]->type; retn_class = StructType( retn_type ); DbgVerify( retn_class != NULL, "AnalyseReturnClassVal -- not class" ); if( ClassCorrupted( retn_class ) ) { PTreeErrorNode( expr ); } else if( TypeAbstract( retn_class ) ) { PTreeErrorExprType( expr, ERR_CONVERT_TO_ABSTRACT_TYPE, retn_class ); ScopeNotePureFunctions( retn_class ); } else { diag = DefargBeingCompiled() ? &diagDefarg : &diagReturn; tgt = NodeFetchReference( getReturnSym() ); expr = removeReturnNode( expr ); expr = CopyClassRetnVal( expr, tgt, retn_type, diag ); if( expr->op != PT_ERROR ) { if( NodeIsBinaryOp( expr, CO_DTOR ) ) { PTREE node = expr->u.subtree[0]; if( SymFunctionReturn() == node->u.symcg.symbol ) { PTreeFree( node ); node = expr; expr = expr->u.subtree[1]; PTreeFree( node ); } } } #if 0 // this is just so we can do some checking expr = CastImplicit( expr , retn_type , CNV_EXPR , DefargBeingCompiled() ? &diagDefarg : &diagReturn ); } #endif }
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; }