rfreeimage 0.1.0

data/vendor/FreeImage/Source/LibJXR/common/include/wmspecstrings_strict.h

@@ -0,0 +1,1096 @@
+//*@@@+++@@@@******************************************************************
+//
+// Copyright � Microsoft Corp.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// � Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// � Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//*@@@---@@@@******************************************************************
+
+
+/************************************************************************* 
+*  This file documents all the macros approved for use in windows source
+*  code. It includes some experimental macros which should only be used by
+*  experts.
+*
+*  DO NOT include this file directly.  This file is include after
+*  specstrings.h. So we can undefine every possible old definition including
+*  private internal macros people should not be using, as well as macros from
+*  sal.h.  Macros are redefined here in a way to cause syntax errors when used
+*  incorrectly during a normal build when specstrings.h is included and
+*  __SPECSTRINGS_STRICT_LEVEL is defined.
+*
+*  There are several levels of strictness, each level includes the behavior of
+*  all previous levels.
+*
+*  0 - Disable strict checking 
+*  1 - Break on unapproved macros and misuse of statement 
+*      macros such as __fallthrough (default)
+*  2 - Deprecated some old macros that should not be used
+*  3 - Use VS 2005 Source Annotation to make sure every macro 
+*      is used in the right context. For example placing __in on a return 
+*      parameter will result in an error.
+************************************************************************/
+#ifndef __SPECSTRINGS_STRICT_LEVEL
+#define __SPECSTRINGS_STRICT_LEVEL 1
+#endif
+/************************************************************************
+*  Introduction
+*
+*  specstrings.h provides a set of annotations to describe how a function uses
+*  its parameters - the assumptions it makes about them, and the guarantees it
+*  makes upon finishing.
+* 
+*  Annotations must be placed before a function parameter's type or its return
+*  type. There are two basic classes of common annotations buffer annotations
+*  and advanced annotations.  Buffer annotations describe how functions use
+*  their pointer parameters, and advanced annotations either describe
+*  complex/unusual buffer behavior, or provide additional information about a
+*  parameter that is not otherwise expressible.
+* 
+*  Buffer Annotations
+* 
+*  The most important annotations in SpecStrings.h provide a consistent way to
+*  annotate buffer parameters or return values for a function. Each of these
+*  annotations describes a single buffer (which could be a string, a
+*  fixed-length or variable-length array, or just a pointer) that the function
+*  interacts with: where it is, how large it is, how much is initialized, and
+*  what the function does with it.
+* 
+*  The appropriate macro for a given buffer can be constructed using the table
+*  below.  Just pick the appropriate values from each category, and combine
+*  them together with a leading underscore. Some combinations of values do not
+*  make sense as buffer annotations. Only meaningful annotations can be added
+*  to your code; for a list of these, see the buffer annotation definitions
+*  section.
+* 
+*  Only a single buffer annotation should be used for each parameter.
+* 
+*  |------------|------------|---------|--------|----------|---------------|
+*  |   Level    |   Usage    |  Size   | Output | Optional |  Parameters   |
+*  |------------|------------|---------|--------|----------|---------------|
+*  | <>         | <>         | <>      | <>     | <>       | <>            |
+*  | _deref     | _in        | _ecount | _full  | _opt     | (size)        |
+*  | _deref_opt | _out       | _bcount | _part  |          | (size,length) |
+*  |            | _inout     |         |        |          |               |
+*  |            |            |         |        |          |               |
+*  |------------|------------|---------|--------|----------|---------------|
+*
+*  Note: "<>" represents the empty string.
+* 
+*  Level: Describes the buffer pointer's level of indirection from the
+*  parameter or return value 'p'.
+* 
+*  <>         : p is the buffer pointer.
+*  _deref     : *p is the buffer pointer. p must not be NULL.
+*  _deref_opt : *p may be the buffer pointer. p may be NULL, in which case the 
+*               rest of the annotation is ignored.
+* 
+*  Usage: Describes how the function uses the buffer.
+* 
+*  <> : The buffer is not accessed. If used on the return value or with
+*  _deref, the function will provide the buffer, and it will be uninitialized
+*  at exit.  Otherwise, the caller must provide the buffer. This should only
+*  be used for alloc and free functions.
+*
+*  _in : The function will only read from the buffer. The caller must provide
+*  the buffer and initialize it.
+*
+*  _out : The function will only write to the buffer. If used on the return
+*  value or with _deref, the function will provide the buffer and initialize
+*  it.  Otherwise, the caller must provide the buffer, and the function will
+*  initialize it.
+*
+*  _inout : The function may freely read from and write to the buffer. The
+*  caller must provide the buffer and initialize it. If used with _deref, the
+*  buffer may be reallocated by the function.
+*
+*  Size: Describes the total size of the buffer. This may be less than the
+*  space actually allocated for the buffer, in which case it describes the
+*  accessible amount.
+* 
+*  <> : No buffer size is given. If the type specifies the buffer size (such
+*  as with LPSTR and LPWSTR), that amount is used. Otherwise, the buffer is
+*  one element long. Must be used with _in, _out, or _inout.
+*
+*  _ecount : The buffer size is an explicit element count.
+*
+*  _bcount : The buffer size is an explicit byte count.
+* 
+*  Output: Describes how much of the buffer will be initialized by the
+*  function. For _inout buffers, this also describes how much is initialized
+*  at entry. Omit this category for _in buffers; they must be fully
+*  initialized by the caller.
+* 
+*  <> : The type specifies how much is initialized. For instance, a function
+*  initializing an LPWSTR must NULL-terminate the string.
+*
+*  _full : The function initializes the entire buffer.
+*
+*  _part : The function initializes part of the buffer, and explicitly
+*  indicates how much.
+* 
+*  Optional: Describes if the buffer itself is optional.
+* 
+*  <>   : The pointer to the buffer must not be NULL.
+*
+*  _opt : The pointer to the buffer might be NULL. It will be checked before
+*  being dereferenced.
+* 
+*  Parameters: Gives explicit counts for the size and length of the buffer.
+* 
+*  <> : There is no explicit count. Use when neither _ecount nor _bcount is
+*  used.
+*
+*  (size) : Only the buffer's total size is given. Use with _ecount or _bcount
+*  but not _part.
+*
+*  (size,length) : The buffer's total size and initialized length are
+*  given. Use with _ecount_part and _bcount_part.
+* 
+*  ----------------------------------------------------------------------------
+*  Buffer Annotation Examples
+* 
+*  LWSTDAPI_(BOOL) StrToIntExA(
+*      LPCSTR pszString,  //  No annotation required, const implies __in.
+*      DWORD dwFlags,
+*      __out int *piRet   // A pointer whose dereference will be filled in.
+*  );
+* 
+*  void MyPaintingFunction(
+*      __in HWND hwndControl,     //  An initialized read-only parameter.
+*      __in_opt HDC hdcOptional,  //  An initialized read-only parameter that 
+*                                 //  might be NULL.
+*      __inout IPropertyStore *ppsStore // An initialized parameter that 
+*                                       // may be freely used and modified.
+*  );
+* 
+*  LWSTDAPI_(BOOL) PathCompactPathExA(
+*      __out_ecount(cchMax) LPSTR pszOut, //  A string buffer with cch elements
+*                                         //  that will be '\0' terminated 
+*                                         //  on exit.
+*      LPCSTR pszSrc,                     //  No annotation required, 
+*                                         //  const implies __in.
+*      UINT cchMax,                              
+*      DWORD dwFlags
+*  );
+* 
+*  HRESULT SHLocalAllocBytes(
+*      size_t cb,
+*      __deref_bcount(cb) T **ppv //  A pointer whose dereference will be set
+*                                 //  to an uninitialized buffer with cb bytes.
+*  );
+* 
+*  __inout_bcount_full(cb) : A buffer with cb elements that is fully
+*  initialized at entry and exit, and may be written to by this function.
+* 
+*  __out_ecount_part(count, *countOut) : A buffer with count elements that
+*  will be partially initialized by this function. The function indicates how
+*  much it initialized by setting *countOut.
+* 
+************************************************************************/
+#if (_MSC_VER >= 1400) && !defined(__midl) && !defined(_PREFAST_) && (__SPECSTRINGS_STRICT_LEVEL > 0)
+#pragma once
+#include <wmspecstrings_undef.h>
+#define __ecount(size)                                __allowed(on_return)
+#define __bcount(size)                                __allowed(on_return)
+#define __xcount(size)                                __allowed(on_return)
+#define __in                                          __allowed(on_parameter)
+#define __in_ecount(size)                             __allowed(on_parameter)
+#define __in_bcount(size)                             __allowed(on_parameter)
+#define __in_xcount(size)                             __allowed(on_parameter)
+#define __in_z                                        __allowed(on_parameter)
+#define __in_ecount_z(size)                           __allowed(on_parameter)
+#define __in_bcount_z(size)                           __allowed(on_parameter)
+#define __out                                         __allowed(on_parameter)
+#define __out_ecount(size)                            __allowed(on_parameter)
+#define __out_bcount(size)                            __allowed(on_parameter)
+#define __out_xcount(size)                            __allowed(on_parameter)
+#define __out_ecount_part(size,len)                   __allowed(on_parameter)
+#define __out_bcount_part(size,len)                   __allowed(on_parameter)
+#define __out_xcount_part(size,len)                   __allowed(on_parameter)
+#define __out_ecount_full(size)                       __allowed(on_parameter)
+#define __out_bcount_full(size)                       __allowed(on_parameter)
+#define __out_xcount_full(size)                       __allowed(on_parameter)
+#define __out_z				              __allowed(on_parameter)
+#define __out_ecount_z(size)                          __allowed(on_parameter)
+#define __out_bcount_z(size)                          __allowed(on_parameter)
+#define __inout                                       __allowed(on_parameter)
+#define __inout_ecount(size)                          __allowed(on_parameter)
+#define __inout_bcount(size)                          __allowed(on_parameter)
+#define __inout_xcount(size)                          __allowed(on_parameter)
+#define __inout_ecount_part(size,len)                 __allowed(on_parameter)
+#define __inout_bcount_part(size,len)                 __allowed(on_parameter)
+#define __inout_xcount_part(size,len)                 __allowed(on_parameter)
+#define __inout_ecount_full(size)                     __allowed(on_parameter)
+#define __inout_bcount_full(size)                     __allowed(on_parameter)
+#define __inout_xcount_full(size)                     __allowed(on_parameter)
+#define __inout_z                                     __allowed(on_parameter)
+#define __inout_ecount_z(size)                        __allowed(on_parameter)
+#define __inout_bcount_z(size)                        __allowed(on_parameter)
+#define __ecount_opt(size)                            __allowed(on_parameter)
+#define __bcount_opt(size)                            __allowed(on_parameter)
+#define __xcount_opt(size)                            __allowed(on_parameter)
+#define __in_opt                                      __allowed(on_parameter)
+#define __in_ecount_opt(size)                         __allowed(on_parameter)
+#define __in_bcount_opt(size)                         __allowed(on_parameter)
+#define __in_z_opt                                    __allowed(on_parameter)
+#define __in_ecount_z_opt(size)                       __allowed(on_parameter)
+#define __in_bcount_z_opt(size)                       __allowed(on_parameter)
+#define __in_xcount_opt(size)                         __allowed(on_parameter)
+#define __out_opt                                     __allowed(on_parameter)
+#define __out_ecount_opt(size)                        __allowed(on_parameter)
+#define __out_bcount_opt(size)                        __allowed(on_parameter)
+#define __out_xcount_opt(size)                        __allowed(on_parameter)
+#define __out_ecount_part_opt(size,len)               __allowed(on_parameter)
+#define __out_bcount_part_opt(size,len)               __allowed(on_parameter)
+#define __out_xcount_part_opt(size,len)               __allowed(on_parameter)
+#define __out_ecount_full_opt(size)                   __allowed(on_parameter)
+#define __out_bcount_full_opt(size)                   __allowed(on_parameter)
+#define __out_xcount_full_opt(size)                   __allowed(on_parameter)
+#define __out_ecount_z_opt(size)                      __allowed(on_parameter)
+#define __out_bcount_z_opt(size)                      __allowed(on_parameter)
+#define __inout_opt                                   __allowed(on_parameter)
+#define __inout_ecount_opt(size)                      __allowed(on_parameter)
+#define __inout_bcount_opt(size)                      __allowed(on_parameter)
+#define __inout_xcount_opt(size)                      __allowed(on_parameter)
+#define __inout_ecount_part_opt(size,len)             __allowed(on_parameter)
+#define __inout_bcount_part_opt(size,len)             __allowed(on_parameter)
+#define __inout_xcount_part_opt(size,len)             __allowed(on_parameter)
+#define __inout_ecount_full_opt(size)                 __allowed(on_parameter)
+#define __inout_bcount_full_opt(size)                 __allowed(on_parameter)
+#define __inout_xcount_full_opt(size)                 __allowed(on_parameter)
+#define __inout_z_opt                                 __allowed(on_parameter)
+#define __inout_ecount_z_opt(size)                    __allowed(on_parameter)
+#define __inout_ecount_z_opt(size)                    __allowed(on_parameter)
+#define __inout_bcount_z_opt(size)                    __allowed(on_parameter)
+#define __deref_ecount(size)                          __allowed(on_parameter)
+#define __deref_bcount(size)                          __allowed(on_parameter)
+#define __deref_xcount(size)                          __allowed(on_parameter)
+#define __deref_in                                    __allowed(on_parameter)
+#define __deref_in_ecount(size)                       __allowed(on_parameter)
+#define __deref_in_bcount(size)                       __allowed(on_parameter)
+#define __deref_in_xcount(size)                       __allowed(on_parameter)
+#define __deref_out                                   __allowed(on_parameter)
+#define __deref_out_ecount(size)                      __allowed(on_parameter)
+#define __deref_out_bcount(size)                      __allowed(on_parameter)
+#define __deref_out_xcount(size)                      __allowed(on_parameter)
+#define __deref_out_ecount_part(size,len)             __allowed(on_parameter)
+#define __deref_out_bcount_part(size,len)             __allowed(on_parameter)
+#define __deref_out_xcount_part(size,len)             __allowed(on_parameter)
+#define __deref_out_ecount_full(size)                 __allowed(on_parameter)
+#define __deref_out_bcount_full(size)                 __allowed(on_parameter)
+#define __deref_out_xcount_full(size)                 __allowed(on_parameter)
+#define __deref_out_z                                 __allowed(on_parameter)
+#define __deref_out_ecount_z(size)                    __allowed(on_parameter)
+#define __deref_out_bcount_z(size)                    __allowed(on_parameter)
+#define __deref_out_xcount(size)                      __allowed(on_parameter)
+#define __deref_inout                                 __allowed(on_parameter)
+#define __deref_inout_ecount(size)                    __allowed(on_parameter)
+#define __deref_inout_bcount(size)                    __allowed(on_parameter)
+#define __deref_inout_xcount(size)                    __allowed(on_parameter)
+#define __deref_inout_ecount_part(size,len)           __allowed(on_parameter)
+#define __deref_inout_bcount_part(size,len)           __allowed(on_parameter)
+#define __deref_inout_xcount_part(size,len)           __allowed(on_parameter)
+#define __deref_inout_ecount_full(size)               __allowed(on_parameter)
+#define __deref_inout_bcount_full(size)               __allowed(on_parameter)
+#define __deref_inout_xcount_full(size)               __allowed(on_parameter)
+#define __deref_inout_z                               __allowed(on_parameter)
+#define __deref_inout_ecount_z(size)                  __allowed(on_parameter)
+#define __deref_inout_bcount_z(size)                  __allowed(on_parameter)
+#define __deref_ecount_opt(size)                      __allowed(on_parameter)
+#define __deref_bcount_opt(size)                      __allowed(on_parameter)
+#define __deref_xcount_opt(size)                      __allowed(on_parameter)
+#define __deref_in_opt                                __allowed(on_parameter)
+#define __deref_in_ecount_opt(size)                   __allowed(on_parameter)
+#define __deref_in_bcount_opt(size)                   __allowed(on_parameter)
+#define __deref_in_xcount_opt(size)                   __allowed(on_parameter)
+#define __deref_out_opt                               __allowed(on_parameter)
+#define __deref_out_ecount_opt(size)                  __allowed(on_parameter)
+#define __deref_out_bcount_opt(size)                  __allowed(on_parameter)
+#define __deref_out_xcount_opt(size)                  __allowed(on_parameter)
+#define __deref_out_ecount_part_opt(size,len)         __allowed(on_parameter)
+#define __deref_out_bcount_part_opt(size,len)         __allowed(on_parameter)
+#define __deref_out_xcount_part_opt(size,len)         __allowed(on_parameter)
+#define __deref_out_ecount_full_opt(size)             __allowed(on_parameter)
+#define __deref_out_bcount_full_opt(size)             __allowed(on_parameter)
+#define __deref_out_xcount_full_opt(size)             __allowed(on_parameter)
+#define __deref_out_z_opt                             __allowed(on_parameter)
+#define __deref_out_ecount_z_opt(size)                __allowed(on_parameter)
+#define __deref_out_bcount_z_opt(size)                __allowed(on_parameter)
+#define __deref_inout_opt                             __allowed(on_parameter)
+#define __deref_inout_ecount_opt(size)                __allowed(on_parameter)
+#define __deref_inout_bcount_opt(size)                __allowed(on_parameter)
+#define __deref_inout_xcount_opt(size)                __allowed(on_parameter)
+#define __deref_inout_ecount_part_opt(size,len)       __allowed(on_parameter)
+#define __deref_inout_bcount_part_opt(size,len)       __allowed(on_parameter)
+#define __deref_inout_xcount_part_opt(size,len)       __allowed(on_parameter)
+#define __deref_inout_ecount_full_opt(size)           __allowed(on_parameter)
+#define __deref_inout_bcount_full_opt(size)           __allowed(on_parameter)
+#define __deref_inout_xcount_full_opt(size)           __allowed(on_parameter)
+#define __deref_inout_z_opt                           __allowed(on_parameter)
+#define __deref_inout_ecount_z_opt(size)              __allowed(on_parameter)
+#define __deref_inout_bcount_z_opt(size)              __allowed(on_parameter)
+#define __deref_opt_ecount(size)                      __allowed(on_parameter)
+#define __deref_opt_bcount(size)                      __allowed(on_parameter)
+#define __deref_opt_xcount(size)                      __allowed(on_parameter)
+#define __deref_opt_in                                __allowed(on_parameter)
+#define __deref_opt_in_ecount(size)                   __allowed(on_parameter)
+#define __deref_opt_in_bcount(size)                   __allowed(on_parameter)
+#define __deref_opt_in_xcount(size)                   __allowed(on_parameter)
+#define __deref_opt_out                               __allowed(on_parameter)
+#define __deref_opt_out_ecount(size)                  __allowed(on_parameter)
+#define __deref_opt_out_bcount(size)                  __allowed(on_parameter)
+#define __deref_opt_out_xcount(size)                  __allowed(on_parameter)
+#define __deref_opt_out_ecount_part(size,len)         __allowed(on_parameter)
+#define __deref_opt_out_bcount_part(size,len)         __allowed(on_parameter)
+#define __deref_opt_out_xcount_part(size,len)         __allowed(on_parameter)
+#define __deref_opt_out_ecount_full(size)             __allowed(on_parameter)
+#define __deref_opt_out_bcount_full(size)             __allowed(on_parameter)
+#define __deref_opt_out_xcount_full(size)             __allowed(on_parameter)
+#define __deref_opt_inout                             __allowed(on_parameter)
+#define __deref_opt_inout_ecount(size)                __allowed(on_parameter)
+#define __deref_opt_inout_bcount(size)                __allowed(on_parameter)
+#define __deref_opt_inout_xcount(size)                __allowed(on_parameter)
+#define __deref_opt_inout_ecount_part(size,len)       __allowed(on_parameter)
+#define __deref_opt_inout_bcount_part(size,len)       __allowed(on_parameter)
+#define __deref_opt_inout_xcount_part(size,len)       __allowed(on_parameter)
+#define __deref_opt_inout_ecount_full(size)           __allowed(on_parameter)
+#define __deref_opt_inout_bcount_full(size)           __allowed(on_parameter)
+#define __deref_opt_inout_xcount_full(size)           __allowed(on_parameter)
+#define __deref_opt_inout_z                           __allowed(on_parameter)
+#define __deref_opt_inout_ecount_z(size)              __allowed(on_parameter)
+#define __deref_opt_inout_bcount_z(size)              __allowed(on_parameter)
+#define __deref_opt_ecount_opt(size)                  __allowed(on_parameter)
+#define __deref_opt_bcount_opt(size)                  __allowed(on_parameter)
+#define __deref_opt_xcount_opt(size)                  __allowed(on_parameter)
+#define __deref_opt_in_opt                            __allowed(on_parameter)
+#define __deref_opt_in_ecount_opt(size)               __allowed(on_parameter)
+#define __deref_opt_in_bcount_opt(size)               __allowed(on_parameter)
+#define __deref_opt_in_xcount_opt(size)               __allowed(on_parameter)
+#define __deref_opt_out_opt                           __allowed(on_parameter)
+#define __deref_opt_out_ecount_opt(size)              __allowed(on_parameter)
+#define __deref_opt_out_bcount_opt(size)              __allowed(on_parameter)
+#define __deref_opt_out_xcount_opt(size)              __allowed(on_parameter)
+#define __deref_opt_out_ecount_part_opt(size,len)     __allowed(on_parameter)
+#define __deref_opt_out_bcount_part_opt(size,len)     __allowed(on_parameter)
+#define __deref_opt_out_xcount_part_opt(size,len)     __allowed(on_parameter)
+#define __deref_opt_out_ecount_full_opt(size)         __allowed(on_parameter)
+#define __deref_opt_out_bcount_full_opt(size)         __allowed(on_parameter)
+#define __deref_opt_out_xcount_full_opt(size)         __allowed(on_parameter)  
+#define __deref_opt_out_z_opt                         __allowed(on_parameter)
+#define __deref_opt_out_ecount_z_opt(size)            __allowed(on_parameter)
+#define __deref_opt_out_bcount_z_opt(size)            __allowed(on_parameter)
+#define __deref_opt_inout_opt                         __allowed(on_parameter)
+#define __deref_opt_inout_ecount_opt(size)            __allowed(on_parameter)
+#define __deref_opt_inout_bcount_opt(size)            __allowed(on_parameter)
+#define __deref_opt_inout_xcount_opt(size)            __allowed(on_parameter)
+#define __deref_opt_inout_ecount_part_opt(size,len)   __allowed(on_parameter) 
+#define __deref_opt_inout_bcount_part_opt(size,len)   __allowed(on_parameter)
+#define __deref_opt_inout_xcount_part_opt(size,len)   __allowed(on_parameter)
+#define __deref_opt_inout_ecount_full_opt(size)       __allowed(on_parameter)
+#define __deref_opt_inout_bcount_full_opt(size)       __allowed(on_parameter)
+#define __deref_opt_inout_xcount_full_opt(size)       __allowed(on_parameter)
+#define __deref_opt_inout_z_opt                       __allowed(on_parameter)
+#define __deref_opt_inout_ecount_z_opt(size)          __allowed(on_parameter)
+#define __deref_opt_inout_bcount_z_opt(size)          __allowed(on_parameter)
+/************************************************************************
+*  Advanced Annotations
+* 
+*  Advanced annotations describe behavior that is not expressible with the
+*  regular buffer macros. These may be used either to annotate buffer
+*  parameters that involve complex or conditional behavior, or to enrich
+*  existing annotations with additional information.
+* 
+*  __success(expr) T f() : <expr> indicates whether function f succeeded or
+*  not. If <expr> is true at exit, all the function's guarantees (as given
+*  by other annotations) must hold. If <expr> is false at exit, the caller
+*  should not expect any of the function's guarantees to hold. If not used,
+*  the function must always satisfy its guarantees. Added automatically to
+*  functions that indicate success in standard ways, such as by returning an
+*  HRESULT.
+* 
+*  __out_awcount(expr, size) T *p : Pointer p is a buffer whose size may be
+*  given in either bytes or elements. If <expr> is true, this acts like
+*  __out_bcount. If <expr> is false, this acts like __out_ecount. This
+*  should only be used to annotate old APIs.
+* 
+*  __in_awcount(expr, size) T* p : Pointer p is a buffer whose size may be given
+*  in either bytes or elements. If <expr> is true, this acts like
+*  __in_bcount. If <expr> is false, this acts like __in_ecount. This should
+*  only be used to annotate old APIs.
+* 
+*  __nullterminated T* p : Pointer p is a buffer that may be read or written
+*  up to and including the first '\0' character or pointer. May be used on
+*  typedefs, which marks valid (properly initialized) instances of that type
+*  as being null-terminated.
+* 
+*  __nullnullterminated T* p : Pointer p is a buffer that may be read or
+*  written up to and including the first sequence of two '\0' characters or
+*  pointers. May be used on typedefs, which marks valid instances of that
+*  type as being double-null terminated.
+* 
+*  __reserved T v : Value v must be 0/NULL, reserved for future use.
+* 
+*  __checkReturn T f(); : Return value of f must not be ignored by callers
+*  of this function.
+* 
+*  __typefix(ctype) T v : Value v should be treated as an instance of ctype,
+*  rather than its declared type when considering validity.
+* 
+*  __override T f(); : Specify C#-style 'override' behaviour for overriding
+*  virtual methods.
+* 
+*  __callback T f(); : Function f can be used as a function pointer.
+* 
+*  __format_string T p : Pointer p is a string that contains % markers in
+*  the style of printf.
+* 
+*  __blocksOn(resource) f(); : Function f blocks on the resource 'resource'.
+* 
+*  __fallthrough : Annotates switch statement labels where fall-through is
+*  desired, to distinguish from forgotten break statements.
+* 
+*  __range(low_bnd, up_bnd) int f(): The return from the function "f" must
+*  be in the inclusive numeric range [low_bnd, up_bnd].
+*
+*  __in_range(low_bnd, up_bnd) int i : Precondition that integer i must be
+*  in the inclusive numeric range [low_bnd, up_bnd].
+* 
+*  __out_range(low_bnd, up_bnd) int i : Postcondition that integer i must be
+*  in the inclusive numeric range [low_bnd, up_bnd].
+* 
+*  __deref_in_range(low_bnd, up_bnd) int* pi : Precondition that integer *pi
+*  must be in the inclusive numeric range [low_bnd, up_bnd].
+*
+*  __deref_out_range(low_bnd, up_bnd) int* pi : Postcondition that integer
+*  *pi must be in the inclusive numeric range [low_bnd, up_bnd].
+*
+*  The first argument of a range macro may also be a C relational operator
+*  (<,>,!=, ==, <=, >=).
+*  
+*  __range(rel_op, j) int f(): Postcondition that "f() rel_op j" must be
+*  true.  Note that j may be a expression known only at runtime.
+*
+*  __in_range(rel_op, j) int i : Precondition that "i rel_op j" must be
+*  true.  Note that j may be a expression known only at runtime.
+* 
+*  __out_range(rel_op, j) int i : Postcondition that integer "i rel_op j"
+*  must be true.  Note that j may be a expression known only at runtime.
+* 
+*  __deref_in_range(rel_op, j) int *pi : Precondition that "*pi rel_op j"
+*  must be true.  Note that j may be a expression known only at runtime.
+*
+*  __deref_out_range(rel_op, j) int *pi : Postcondition that "*pi rel_op j"
+*  must be true.  Note that j may be a expression known only at runtime.
+*
+*  __in_bound int i : Precondition that integer i must be bound, but the
+*  exact range can't be specified at compile time.  __in_range should be
+*  used if the range can be explicitly stated.
+*
+*  __out_bound int i : Postcondition that integer i must be bound, but the
+*  exact range can't be specified at compile time.  __out_range should be
+*  used if the range can be explicitly stated.
+* 
+*  __deref_out_bound int pi : Postcondition that integer *pi must be bound,
+*  but the exact range can't be specified at compile time.
+*  __deref_out_range should be used if the range can be explicitly stated.
+* 
+*  __assume_bound(expr); : Assume that the expression is bound to some known
+*  range. This can be used to suppress integer overflow warnings on integral
+*  expressions that are known to be bound due to reasons not explicit in the
+*  code. Use as a statement in the body of a function.
+* 
+*  __allocator void f(): Function allocates memory using an integral size
+*  argument
+*
+*  ----------------------------------------------------------------------------
+*  Advanced Annotation Examples
+* 
+*  __success(return == TRUE) LWSTDAPI_(BOOL) 
+*  PathCanonicalizeA(__out_ecount(MAX_PATH) LPSTR pszBuf, LPCSTR pszPath);
+*  //  pszBuf is only guaranteed to be null-terminated when TRUE is returned.
+* 
+*  // Initialized LPWSTRs are null-terminated strings.
+*  typedef __nullterminated WCHAR* LPWSTR;
+* 
+*  __out_ecount(cch) __typefix(LPWSTR) void *psz;
+*  // psz is a buffer parameter which will be a null-terminated WCHAR string 
+*  // at exit, and which initially contains cch WCHARs.
+* 
+************************************************************************/
+#define __success(expr)          __allowed(on_function_or_typedecl)
+#define __out_awcount(expr,size) __allowed(on_parameter) 
+#define __in_awcount(expr,size)  __allowed(on_parameter)   
+#define __nullterminated         __allowed(on_typedecl)
+#define __nullnullterminated     __allowed(on_typedecl)
+#define __reserved               __allowed(on_parameter)
+#define __checkReturn            __allowed(on_function)
+#define __typefix(ctype)         __allowed(on_parameter_or_return) 
+#define __override               __allowed(on_function) 
+#define __callback               __allowed(on_function) 
+#define __format_string          __allowed(on_parameter_or_return) 
+#define __blocksOn(resource)     __allowed(on_function) 
+#define __fallthrough            __allowed(as_statement)
+#define __range(lb,ub)           __allowed(on_return) 
+#define __in_range(lb,ub)        __allowed(on_parameter) 
+#define __out_range(lb,ub)       __allowed(on_parameter) 
+#define __deref_in_range(lb,ub)  __allowed(on_parameter) 
+#define __deref_out_range(lb,ub) __allowed(on_parameter) 
+#define __field_range(lb,ub)     __allowed(on_field)
+#define __bound                  __allowed(on_return) 
+#define __in_bound               __allowed(on_parameter) 
+#define __out_bound              __allowed(on_parameter) 
+#define __deref_out_bound        __allowed(on_parameter) 
+#define __assume_bound(i)        __allowed(as_statement_with_arg(i))
+#define __allocator              __allowed(on_function) 
+/*************************************************************************** 
+* Expert Macros
+***************************************************************************/
+#define __null                  __allowed(on_typedecl)
+#define __notnull               __allowed(on_typedecl)
+#define __maybenull             __allowed(on_typedecl)
+#define __exceptthat            __allowed(on_typedecl)
+/*************************************************************************** 
+* Macros to classify fields of structures.
+*                          Structure Annotations
+*
+*   The buffer annotations are a convenient way of describing
+*   relationships between buffers and their size on a function by
+*   function basis. Very often struct or class data members have similar
+*   invariants, which can be expressed directly on the type.
+*
+*   Similar to our buffer annotations we can summarize all the various
+*   structure annotations by one choosing an element from each column of
+*   this table to build a composite annotation.
+*
+*           +--------------------------------------------------+
+*           | Selector |  Units  |    Size/Init     | Optional |
+*           |----------+---------+------------------+----------|
+*           | __field  | _ecount | (size)           | empty    |
+*           |----------+---------+------------------+----------|
+*           | __struct | _bcount | _full(size)      | _opt     |
+*           |----------+---------+------------------+----------|
+*           |          | _xcount | _part(size,init) |          |
+*           +--------------------------------------------------+
+*
+*   Note that empty represents the empty string. Sometime arguments need
+*   to be "floated" to the left to give us a valid annotation name. For
+*   example the naive combination __field_ecount(size)_opt is actually
+*   written as __field_ecount_opt(size). Not all possible combinations
+*   are currently supported or sensible. See specstrings_strict.h for
+*   the currently supported set. Those that are supported are documented
+*   below.
+*
+*Summary of Elements
+*
+*   Selector
+*
+*                __field
+*                        The annotation should only be placed in front
+*                        of data members of structures and classes. The
+*                        data members are pointers to a block of data.
+*                        The annotations describe properties about the
+*                        size of the block of data. This can be used for
+*
+*                __struct
+*                        The annotation should only be placed at the
+*                        beginning of the definition of a structure or
+*                        class. These annotations are used when a struct
+*                        or class is used as a "header" that is
+*                        allocated inline with a block of data and there
+*                        is no apparent field that represents the tail
+*                        end of the structure.
+*
+*   Units
+*
+*                _ecount
+*                        All size and initialization values are in terms
+*                        of elements of the appropriate type
+*
+*                _bcount
+*                        All size and initialization values are in terms
+*                        of raw byte sizes.
+*
+*                _xcount
+*                        The size or initialization values cannot be
+*                        properly expressed as a simple byte or element
+*                        count, and instead a place holder is used to
+*                        document the relationship.
+*
+*   Size/Init
+*           All the size/init expressions can contain references to
+*           other fields in the struct or class.
+*
+*                (size)
+*                        The size of the buffer is determined by the
+*                        expression size. Unless, the type of the buffer
+*                        provides more information nothing is know about
+*                        how much of this data is initialized. For
+*                        example, if the data member happens to be a
+*                        string type such as LPSTR. It is assumed that
+*                        the data is initialized to the first '\0'.
+*
+*                _full(size)
+*                        The size of the buffer is determined by the
+*                        expression size and all the data in the buffer
+*                        is guaranteed to be initialized.
+*
+*                _part(size,init)
+*                        The size of the buffer is determined by the
+*                        expression size and all the data in the buffer
+*                        is guaranteed to be initialized up to init
+*                        elements or bytes.
+*
+*   Optional
+*
+*                empty
+*                        The pointer to the block of memory is never
+*                        NULL
+*
+*                _opt
+*                        The pointer to the block of memory is may be
+*                        NULL
+*
+*     
+*   // Basic Usage of Struct Annotations                         
+*   #include <stdio.h>                                           
+*   #include <stdlib.h>                                          
+*   struct buf_s {                                               
+*    int sz;                                                     
+*    __field_bcount_full(sz)                                     
+*    char *buf;                                                  
+*   };                                                           
+*   void InitBuf(__out struct *buf_s b,int sz) {                 
+*        b->buf = calloc(sz,sizeof(char));                       
+*        b->sz = sz;                                             
+*   }                                                            
+*   void WriteBuf(__in FILE *fp,__in struct *buf_s b) {          
+*     fwrite(b->buf,b->sz,sizeof(char),fp);                      
+*   }                                                            
+*   void ReadBuf(__in FILE *fp,__inout struct *buf_s b) {        
+*     fread(b->buf,b->sz,sizeof(char),fp);                       
+*   }                                                            
+*                                                                 
+*                                                                 
+*                                                                 
+*   // Inline Allocated Buffer                                   
+*   struct buf_s {                                               
+*    int sz;                                                     
+*    __field_bcount(sz)                                          
+*    char buf[1];                                                
+*   };                                                           
+*   void WriteBuf(__in FILE *fp,__in struct *buf_s b) {          
+*     fwrite(&(b->buf),b->sz,sizeof(char),fp);                   
+*   }                                                            
+*   void ReadBuf(__in FILE *fp,__inout struct *buf_s b) {        
+*     fread(&(b->buf),b->sz,sizeof(char),fp);                    
+*   }                                                            
+*                                                                 
+*                                                                 
+*                                                                 
+*   // Embedded Header Structure                                 
+*   __struct_bcount(sz)                                          
+*   struct buf_s {                                               
+*    int sz;                                                     
+*   };                                                           
+*   void WriteBuf(__in FILE *fp,__in struct *buf_s b) {          
+*     fwrite(&b,b->sz,sizeof(char),fp);                          
+*   }                                                            
+*   void ReadBuf(__in FILE *fp,__inout struct *buf_s b) {        
+*     fread(&b,b->sz,sizeof(char),fp);                           
+*   }                                                            
+*
+*
+****************************************************************************/
+#define __field_ecount(size)               __allowed(on_field)
+#define __field_bcount(size)               __allowed(on_field)
+#define __field_xcount(size)               __allowed(on_field)
+#define __field_ecount_opt(size)           __allowed(on_field)
+#define __field_bcount_opt(size)           __allowed(on_field)
+#define __field_xcount_opt(size)           __allowed(on_field)
+#define __field_ecount_part(size,init)     __allowed(on_field)
+#define __field_bcount_part(size,init)     __allowed(on_field)
+#define __field_xcount_part(size,init)     __allowed(on_field)
+#define __field_ecount_part_opt(size,init) __allowed(on_field)
+#define __field_bcount_part_opt(size,init) __allowed(on_field)
+#define __field_xcount_part_opt(size,init) __allowed(on_field)
+#define __field_ecount_full(size)          __allowed(on_field)
+#define __field_bcount_full(size)          __allowed(on_field)
+#define __field_xcount_full(size)          __allowed(on_field)
+#define __field_ecount_full_opt(size)      __allowed(on_field)
+#define __field_bcount_full_opt(size)      __allowed(on_field) 
+#define __field_xcount_full_opt(size)      __allowed(on_field)
+#define __struct_bcount(size)              __allowed(on_struct) 
+#define __struct_xcount(size)              __allowed(on_struct) 
+
+/*************************************************************************** 
+* Macros to classify the entrypoints and indicate their category.
+*
+* Pre-defined control point categories include: RPC, KERNEL, GDI.
+*
+* Pre-defined control point macros include:
+*  __rpc_entry, __kernel_entry, __gdi_entry.
+***************************************************************************/
+#define __control_entrypoint(category)     __allowed(on_function) 
+#define __rpc_entry                        __allowed(on_function) 
+#define __kernel_entry                     __allowed(on_function) 
+#define __gdi_entry                        __allowed(on_function)  
+
+/*************************************************************************** 
+* Macros to track untrusted data and their validation. The list of untrusted
+* sources include:
+*
+* FILE                     - File reading stream or API
+* NETWORK                  - Socket readers
+* INTERNET                 - WinInet and WinHttp readers
+* USER_REGISTRY            - HKCU portions of the registry
+* USER_MODE                - Parameters to kernel entry points
+* RPC                      - Parameters to RPC entry points 
+* DRIVER                   - Device driver 
+***************************************************************************/
+#define __in_data_source(src_sym)       __allowed(on_parameter) 
+#define __out_data_source(src_sym)      __allowed(on_parameter) 
+#define __field_data_source(src_sym)    __allowed(on_field)
+#define __this_out_data_source(src_syn) __allowed(on_function)
+
+/************************************************************************** 
+* Macros to tag file parsing code. Predefined formats include:
+*  PNG                     - Portable Network Graphics
+*  JPEG                    - Joint Photographic Experts Group
+*  BMP                     - Bitmap
+*  RC_BMP                  - Resource bitmap
+*  WMF                     - Windows Metafile
+*  EMF                     - Windows Enhanced Metafile
+*  GIF                     - Graphics Interchange Format
+*  MIME_TYPE               - MIME type from header tokens
+*  MAIL_MONIKER            - MAIL information refered by URL moniker
+*  HTML                    - HyperText Markup Language
+*  WMPHOTO                 - Windows media photo
+*  OE_VCARD                - Outlook Express virtual card
+*  OE_CONTACT              - Outlook Express contact
+*  MIDI                    - Musical Instrument Digital Interface
+*  LDIF                    - LDAP Data Interchange Format
+*  AVI                     - Audio Visual Interchange
+*  ACM                     - Audio Compression Manager
+**************************************************************************/
+#define __out_validated(filetype_sym)         __allowed(on_parameter) 
+#define __this_out_validated(filetype_sym)    __allowed(on_function)   
+#define __file_parser(filetype_sym)           __allowed(on_function) 
+#define __file_parser_class(filetype_sym)     __allowed(on_struct)  
+#define __file_parser_library(filetype_sym)   __allowed(as_global_decl)  
+
+/*************************************************************************** 
+* Macros to track the code content in the file. The type of code
+* contents currently tracked:
+*
+* NDIS_DRIVER                   - NDIS Device driver 
+***************************************************************************/
+#define __source_code_content(codetype_sym)     __allowed(as_global_decl) 
+
+/*************************************************************************** 
+* Macros to track the code content in the class. The type of code
+* contents currently tracked:
+*
+* DCOM                          - Class implementing DCOM
+***************************************************************************/
+#define __class_code_content(codetype_sym)    __allowed(on_struct) 
+
+/*************************************************************************
+* Macros to tag encoded function pointers
+**************************************************************************/
+#define __encoded_pointer                 
+#define __encoded_array                   
+#define __field_encoded_pointer           __allowed(on_field)
+#define __field_encoded_array             __allowed(on_field)
+
+#define __transfer(formal)                __allowed(on_parameter_or_return) 
+#define __assume_validated(exp)           __allowed(as_statement_with_arg(exp))
+
+/************************************************************************* 
+* __analysis_assume(expr) : Expert macro use only when directed. Use this to
+* tell static analysis tools like PREfix and PREfast about a non-coded
+* assumption that you wish the tools to assume. The assumption will be
+* understood by those tools. By default there is no dynamic checking or
+* static checking of the assumption in any build.
+*
+* To obtain dynamic checking wrap this macro in your local version of a debug
+* assert.
+* Please do not put function calls in the expression because this is not
+* supported by all tools:
+*  __analysis_assume(GetObject () != NULL); // DO NOT DO THIS
+*
+*************************************************************************/
+#define __analysis_assume(expr) __allowed(as_statement_with_arg(expr))
+#define __analysis_assert(expr) __allowed(as_statement_with_arg(expr))
+
+/************************************************************************* 
+* __analysis_hint(hint_sym) : Expert macro use only when
+* directed. Use this to influence certain analysis heuristics
+* used by the tools. These hints do not describe the semantics
+* of functions but simply direct the tools to act in a certain
+* way.
+*
+* Current hints that are supported are:
+*
+* INLINE   - inline this function during analysis overrides any
+*            default heuristics 
+* NOINLINE - do not inline this function during analysis overrides 
+*            and default heuristics
+*************************************************************************/
+#define __analysis_hint(hint) __allowed(on_function)
+
+/************************************************************************* 
+* Macros to encode abstract properties of values. Used by SALadt.h
+*************************************************************************/
+#define __type_has_adt_prop(adt,prop)     __allowed(on_typdecl)
+#define __out_has_adt_prop(adt,prop)      __allowed(on_parameter)
+#define __out_not_has_adt_prop(adt,prop)  __allowed(on_parameter)
+#define __out_transfer_adt_prop(arg)      __allowed(on_parameter)
+#define __out_has_type_adt_props(typ)     __allowed(on_parameter)
+#define __assume_ValidCompNameA(expr)     __allowed(as_statement_with_arg(expr))
+#define __assume_ValidCompNameW(expr)     __allowed(as_statement_with_arg(expr))
+
+/************************************************************************* 
+* Macros used by Prefast for Drivers 
+* 
+*  __possibly_notnulltermiated :
+*
+*  Used for return values of parameters or functions that do not
+*  guarantee nullterimination in all cases.
+*
+*************************************************************************/
+#define __possibly_notnulltermiated     __allowed(on_parameter_or_return)
+
+/************************************************************************* 
+* Advanced macros
+* 
+*  __volatile 
+* The __volatile annotation identifies a global variable or
+* structure field that: 
+*   1) is not declared volatile; 
+*   2) is accessed concurrently by multiple threads.
+*
+* The __deref_volatile annotation identifies a global variable
+* or structure field that stores a pointer to some data that:
+*   1) is not declared volatile; 
+*   2) is accessed concurrently by multiple threads.
+*
+* Prefast uses these annotations to find patterns of code that
+* may result in unexpected re-fetching of the global variable
+* into a local variable.
+*
+* We also provide two complimentary annotations __nonvolatile
+* and __deref_nonvolatile that could be used to suppress Prefast
+*
+* re-fetching warnings on variables that are known either:
+*   1) not to be in danger of being re-fetched or,
+*   2) not to lead to incorrect results if they are re-fetched
+*
+*************************************************************************/
+#define __volatile                       __allowed(on_global_or_field)
+#define __deref_volatile                 __allowed(on_global_or_field)
+#define __nonvolatile                    __allowed(on_global_or_field)
+#define __deref_nonvolatile              __allowed(on_global_or_field)
+
+/************************************************************************* 
+* Macros deprecated with strict level greater then 1.
+**************************************************************************/
+#if (__SPECSTRINGS_STRICT_LEVEL > 1)
+/* Must come before macro defintions */
+#pragma deprecated(__in_nz)
+#pragma deprecated(__in_ecount_nz)
+#pragma deprecated(__in_bcount_nz)
+#pragma deprecated(__out_nz)
+#pragma deprecated(__out_nz_opt)
+#pragma deprecated(__out_ecount_nz)
+#pragma deprecated(__out_bcount_nz)
+#pragma deprecated(__inout_nz)
+#pragma deprecated(__inout_ecount_nz)
+#pragma deprecated(__inout_bcount_nz)
+#pragma deprecated(__in_nz_opt)          
+#pragma deprecated(__in_ecount_nz_opt)
+#pragma deprecated(__in_bcount_nz_opt)
+#pragma deprecated(__out_ecount_nz_opt)
+#pragma deprecated(__out_bcount_nz_opt)
+#pragma deprecated(__inout_nz_opt)       
+#pragma deprecated(__inout_ecount_nz_opt)
+#pragma deprecated(__inout_bcount_nz_opt)
+#pragma deprecated(__deref_out_nz)                 
+#pragma deprecated(__deref_out_ecount_nz)
+#pragma deprecated(__deref_out_bcount_nz)
+#pragma deprecated(__deref_inout_nz)               
+#pragma deprecated(__deref_inout_ecount_nz)
+#pragma deprecated(__deref_inout_bcount_nz)
+#pragma deprecated(__deref_out_nz_opt)             
+#pragma deprecated(__deref_out_ecount_nz_opt)
+#pragma deprecated(__deref_out_bcount_nz_opt)
+#pragma deprecated(__deref_inout_nz_opt)           
+#pragma deprecated(__deref_inout_ecount_nz_opt)
+#pragma deprecated(__deref_inout_bcount_nz_opt)
+#pragma deprecated(__deref_opt_inout_nz)           
+#pragma deprecated(__deref_opt_inout_ecount_nz)
+#pragma deprecated(__deref_opt_inout_bcount_nz)
+#pragma deprecated(__deref_opt_out_nz_opt)         
+#pragma deprecated(__deref_opt_out_ecount_nz_opt)
+#pragma deprecated(__deref_opt_out_bcount_nz_opt)
+#pragma deprecated(__deref_opt_inout_nz_opt)       
+#pragma deprecated(__deref_opt_inout_ecount_nz_opt)
+#pragma deprecated(__deref_opt_inout_bcount_nz_opt)
+#pragma deprecated(__deref)
+#pragma deprecated(__pre)
+#pragma deprecated(__post)
+#pragma deprecated(__readableTo)
+#pragma deprecated(__writableTo)
+#pragma deprecated(__maybevalid)
+#pragma deprecated(__data_entrypoint)
+#pragma deprecated(__inexpressible_readableTo)
+#pragma deprecated(__readonly)
+#pragma deprecated(__byte_writableTo)
+#pragma deprecated(__byte_readableTo)
+#pragma deprecated(__elem_readableTo)
+#pragma deprecated(__elem_writableTo)
+#pragma deprecated(__valid)
+#pragma deprecated(__notvalid)
+#pragma deprecated(__refparam)
+#pragma deprecated(__precond)
+#endif
+/* Define soon to be deprecated macros to nops. */
+#define __in_nz                                       
+#define __in_ecount_nz(size)                          
+#define __in_bcount_nz(size)                          
+#define __out_nz                                      
+#define __out_nz_opt                                  
+#define __out_ecount_nz(size)                         
+#define __out_bcount_nz(size)                         
+#define __inout_nz                                    
+#define __inout_ecount_nz(size)                       
+#define __inout_bcount_nz(size)                       
+#define __in_nz_opt                                   
+#define __in_ecount_nz_opt(size)                      
+#define __in_bcount_nz_opt(size)                      
+#define __out_ecount_nz_opt(size)                     
+#define __out_bcount_nz_opt(size)                     
+#define __inout_nz_opt                                
+#define __inout_ecount_nz_opt(size)                   
+#define __inout_bcount_nz_opt(size)                   
+#define __deref_out_nz                                
+#define __deref_out_ecount_nz(size)                   
+#define __deref_out_bcount_nz(size)                   
+#define __deref_inout_nz                              
+#define __deref_inout_ecount_nz(size)                 
+#define __deref_inout_bcount_nz(size)                 
+#define __deref_out_nz_opt                            
+#define __deref_out_ecount_nz_opt(size)               
+#define __deref_out_bcount_nz_opt(size)               
+#define __deref_inout_nz_opt                          
+#define __deref_inout_ecount_nz_opt(size)             
+#define __deref_inout_bcount_nz_opt(size)             
+#define __deref_opt_inout_nz                          
+#define __deref_opt_inout_ecount_nz(size)             
+#define __deref_opt_inout_bcount_nz(size)             
+#define __deref_opt_out_nz_opt                        
+#define __deref_opt_out_ecount_nz_opt(size)           
+#define __deref_opt_out_bcount_nz_opt(size)           
+#define __deref_opt_inout_nz_opt                      
+#define __deref_opt_inout_ecount_nz_opt(size)         
+#define __deref_opt_inout_bcount_nz_opt(size)         
+#define __deref             
+#define __pre               
+#define __post              
+#define __readableTo(count) 
+#define __writableTo(count) 
+#define __maybevalid        
+#define __inexpressible_readableTo(string) 
+#define __data_entrypoint(category)
+#define __readonly
+#define __byte_writableTo(count)
+#define __byte_readableTo(count)
+#define __elem_readableTo(count)
+#define __elem_writableTo(count)
+#define __valid
+#define __notvalid
+#define __refparam
+#define __precond(condition)
+
+/************************************************************************* 
+* Definitions to force a compile error when macros are used improperly.
+* Relies on VS 2005 source annotations.
+*************************************************************************/
+#define __allowed(p) __$allowed_##p
+#define __$allowed_as_global_decl /* empty */
+#define __$allowed_as_statement_with_arg(x) \
+    __pragma(warning(push)) __pragma(warning(disable : 4548)) \
+        do {__noop(x);} while((0,0) __pragma(warning(pop)) )
+#define __$allowed_as_statement __$allowed_as_statement_with_arg(1)
+
+/**************************************************************************
+*  This should go away. It's only for __success which we should split into.
+*  __success and __typdecl_sucess
+***************************************************************************/
+#define __$allowed_on_function_or_typedecl /* empty */
+#if (__SPECSTRINGS_STRICT_LEVEL == 1) || (__SPECSTRINGS_STRICT_LEVEL == 2)
+#define __$allowed_on_typedecl /* empty */
+#define __$allowed_on_return /* empty */
+#define __$allowed_on_parameter /* empty */
+#define __$allowed_on_function /* empty */
+#define __$allowed_on_struct /* empty */
+#define __$allowed_on_field /* empty */
+#define __$allowed_on_parameter_or_return /* empty */
+#define __$allowed_on_global_or_field /* empty */
+#elif __SPECSTRINGS_STRICT_LEVEL == 3
+#define __$allowed_on_typedecl /* empty */
+/* Define dummy source attributes. Still needs more testing */
+#define __$allowed_on_return [returnvalue: OnReturnOnly]
+#define __$allowed_on_parameter [OnParameterOnly]
+#define __$allowed_on_function [method: OnFunctionOnly]
+#define __$allowed_on_struct [OnStructOnly]
+#define __$allowed_on_field [OnFieldOnly]
+#define __$allowed_on_parameter_or_return [OnParameterOrReturnOnly] 
+#define __$allowed_on_global_or_field /* empty */
+#pragma push_macro( "DECL_SA" )
+#pragma push_macro( "SA" )
+#ifdef __cplusplus
+#define SA(x) x
+#define DECL_SA(name,loc) \
+  [repeatable] \
+  [source_annotation_attribute( loc )] \
+  struct name##Attribute { name##Attribute(); const char* ignored; }; 
+#else
+#define SA(x) SA_##x
+#define DECL_SA(name,loc) \
+  [source_annotation_attribute( loc )] \
+  struct name { const char* ignored; };\
+  typedef struct name name;
+#endif  /* #endif  __cplusplus */
+DECL_SA(OnParameterOnly,SA(Parameter));
+DECL_SA(OnReturnOnly,SA(ReturnValue));
+DECL_SA(OnFunctionOnly,SA(Method));
+DECL_SA(OnStructOnly,SA(Struct));
+DECL_SA(OnFieldOnly,SA(Field));
+DECL_SA(OnParameterOrReturnOnly,SA(Parameter) | SA(ReturnValue));
+#pragma pop_macro( "SA" )
+#pragma pop_macro( "DECL_SA" )
+#endif 
+#endif 
+
+