... (Ellipsis)

Used in place of procedure parameter to pass a variable number of 
arguments, or as the upper bound in an array declaration to denote that the 
number of elements will be determined by the initializer.

Syntax
	KeyPgDeclareDeclare { KeyPgSubSub | KeyPgFunctionFunction } proc_name KeyPgCdeclcdecl ( param_list, ... )  { | [ 
	KeyPgByrefFunctionByRef ] KeyPgAsAs return_type }

	KeyPgPpdefine#define identifier( [ parameters, ] variadic_parameter... ) body

	KeyPgDimDim array_symbol ([lbound KeyPgToTo] ...) [KeyPgAsAs DataTypedatatype] => { expression_list }

Description
	Variadic Procedures
		The ellipsis (three dots, ...) is used in procedure declarations and 
		definitions to indicate a variable argument list.

		A first argument (at least) must always be specified and the 
		procedure must be called with the C calling convention KeyPgCdeclcdecl.

		In the procedure body, KeyPgCvaListCva_List data type, and KeyPgCvaArgCva_Arg macro can be 
		used to expand the ellipsis parameter (...) to obtain the values of 
		the arguments passed to the variadic procedure.  The argument list, 
		once initialized with KeyPgCvaStartCva_Start or copied with KeyPgCvaCopyCva_Copy, can be 
		passed to another procedure taking a KeyPgCvaListCva_List parameter.

		On some targets, for backwards compatibility, KeyPgVaFirstva_first, KeyPgVaArgva_arg and 
		KeyPgVaNextva_next can still be used to handle the variable arguments.

		Only numeric types and pointers are supported as variable arguments 
		(all bytes and shorts passed on variable arguments are implicitly 
		converted to integers, all singles passed on variable arguments are 
		implicitly converted to doubles).  KeyPgStringStrings can be passed, in which 
		case a KeyPgZstringZString KeyPgPtrPtr to the string data is taken.

		A variadic procedure name can never be overloaded.

	Variadic Macros
		Using an ellipsis behind the last parameter in a KeyPgPpdefine#define or KeyPgPpmacro#macro 
		declaration allows creation of a variadic macro. This means it is 
		possible to pass any number of arguments to the variadic_parameter, 
		which can be used in the body as if it was a normal macro parameter. 
		The variadic_parameter will expand to the full list of arguments 
		passed to it, including commas, and can also be completely empty.

		Note: To distinguish between the different arguments passed by 
		variadic_parameter, you can first convert variadic_parameter to a 
		string using the KeyPgOpPpStringizeOperator # (Preprocessor Stringize), then 
		differentiate in this string (#variadic_parameter) each passed 
		argument by locating the separators (usually a comma).

	Array Upper Bound
		Using an ellipsis in place of the upper bound in an array declaration 
		causes the upper bound to be set according to the data that appears 
		in the expression_list.  When the ellipsis is used in this manner, an 
		initializer must appear, and cannot be KeyPgAnyAny.

Example
	Declare Function foo cdecl (x As Integer, ...) As Integer

	Dim As Integer myarray(0 To ...) = {0, 1, 2, 3}
	Print LBound(myarray), UBound(myarray)   '' 0, 3

	'' Using a variadic macro to wrap a variadic function
	#include "crt.bi"
	#define eprintf(Format, args...) fprintf(stderr, Format, args)
	eprintf(!"Hello from printf: %i %s %i\n", 5, "test", 123)

	'' LISP-like accessors allowing to modify comma-separated lists
	#define car(a, b...) a
	#define cdr(a, b...) b

Differences from QB
	* New to FreeBASIC

See also
	* KeyPgCdeclcdecl
	* KeyPgCvaListCva_List
	* KeyPgCvaArgCva_Arg
	* KeyPgVaArgva_arg
	* KeyPgVaFirstva_first
	* KeyPgVaNextva_next
	* KeyPgDimDim
	* KeyPgStaticStatic
	* KeyPgPpdefine#define

