ansiprot.h

VRTX操作系统

/*************************************************************************

	Copyright (c) 1999 Mentor Graphics Corporation.


IMPORTANT - USE OF THIS SOFTWARE IS SUBJECT TO LICENSE RESTRICTIONS
CAREFULLY READ THE LICENSE AGREEMENT BEFORE USING THE SOFTWARE


*************************************************************************/

/* $Header: ansiprot.h,v 1.1 90/09/19 16:32:23 glenn Exp $ */
/* ANSI C function prototype macros */

#ifndef ANSIPROT_H
#define ANSIPROT_H

/* This header file, if included by an ANSI C header file,
 * causes that header file to be non-ANSI conforming.  This
 * is because this header file pollutes the name space by
 * using names which are reserved to the application.  At
 * some time in the future, this header file should be changed
 * to use names from the space which is reserved to the implementation.
 * This should be done in a two-stage process, first by adding
 * duplicate new names, then converting all code to the new names,
 * then deleting the old names.  This will cause the minimal disruption.
 */

/* Microsoft C 6.0 doesn't define __STDC__ unless /Za option is specified */

#ifdef M_I86
#ifndef __STDC__
#define __STDC__ 1
#endif
#endif

/* Note the use of "#if __STDC__" instead of "#ifdef __STDC__".
 * You will often see the latter used in programs, but this is
 * incorrect.  ANSI C specifies that an implementation
 * conforms to the standard if and only if it defines __STDC__
 * to be 1.  It does not specify that a non-conforming implementation
 * shall not define __STDC__.  Most non-conforming implementations
 * do not define __STDC__, however there are a few (for example,
 * GNU gcc with option -traditional), which define __STDC__ to
 * be 0.  Thus only "#if __STDC__" is correct.  For those concerned
 * about the meaning of "#if __STDC__" when __STDC__ is undefined,
 * both ANSI C and traditional C implementations treat an undefined
 * macro as 0 in this context.
 */

/***/
/***/
/*** 4/14/93 Thomas Lee ***/
/*** Another set of definitions that started with _ANSIPROT are
     provided for both cases (whether __STDC__ is 1 or not).
     This is a transition stage to allow both ANSIPROT and 
     _ANSIPROT coexist. Eventually, the _ANSIPROT definitions
     will replace the ANSIPROT definitions to meet the ANSI
     comformance requirement as not messing up the application
     name space.
***/
 
