//==================================================================================================
// S t a n d a r d                                                                        Interface
// K e y w o r d
//                                                                                By Bruno Bachelet
//==================================================================================================
// Copyright (c) 1999-2016
// Bruno Bachelet - bruno@nawouak.net - http://www.nawouak.net
//
// This file is part of the B++ Library. This library is free software; you can redistribute it
// and/or modify it under the terms of the GNU Library General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
// the GNU Library General Public License for more details (http://www.gnu.org).

/*DESCRIPTION*/
/* This module provides new keywords for the language. */

// File Name //-------------------------------------------------------------------------------------
#line __LINE__ "standard/keyword.hpp"

// Guardian //--------------------------------------------------------------------------------------
#ifndef guStandardKeyword
#define guStandardKeyword

// Headers //---------------------------------------------------------------------------------------
#include <cstdarg> /*INCLUDE*/
#include <cstddef> /*INCLUDE*/
#include <bpp/dependency.hpp> /*INCLUDE*/

namespace bpp {

// Importation/Exportation //-----------------------------------------------------------------------
#ifdef STANDARD_DLL
 #define dll_export DLL_EXPORT
#else
 #define dll_export DLL_IMPORT
#endif

// Namespaces //------------------------------------------------------------------------------------
#define public_area  standardKeyword
#define private_area standardKeyword_private

namespace public_area  {}
namespace private_area {}

// Initialization //--------------------------------------------------------------------------------

// Macrocommands //---------------------------------------------------------------------------------
#define low_flag(prFlag) {                                                                       \
 std::ofstream lcLowOut;                                                                         \
 lcLowOut.open("bpp_library.low",ios::app);                                                      \
 lcLowOut << "Flag " << #prFlag << " [" << __FILE__ << "][" << (__LINE__+1) << "]" << std::endl; \
 lcLowOut.close(); }                                                                             \

#define low_spy(prVariable) {                                 \
 std::ofstream lcLowOut;                                      \
 lcLowOut.open("bpp_library.low",ios::app);                   \
 lcLowOut << #prVariable << " = " << prVariable << std::endl; \
 lcLowOut.close(); }                                          \

#ifdef NEED_LOGICAL_KEYWORDS
 /*MACROCOMMAND*/ /* Replaces <CODE>&&</CODE>. */
 #define and &&

 /*MACROCOMMAND*/ /* Replaces <CODE>!</CODE>. */
 #define not !

 /*MACROCOMMAND*/ /* Replaces <CODE>||</CODE>. */
 #define or ||
#endif

/*MACROCOMMAND*/
/* Used to write a commentary. <CODE>prLine</CODE> is not integrated into the source code. */
#define commentary(prLine)

/*MACROCOMMAND*/ /* Nothing. Used to indicate more clearly that a method is a constructor. */
#define constructor

/*MACROCOMMAND*/
/* Replaces <CODE>~</CODE>. Used to indicate more clearly that a method is a destructor. */
#define destructor ~

/*MACROCOMMAND*/ /* Is the null character. */
#define end_string '\0'

/*MACROCOMMAND*/ /* Replaces <CODE>typedef enum</CODE>. */
#define enumeration typedef enum

/*MACROCOMMAND*/ /* Used to declare externally (in a header file) an error. */
#define extern_error extern dll_export clError

/*MACROCOMMAND*/ /* Used to indicate that a function is exported. */
#define function dll_export

/*MACROCOMMAND*/ /* Replaces the <CODE>NULL</CODE> macrocommand. */
#define nil NULL

/*MACROCOMMAND*/
/* Used to indicate that a public method or attribute is exported (in the declaration). */
#define public_property public: dll_export

/*MACROCOMMAND*/
/* Used to indicate that a private method or attribute is exported (in the declaration). */
#define private_property protected: dll_export

/*MACROCOMMAND*/
/* Used to indicate that a method or an attribute is exported (in the definition). */
#define property dll_export

/*MACROCOMMAND*/ /* Used to declare internally (in the source file) an error. */
#define static_error dll_export clError

/*MACROCOMMAND*/ /* Replaces <CODE>typedef struct</CODE>. */
#define structure typedef struct

/*MACROCOMMAND*/ /* Replaces <CODE>typedef union</CODE>. */
#define type_union typedef union

/*MACROCOMMAND*/
/* Used to declare externally (in the header file) a global constant or variable that is not an
   object. <CODE>prArea</CODE> is the private or public area. <CODE>prType</CODE> is the type of
   the constant. <CODE>prConstantName</CODE> is the internal name of the constant.
   <CODE>prFunctionName</CODE> is the name of the function to access the constant externally. */
