gcc/cp/typeck.c

66    complete type when this function returns.  */
392 	 function has already eliminated the possibility that
400    case.  See that function for documentation fo the parameters.  */
521 		 "and pointer-to-function", location);
728 	/* If this was a member function type, get back to the
729 	   original type of type member function (i.e., without
802    unambiguously derived from Y. Otherwise a function only allows exceptions
1188    If there is not a unique most-derived base type, this function
1289 	pedwarn ("invalid application of %qs to a member function",
1345 	       "function type");
1396 	       "function type");
1426 /* EXPR is being used in a context that is not a function call.
1432      member function call.
1436      If the result of .* or ->* is a function, then that result can be
1437      used only as the operand for the function call operator ().
1447       error ("invalid use of non-static member function");
1510    function-to-pointer conversions.  In addition, manifest constants
1515    function does not wrap the returned expression in a
1591      default_conversion.  That function promotes bitfields correctly
1592      before calling this function.  At this point, if we have a
1616      lvalue-to-rvalue, array-to-pointer, or function-to-pointer
1662 /* Take the address of an inline function without setting TREE_ADDRESSABLE
1798    This function does not perform access control; that is either done
1947 	     build_field_call.  After the function-call code is
1992       /* The member is a (possibly overloaded) member function.  */
1996       /* If the MEMBER is exactly one static member function, then we
2006 	 base.  That will happen when the function is called.  */
2086      functions containing at least one template function.  */
2116 /* This function is called by the parser to process a class member
2180     /* A member function that has already been looked up.  */
2261 	      error ("%qD is not a member template function", name);
2292    representation of PTRMEM, a pointer-to-member function.  (Each
2293    pointer-to-member function type gets its own RECORD_TYPE so it is
2323    This function may need to overload OPERATOR_FNNAME.
2581 /* Resolve a pointer to member function.  INSTANCE is the object
2592 get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function)
2594   if (TREE_CODE (function) == OFFSET_REF)
2595     function = TREE_OPERAND (function, 1);
2597   if (TYPE_PTRMEMFUNC_P (TREE_TYPE (function)))
2600       tree fntype = TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (function));
2606 	  if (TREE_CODE (function) == PTRMEM_CST)
2608 	      /* Extracting the function address from a pmf is only
2611 	      e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
2617 	      error ("object missing in use of %qE", function);
2625       if (TREE_SIDE_EFFECTS (function))
2626 	function = save_expr (function);
2629       e3 = pfn_from_ptrmemfunc (function);
2630       delta = build_ptrmemfunc_access_expr (function, delta_identifier);
2650 	 be incomplete.  In that case, the function will of course be
2677       /* Finally, extract the function pointer from the vtable.  */
2683       /* When using function descriptors, the address of the
2684 	 vtable entry is treated as a function pointer.  */
2698       function = e1;
2700   return function;
2708  FNTYPE is the original function type derived from the syntax.
2735   /* Build: result_type(*)(void *, function-arg-type-list) */
2751 build_function_call (tree function, tree params)
2757   tree original = function;
2761   function = objc_rewrite_function_call (function, params);
2765   if (TREE_CODE (function) == NOP_EXPR
2766       && TREE_TYPE (function) == TREE_TYPE (TREE_OPERAND (function, 0)))
2767     function = TREE_OPERAND (function, 0);
2769   if (TREE_CODE (function) == FUNCTION_DECL)
2771       name = DECL_NAME (function);
2773       mark_used (function);
2774       fndecl = function;
2776       /* Convert anything with function type to a pointer-to-function.  */
2777       if (pedantic && DECL_MAIN_P (function))
2781 	 (because calling an inline function does not mean the function
2784       if (DECL_INLINE (function))
2785 	function = inline_conversion (function);
2787 	function = build_addr_func (function);
2793       function = build_addr_func (function);
2796   if (function == error_mark_node)
2799   fntype = TREE_TYPE (function);
2804 	     "function in %<%E (...)%>",
2816 	|| TREE_CODE (function) == TEMPLATE_ID_EXPR))
2818       error ("%qE cannot be used as a function", original);
2822   /* fntype now gets the type of function pointed to.  */
2826      function prototype, or apply default promotions.  */
2831 				      (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE));
2842   if (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE)
2843     return build_block_call (fntype, function, coerced_params);
2846   return build_cxx_call (function, coerced_params);
2886 	    called_thing = "member function";
2889 	called_thing = "function";
2911 	    error ("too many arguments to %s", (block_call ? "block call" : "function"));
2939 	  /* Formal parm type is specified by a function prototype.  */
3014 	    error ("too few arguments to %s", (block_call ? "block call" : "function"));
3071    This function differs from `build' in several ways:
3168   /* DTRT if one side is an overloaded function, but complain about it.  */
3174 	  pedwarn ("assuming cast to type %qT from overloaded function",
3184 	  pedwarn ("assuming cast to type %qT from overloaded function",
3943 	pedwarn ("ISO C++ forbids using pointer to a function in subtraction");
4004     /* Don't look for a function.  */;
4010       /*  A pointer to member-function can be formed only by saying
4018 	      error ("invalid use of %qE to form a pointer-to-member-function",
4027 		     " pointer-to-member-function",
4088 /* Return an ADDR_EXPR giving the address of T.  This function
4403 	pedwarn ("ISO C++ forbids taking address of function %<::main%>");
4426 	 address of a function is a no-op, so just return the
4436 	     member function.  This is ill-formed (except in MS-land),
4460 			 " or parenthesized non-static member function to form"
4461 			 " a pointer to member function.  Say %<&%T::%D%>",
4465 			 " function to form a pointer to member function."
4562 	     function.  */
4676   /* We permit compiler to make function calls returning
4889    casts away constness.  DIAG_FN gives the function to call if we
4988   /* Save casted types in the function's used types hash table.  */
5048       /* Convert from "B*" to "D*".  This function will check that "B"
5093      (_conv.array_), function-to-pointer (_conv.func_), and boolean
5226 /* EXPR is an expression with member function or pointer-to-member
5227    function type.  TYPE is a pointer type.  Converting EXPR to TYPE is
5279   /* Save casted types in the function's used types hash table.  */
5318      pointer-to-function and pointer-to-void types.  If
5329      array-to-pointer, and function-to-pointer conversions are
5421 	warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object");
5506 	       "or reference to a function type", dst_type);
5510   /* Save casted types in the function's used types hash table.  */
5541 	 lvalue-to-rvalue, array-to-pointer, and function-to-pointer
5662       error ("invalid cast to function type %qT", type);
6123 /* Get difference in deltas for different pointer to member function
6132    this way because we call this function to find out how to convert from
6148     error ("   in pointer to member function conversion");
6195 /* Return a constructor for the pointer-to-member-function TYPE using
6228 /* Build a constructor for a pointer to member function.  It can be
6284       /* Obtain the function pointer and the current DELTA.  */
6302   /* Handle null pointer to member function conversions.  */
6338   /* The class that the function belongs to.  */
6344   /* First, calculate the adjustment to the function's class.  */
6352       /* If we're dealing with a virtual function, we have to adjust 'this'
6361       /* We set PFN to the vtable offset at which the function can be
6395 /* Return an expression for PFN from the pointer-to-member function
6504 	     overloaded function.  Call instantiate_type to get error
6707 /* Check that returning RETVAL from the current function is valid.
6709    change RETVAL into the function return type, and to assign it to
6710    the DECL_RESULT for the function.  Set *NO_WARNING to true if
6711    code reaches end of non-void function warning shouldn't be issued
6718   /* The type actually returned by the function, after any
6725   /* A `volatile' function is one that isn't supposed to return, ever.
6727      that call the `volatile' function.)  */
6729     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6742 	   function-try-block of a constructor, the program is ill-formed.  */
6743 	error ("cannot return from a handler of a function-try-block of a constructor");
6814   /* When no explicit return-value is given in a function with a named
6823   /* Check for a return statement with no return value in a function
6827       pedwarn ("return-statement with no value, in function returning %qT",
6830 	 end of a non-void function (which we don't, we gave a
6834 	 RETURN_EXPR to avoid control reaches end of non-void function
6838   /* Check for a return statement with a value in a function that
6843 	/* You can return a `void' value from a function of `void'
6848 	pedwarn ("return-statement with a value, in function "
6857     /* Remember that this function can sometimes return without a
6861     /* Remember that this function did return a value.  */
6866      function.  */
6888       /* The function return type must be a reference to the current
6897 	  /* If we are calling a function whose return type is the same of
6910      [...]      For  a function with a class return type, if the expression
6912      unqualified  type  of  the  local  object  is the same as the function
6914      porary  object  to  hold  the function return value [...]
6916      So, if this is a value-returning function that always returns the same
6920      variable even if the function sometimes returns something else, but
6958       /* The type the function is declared to return.  */
6966       /* First convert the value to the function's return type, then
7019       /* Const and volatile mean something different for function types,
7048 /* When comparing, say, char ** to char const **, this function takes
7050    types to this function.  */
7165 	 a function type), but DR 295 makes the code well-formed by
7170 	  pedwarn ("ignoring %qV qualifiers added to function type %qT",