#if __STDC__
#define ANSIPROT(args)                  args
#define ANSIPROT0			void
#define ANSIPROT1(a)			a
#define ANSIPROT2(a,b)			a,b
#define ANSIPROT3(a,b,c)		a,b,c
#define ANSIPROT4(a,b,c,d)		a,b,c,d
#define ANSIPROT5(a,b,c,d,e)		a,b,c,d,e
#define ANSIPROT6(a,b,c,d,e,f)		a,b,c,d,e,f
#define ANSIPROT7(a,b,c,d,e,f,g)	a,b,c,d,e,f,g
#define ANSIPROT8(a,b,c,d,e,f,g,h)	a,b,c,d,e,f,g,h
#define ANSIPROT9(a,b,c,d,e,f,g,h,i)	a,b,c,d,e,f,g,h,i
#define ANSIPROT10(a,b,c,d,e,f,g,h,i,j)	a,b,c,d,e,f,g,h,i,j
#define ANSIPROT11(a,b,c,d,e,f,g,h,i,j,k)	a,b,c,d,e,f,g,h,i,j,k
#define ANSIPROT12(a,b,c,d,e,f,g,h,i,j,k,l)	a,b,c,d,e,f,g,h,i,j,k,l
#define ANSIPROT13(a,b,c,d,e,f,g,h,i,j,k,l,m)	a,b,c,d,e,f,g,h,i,j,k,l,m
#define ANSIPROT14(a,b,c,d,e,f,g,h,i,j,k,l,m,n)	a,b,c,d,e,f,g,h,i,j,k,l,m,n
#define ANSIPROT15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o
#define ANSIPROT16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p
#define ANSIPROT17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q
#define _ANSIPROT(args)                  args
#define _ANSIPROT0			void
#define _ANSIPROT1(a)			a
#define _ANSIPROT2(a,b)			a,b
#define _ANSIPROT3(a,b,c)		a,b,c
#define _ANSIPROT4(a,b,c,d)		a,b,c,d
#define _ANSIPROT5(a,b,c,d,e)		a,b,c,d,e
#define _ANSIPROT6(a,b,c,d,e,f)		a,b,c,d,e,f
#define _ANSIPROT7(a,b,c,d,e,f,g)	a,b,c,d,e,f,g
#define _ANSIPROT8(a,b,c,d,e,f,g,h)	a,b,c,d,e,f,g,h
#define _ANSIPROT9(a,b,c,d,e,f,g,h,i)	a,b,c,d,e,f,g,h,i
#define _ANSIPROT10(a,b,c,d,e,f,g,h,i,j)	a,b,c,d,e,f,g,h,i,j
#define _ANSIPROT11(a,b,c,d,e,f,g,h,i,j,k)	a,b,c,d,e,f,g,h,i,j,k
#define _ANSIPROT12(a,b,c,d,e,f,g,h,i,j,k,l)	a,b,c,d,e,f,g,h,i,j,k,l
#define _ANSIPROT13(a,b,c,d,e,f,g,h,i,j,k,l,m)	a,b,c,d,e,f,g,h,i,j,k,l,m
#define _ANSIPROT14(a,b,c,d,e,f,g,h,i,j,k,l,m,n)	a,b,c,d,e,f,g,h,i,j,k,l,m,n
#define _ANSIPROT15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o
#define _ANSIPROT16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p
#define _ANSIPROT17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q
#else
#define ANSIPROT(args) ()
#define ANSIPROT0
#define ANSIPROT1(a)
#define ANSIPROT2(a,b)
#define ANSIPROT3(a,b,c)
#define ANSIPROT4(a,b,c,d)
#define ANSIPROT5(a,b,c,d,e)
#define ANSIPROT6(a,b,c,d,e,f)
#define ANSIPROT7(a,b,c,d,e,f,g)
#define ANSIPROT8(a,b,c,d,e,f,g,h)
#define ANSIPROT9(a,b,c,d,e,f,g,h,i)
#define ANSIPROT10(a,b,c,d,e,f,g,h,i,j)
#define ANSIPROT11(a,b,c,d,e,f,g,h,i,j,k)
#define ANSIPROT12(a,b,c,d,e,f,g,h,i,j,k,l)
#define ANSIPROT13(a,b,c,d,e,f,g,h,i,j,k,l,m)
#define ANSIPROT14(a,b,c,d,e,f,g,h,i,j,k,l,m,n)
#define ANSIPROT15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)
#define ANSIPROT16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
#define ANSIPROT17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)
#define _ANSIPROT(args) ()
#define _ANSIPROT0
#define _ANSIPROT1(a)
#define _ANSIPROT2(a,b)
#define _ANSIPROT3(a,b,c)
#define _ANSIPROT4(a,b,c,d)
#define _ANSIPROT5(a,b,c,d,e)
#define _ANSIPROT6(a,b,c,d,e,f)
#define _ANSIPROT7(a,b,c,d,e,f,g)
#define _ANSIPROT8(a,b,c,d,e,f,g,h)
#define _ANSIPROT9(a,b,c,d,e,f,g,h,i)
#define _ANSIPROT10(a,b,c,d,e,f,g,h,i,j)
#define _ANSIPROT11(a,b,c,d,e,f,g,h,i,j,k)
#define _ANSIPROT12(a,b,c,d,e,f,g,h,i,j,k,l)
#define _ANSIPROT13(a,b,c,d,e,f,g,h,i,j,k,l,m)
#define _ANSIPROT14(a,b,c,d,e,f,g,h,i,j,k,l,m,n)
#define _ANSIPROT15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)
#define _ANSIPROT16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
#define _ANSIPROT17(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)
/* gcc can take __const__ even if __STDC__ is 0, allow user to define it */
#ifndef const 
#define const
#endif
#define signed
/* gcc can take __volatile__ even if __STDC__ is 0, allow user to define it */
#ifndef volatile
#define volatile
#endif

#endif /* __STDC__ */

#define extern_const const

#if defined(I386) && !defined(lint)
#define FAR     _far
#define NEAR    _near
#define HUGE    _huge
#else
#define FAR
#define NEAR
#define HUGE
#endif

#endif