#define extern_static_constant(prArea,prType,prConstantName,prFunctionName) \
 namespace private_area { extern dll_export prType prConstantName; }        \
 prArea##_static_access(prType,prConstantName,prFunctionName)               \

/*MACROCOMMAND*/
/* Used to declare externally (in the header file) a global constant or variable that is an object.
   <CODE>prArea</CODE> is the private or public area. <CODE>prType</CODE> is the type of the
   constant. <CODE>prConstantName</CODE> is the internal name of the constant.
   <CODE>prFunctionName</CODE> is the name of the function to access the constant externally. */
#define extern_dynamic_constant(prArea,prType,prConstantName,prFunctionName) \
 namespace private_area { extern dll_export prType * prConstantName; }       \
 prArea##_dynamic_access(prType,prConstantName,prFunctionName)               \

/*MACROCOMMAND*/ /* Internal use. Never use it. */
#define private_dynamic_access(prType,prConstantName,prFunctionName) \
 class _private_dynamic_access_semicolon_eater_                      \

/*MACROCOMMAND*/ /* Internal use. Never use it. */
#define private_static_access(prType,prConstantName,prFunctionName) \
 class _private_static_access_semicolon_eater_                      \

/*MACROCOMMAND*/ /* Internal use. Never use it. */
#define public_dynamic_access(prType,prConstantName,prFunctionName) \
 namespace public_area {                                            \
  inline const private_area::prType & prFunctionName(void)          \
  { return (*(private_area::prConstantName)); }                     \
 }                                                                  \
 class _public_dynamic_access_semicolon_eater_                      \

/*MACROCOMMAND*/ /* Internal use. Never use it. */
#define public_static_access(prType,prConstantName,prFunctionName) \
 namespace public_area {                                           \
  inline const private_area::prType & prFunctionName(void)         \
  { return (private_area::prConstantName); }                       \
 }                                                                 \
 class _public_static_access_semicolon_eater_                      \

/*MACROCOMMAND*/
/* Used to declare a read-only instance attribute in a class. <CODE>prType</CODE> is the type of
   the attribute. <CODE>prAttributeName</CODE> is the internal name of the attribute.
   <CODE>prFunctionName</CODE> is the name of the method to access the attribute externally. */
#define read_only_attribute(prType,prAttributeName,prFunctionName) \
 protected: prType prAttributeName;                                \
 public_property const prType & prFunctionName(void) const         \
 { return ((const prType &)prAttributeName); }                     \

/*MACROCOMMAND*/
/* Used to declare a read-and-write instance attribute in a class. <CODE>prType</CODE> is the type
   of the attribute. <CODE>prAttributeName</CODE> is the internal name of the attribute.
   <CODE>prFunctionName</CODE> is the name of the method to access the attribute externally. */
#define read_write_attribute(prType,prAttributeName,prFunctionName)          \
 protected: prType prAttributeName;                                          \
 public_property const prType & prFunctionName(void) const                   \
 { return ((const prType &)prAttributeName); }                               \
 public_property prType & prFunctionName(void) { return (prAttributeName); } \

/*MACROCOMMAND*/
/* Used to declare a read-only class attribute in a class. <CODE>prType</CODE> is the type of the
   attribute. <CODE>prAttributeName</CODE> is the internal name of the attribute.
   <CODE>prFunctionName</CODE> is the name of the method to access the attribute externally. */
#define read_only_static_attribute(prType,prAttributeName,prFunctionName) \
 protected: static prType prAttributeName;                                \
 public_property static const prType & prFunctionName(void)               \
 { return ((const prType &)prAttributeName); }                            \

/*MACROCOMMAND*/
/* Used to declare a read-and-write class attribute in a class. <CODE>prType</CODE> is the type of
   the attribute. <CODE>prAttributeName</CODE> is the internal name of the attribute.
   <CODE>prFunctionName</CODE> is the name of the method to access the attribute externally. */
#define read_write_static_attribute(prType,prAttributeName,prFunctionName)          \
 protected: static prType prAttributeName;                                          \
 public_property static prType & prFunctionName(void) { return (prAttributeName); } \

/*MACROCOMMAND*/
/* Used to declare internally (in the source file) a global constant or variable that is an object.
   <CODE>prType</CODE> is the type of the constant. <CODE>prConstantName</CODE> is the internal
   name of the constant. */
#define dynamic_constant(prType,prConstantName)                       \
 namespace private_area { dll_export prType * prConstantName = nil; } \
 class _dynamic_constant_semicolon_eater_                             \

