From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../ARM202U/INCLUDE/STDARG.H | 100 +++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 Bachelor/Mikroprozessorsysteme2/ARM202U/INCLUDE/STDARG.H (limited to 'Bachelor/Mikroprozessorsysteme2/ARM202U/INCLUDE/STDARG.H') diff --git a/Bachelor/Mikroprozessorsysteme2/ARM202U/INCLUDE/STDARG.H b/Bachelor/Mikroprozessorsysteme2/ARM202U/INCLUDE/STDARG.H new file mode 100644 index 0000000..ff486a3 --- /dev/null +++ b/Bachelor/Mikroprozessorsysteme2/ARM202U/INCLUDE/STDARG.H @@ -0,0 +1,100 @@ +#pragma force_top_level +#pragma include_only_once + +/* stdarg.h: ANSI 'C' (X3J11 Oct 88) library header, section 4.8 */ +/* Copyright (C) Codemist Ltd., 1988 */ +/* Copyright (C) Advanced Risc Machines Ltd., 1991 */ +/* version 3 */ + +#ifndef __stdarg_h +#define __stdarg_h + +/* + * stdarg.h declares a type and defines three macros, for advancing through a + * list of arguments whose number and types are not known to the called + * function when it is translated. A function may be called with a variable + * number of arguments of differing types. Its parameter list contains one or + * more parameters. The rightmost parameter plays a special role in the access + * mechanism, and will be called parmN in this description. + */ + +/* N.B. is required to declare vfprintf() without defining */ +/* va_list. Clearly the type __va_list there must keep in step. */ +typedef char *va_list[1]; /* see */ + /* + * an array type suitable for holding information needed by the macro va_arg + * and the function va_end. The called function shall declare a variable + * (referred to as ap) having type va_list. The variable ap may be passed as + * an argument to another function. + * Note: va_list is an array type so that when an object of that type + * is passed as an argument it gets passed by reference. + */ + +/* Note that ___type is a syntactic item a bit like the type qualifiers */ +/* 'static', 'register', 'const' etc except that it has no effect! Its */ +/* purpose is to indicate when a type is being introduced and thus */ +/* help (a bit) when the user gets the args to va_arg the wrong way round */ +#define __alignof(type) \ + ((char *)&(((struct{char __member1; \ + ___type type __member2;}*) 0)->__member2) - \ + (char *)0) +#define __alignuptotype(ptr,type) \ + ((char *)((int)(ptr) + (__alignof(type)-1) & ~(__alignof(type)-1))) + + +#define va_start(ap,parmN) \ + (___assert((___typeof(parmN) & 0x481) == 0, \ + "Illegal type of 2nd argument to va_start"), \ + (void)(*(ap) = (char *)&(parmN) + sizeof(parmN))) + /* + * The va_start macro shall be executed before any access to the unnamed + * arguments. The parameter ap points to an object that has type va_list. + * The va_start macro initialises ap for subsequent use by va_arg and + * va_end. The parameter parmN is the identifier of the rightmost parameter + * in the variable parameter list in the function definition (the one just + * before the , ...). If the parameter parmN is declared with the register + * storage class the behaviour is undefined (Norcroft C gives diagnostic). + * parmN shall not be affected by default argument conversions (Norcroft + * C gives a diagnostic and would (July 1990) generate 'wrong' code). + * Returns: no value. + */ + +#define va_arg(ap,type) \ + (___assert((___typeof(___type type) & 0x481) == 0, \ + "Illegal type used with va_arg"), \ + *(___type type *)((*(ap)=__alignuptotype(*(ap),type)+sizeof(___type type))-\ + sizeof(___type type))) + /* + * The va_arg macro expands to an expression that has the type and value of + * the next argument in the call. The parameter ap shall be the same as the + * va_list ap initialised by va_start. Each invocation of va_arg modifies + * ap so that successive arguments are returned in turn. The parameter + * 'type' is a type name such that the type of a pointer to an object that + * has the specified type can be obtained simply by postfixing a * to + * 'type'. If 'type' disagrees with the type of the actual next argument + * (as promoted according to the default argument promotions), the behaviour + * is undefined. + * Returns: The first invocation of the va_arg macro after that of the + * va_start macro returns the value of the argument after that + * specified by parmN. Successive invocations return the values of + * the remaining arguments in succession. + * Note: care is taken in va_arg so that illegal things like va_arg(ap,char) + * which may seem natural but are illegal are caught. The special Norcroft + * C keywords ___assert and ___typeof are used to do this: these keywords + * are not intended for use by ordinary users. + */ + +#define va_end(ap) ((void)(*(ap) = (char *)-256)) + /* + * The va_end macro facilitates a normal return from the function whose + * variable argument list was referenced by the expansion of va_start that + * initialised the va_list ap. If the va_end macro is not invoked before + * the return, the behaviour is undefined. + * Returns: no value. + * Note: this macro is careful to avoid compiler warning messages and uses + * a -ve address to ensure address trap. + */ + +#endif + +/* end of stdarg.h */ -- cgit v1.2.3