/*MACROCOMMAND*/
/* Used to declare internally (in the source file) a global constant or variable that is not an
   object. <CODE>prType</CODE> is the type of the constant. <CODE>prConstantName</CODE> is the
   internal name of the constant. */
#define static_constant(prType,prConstantName)                \
 namespace private_area { dll_export prType prConstantName; } \
 class _static_constant_semicolon_eater_                      \

/*MACROCOMMAND*/
/* Creates the argument list of the current method starting with a given argument. */
#define create_argument_list(prArgument) \
 va_list _argument_list_;                \
 va_start(_argument_list_,prArgument);   \

/*MACROCOMMAND*/ /* Gets the next argument in the argument list. */
#define get_next_argument(prType) (va_arg(_argument_list_,prType))

/*MACROCOMMAND*/ /* Deletes the argument list. */
#define delete_argument_list (va_end(_argument_list_))

/*MACROCOMMAND*/ /* Makes the provided parameter a string. */
#define stringify(prParameter) stringify_2(prParameter)
#define stringify_2(prParameter) #prParameter

#ifdef THREAD_SAFETY
 #define safe_static

 /*MACROCOMMAND*/
 /* The expression <CODE>prLine</CODE> is integrated into the source code if
    <CODE>THREAD_SAFETY</CODE> is defined. */
 #define safe_yes(prLine) prLine

 #define safe_no(prLine)

 #ifndef NEED_SAFE_STL_ALLOCATOR
  /*MACROCOMMAND*/ /* Expression to access a thread-safe STL allocator. */
  #define safe_allocator std_thread_allocator
 #else
  #define safe_allocator thread_safe_allocator
 #endif
#else
 /*MACROCOMMAND*/
 /* Used to declare a static variable in a method or a function, but if thread-safety is required
    the variable will not be static in order to make the function or method reentrant. */
 #define safe_static static

 #define safe_yes(prLine)

 /*MACROCOMMAND*/
 /* The expression <CODE>prLine</CODE> is integrated into the source code if
    <CODE>THREAD_SAFETY</CODE> is undefined. */
 #define safe_no(prLine) prLine

 #define safe_allocator std_allocator
#endif

#ifdef TESTING_MODE
 /*MACROCOMMAND*/
 /* The expression <CODE>prLine</CODE> is integrated into the source code if
    <CODE>TESTING_MODE</CODE> is defined. */
 #define testing_mode(prLine) prLine
#else
 #define testing_mode(prLine)
#endif

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 1 element. */
#define cpattern_one(prPattern) vpattern_##prPattern(Arg1)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 2 elements (separated by a comma). */
#define cpattern_two(prPattern) \
 vpattern_##prPattern(Arg1),    \
 vpattern_##prPattern(Arg2)     \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 3 elements (separated by a comma). */
#define cpattern_three(prPattern) \
 vpattern_##prPattern(Arg1),      \
 vpattern_##prPattern(Arg2),      \
 vpattern_##prPattern(Arg3)       \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 4 elements (separated by a comma). */
#define cpattern_four(prPattern) \
 vpattern_##prPattern(Arg1),     \
 vpattern_##prPattern(Arg2),     \
 vpattern_##prPattern(Arg3),     \
 vpattern_##prPattern(Arg4)      \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 5 elements (separated by a comma). */
#define cpattern_five(prPattern) \
 vpattern_##prPattern(Arg1),     \
 vpattern_##prPattern(Arg2),     \
 vpattern_##prPattern(Arg3),     \
 vpattern_##prPattern(Arg4),     \
 vpattern_##prPattern(Arg5)      \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 6 elements (separated by a comma). */
#define cpattern_six(prPattern) \
 vpattern_##prPattern(Arg1),    \
 vpattern_##prPattern(Arg2),    \
 vpattern_##prPattern(Arg3),    \
 vpattern_##prPattern(Arg4),    \
 vpattern_##prPattern(Arg5),    \
 vpattern_##prPattern(Arg6)     \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 7 elements (separated by a comma). */
#define cpattern_seven(prPattern) \
 vpattern_##prPattern(Arg1),      \
 vpattern_##prPattern(Arg2),      \
 vpattern_##prPattern(Arg3),      \
 vpattern_##prPattern(Arg4),      \
 vpattern_##prPattern(Arg5),      \
 vpattern_##prPattern(Arg6),      \
 vpattern_##prPattern(Arg7)       \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 8 elements (separated by a comma). */
#define cpattern_eight(prPattern) \
 vpattern_##prPattern(Arg1),      \
 vpattern_##prPattern(Arg2),      \
 vpattern_##prPattern(Arg3),      \
 vpattern_##prPattern(Arg4),      \
 vpattern_##prPattern(Arg5),      \
 vpattern_##prPattern(Arg6),      \
 vpattern_##prPattern(Arg7),      \
 vpattern_##prPattern(Arg8)       \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 9 elements (separated by a comma). */
#define cpattern_nine(prPattern) \
 vpattern_##prPattern(Arg1),     \
 vpattern_##prPattern(Arg2),     \
 vpattern_##prPattern(Arg3),     \
 vpattern_##prPattern(Arg4),     \
 vpattern_##prPattern(Arg5),     \
 vpattern_##prPattern(Arg6),     \
 vpattern_##prPattern(Arg7),     \
 vpattern_##prPattern(Arg8),     \
 vpattern_##prPattern(Arg9)      \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 10 elements (separated by a comma). */
#define cpattern_ten(prPattern) \
 vpattern_##prPattern(Arg1),    \
 vpattern_##prPattern(Arg2),    \
 vpattern_##prPattern(Arg3),    \
 vpattern_##prPattern(Arg4),    \
 vpattern_##prPattern(Arg5),    \
 vpattern_##prPattern(Arg6),    \
 vpattern_##prPattern(Arg7),    \
 vpattern_##prPattern(Arg8),    \
 vpattern_##prPattern(Arg9),    \
 vpattern_##prPattern(Arg10)    \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 1 element. */
#define spattern_one(prPattern) vpattern_##prPattern(Arg1)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 2 elements (separated by a semicolon). */
#define spattern_two(prPattern) \
 vpattern_##prPattern(Arg1);    \
 vpattern_##prPattern(Arg2)     \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 3 elements (separated by a semicolon). */
#define spattern_three(prPattern) \
 vpattern_##prPattern(Arg1);      \
 vpattern_##prPattern(Arg2);      \
 vpattern_##prPattern(Arg3)       \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 4 elements (separated by a semicolon). */
#define spattern_four(prPattern) \
 vpattern_##prPattern(Arg1);     \
 vpattern_##prPattern(Arg2);     \
 vpattern_##prPattern(Arg3);     \
 vpattern_##prPattern(Arg4)      \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 5 elements (separated by a semicolon). */
#define spattern_five(prPattern) \
 vpattern_##prPattern(Arg1);     \
 vpattern_##prPattern(Arg2);     \
 vpattern_##prPattern(Arg3);     \
 vpattern_##prPattern(Arg4);     \
 vpattern_##prPattern(Arg5)      \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 6 elements (separated by a semicolon). */
#define spattern_six(prPattern) \
 vpattern_##prPattern(Arg1);    \
 vpattern_##prPattern(Arg2);    \
 vpattern_##prPattern(Arg3);    \
 vpattern_##prPattern(Arg4);    \
 vpattern_##prPattern(Arg5);    \
 vpattern_##prPattern(Arg6)     \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 7 elements (separated by a semicolon). */
#define spattern_seven(prPattern) \
 vpattern_##prPattern(Arg1);      \
 vpattern_##prPattern(Arg2);      \
 vpattern_##prPattern(Arg3);      \
 vpattern_##prPattern(Arg4);      \
 vpattern_##prPattern(Arg5);      \
 vpattern_##prPattern(Arg6);      \
 vpattern_##prPattern(Arg7)       \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 8 elements (separated by a semicolon). */
#define spattern_eight(prPattern) \
 vpattern_##prPattern(Arg1);      \
 vpattern_##prPattern(Arg2);      \
 vpattern_##prPattern(Arg3);      \
 vpattern_##prPattern(Arg4);      \
 vpattern_##prPattern(Arg5);      \
 vpattern_##prPattern(Arg6);      \
 vpattern_##prPattern(Arg7);      \
 vpattern_##prPattern(Arg8)       \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 9 elements (separated by a semicolon). */
#define spattern_nine(prPattern) \
 vpattern_##prPattern(Arg1);     \
 vpattern_##prPattern(Arg2);     \
 vpattern_##prPattern(Arg3);     \
 vpattern_##prPattern(Arg4);     \
 vpattern_##prPattern(Arg5);     \
 vpattern_##prPattern(Arg6);     \
 vpattern_##prPattern(Arg7);     \
 vpattern_##prPattern(Arg8);     \
 vpattern_##prPattern(Arg9)      \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>vpattern_</CODE>)
   on 10 elements (separated by a semicolon). */
#define spattern_ten(prPattern) \
 vpattern_##prPattern(Arg1);    \
 vpattern_##prPattern(Arg2);    \
 vpattern_##prPattern(Arg3);    \
 vpattern_##prPattern(Arg4);    \
 vpattern_##prPattern(Arg5);    \
 vpattern_##prPattern(Arg6);    \
 vpattern_##prPattern(Arg7);    \
 vpattern_##prPattern(Arg8);    \
 vpattern_##prPattern(Arg9);    \
 vpattern_##prPattern(Arg10)    \

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 1 element. */
#define one(prPattern) gpattern_##prPattern(one)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 2 elements. */
#define two(prPattern) gpattern_##prPattern(two)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 3 elements. */
#define three(prPattern) gpattern_##prPattern(three)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 4 elements. */
#define four(prPattern) gpattern_##prPattern(four)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 5 elements. */
#define five(prPattern) gpattern_##prPattern(five)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 6 elements. */
#define six(prPattern) gpattern_##prPattern(six)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 7 elements. */
#define seven(prPattern) gpattern_##prPattern(seven)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 8 elements. */
#define eight(prPattern) gpattern_##prPattern(eight)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 9 elements. */
#define nine(prPattern) gpattern_##prPattern(nine)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>gpattern_</CODE>)
   for 10 elements. */
#define ten(prPattern) gpattern_##prPattern(ten)

/*MACROCOMMAND*/
/* Used for code generation. Applies a pattern (with the prefix <CODE>mpattern_</CODE>)
   for 1 to 10 elements. */
#define one_to_n(prPattern)       \
 mpattern_##prPattern(one)        \
 mpattern_##prPattern(two)        \
 mpattern_##prPattern(three)      \
 mpattern_##prPattern(four)       \
 mpattern_##prPattern(five)       \
 mpattern_##prPattern(six)        \
 mpattern_##prPattern(seven)      \
 mpattern_##prPattern(eight)      \
 mpattern_##prPattern(nine)       \
 mpattern_##prPattern(ten)        \
 class _one_to_n_semicolon_eater_ \

// Types & Classes //-------------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// Functions Interface //---------------------------------------------------------------------------
namespace public_area {
 template <class prType> prType & nextSymbol(prType &);
 template <class prType> prType & previousSymbol(prType &);
}

namespace private_area {}

// Errors //----------------------------------------------------------------------------------------
namespace public_area  {}

// Constants & Variables //-------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// X X X  Interface //------------------------------------------------------------------------------
namespace {}

// Functions Inline //------------------------------------------------------------------------------
namespace public_area {
 //---------------------------------------------------------------------------------------NextSymbol
 /*FUNCTION*/ /* Returns the next symbolic constant of an enumeration set. */
 template <class prType> inline prType & nextSymbol(prType & agVariable)
 { return (agVariable=prType(int(agVariable)+1)); }
 //-----------------------------------------------------------------------------------PreviousSymbol
 /*FUNCTION*/ /* Returns the previous symbolic constant of an enumeration set. */
 template <class prType> inline prType & previousSymbol(prType & agVariable)
 { return (agVariable=prType(int(agVariable)-1)); }
}

namespace private_area {}

// X X X  Inline //---------------------------------------------------------------------------------
namespace {}

// End //-------------------------------------------------------------------------------------------
}
#undef dll_export
#undef public_area
#undef private_area
#endif
 
//==================================================================================================
// S t a n d a r d                                                                   Implementation
// K e y w o r d
//                                                                                By Bruno Bachelet
//==================================================================================================
// Copyright (c) 1999-2016
// Bruno Bachelet - bruno@nawouak.net - http://www.nawouak.net
//
// This file is part of the B++ Library. This library is free software; you can redistribute it
// and/or modify it under the terms of the GNU Library General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your option) any later
// version.
//
// This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
// the GNU Library General Public License for more details (http://www.gnu.org).

// File Name //-------------------------------------------------------------------------------------
#line __LINE__ "standard/keyword.cpp"

// DLL Belonging //---------------------------------------------------------------------------------
#define STANDARD_DLL

// Headers //---------------------------------------------------------------------------------------
#include <bpp/standard/keyword.hpp> /*INTERFACE*/

namespace bpp {

// Namespaces //------------------------------------------------------------------------------------
#define public_area  standardKeyword
#define private_area standardKeyword_private
#define dll_export   DLL_EXPORT

namespace public_area  {}
namespace private_area {}

// Initialization //--------------------------------------------------------------------------------

// Errors //----------------------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// Constants & Variables //-------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// Static Members //--------------------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// Functions Implementation //----------------------------------------------------------------------
namespace public_area  {}
namespace private_area {}

// X X X  Implementation //-------------------------------------------------------------------------
namespace {}

// End //-------------------------------------------------------------------------------------------
}