ROOT logo
// @(#)root/reflex:$Id$
// Author: Stefan Roiser 2004

// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.
//
// Permission to use, copy, modify, and distribute this software for any
// purpose is hereby granted without fee, provided that this copyright and
// permissions notice appear in all copies and derivatives.
//
// This software is provided "as is" without express or implied warranty.

#ifndef Reflex_Kernel
#define Reflex_Kernel

// These macros will allow selection on exported symbols
// taken from http://www.nedprod.com/programs/gccvisibility.html
// Shared library support

#if __GNUC__ >= 4 && !defined(__CINT__)
# define GCC_HASCLASSVISIBILITY
#endif

#if !defined(REFLEX_DLL_VETO) && !defined(REFLEX_DLL) && !defined(__CINT__)
// we build Reflex as DLL by default, #define REFLEX_DLL_VETO to hide visibility / dllim/export code
# define REFLEX_DLL
#endif

#ifdef _WIN32
# define RFLX_IMPORT __declspec(dllimport)
# define RFLX_EXPORT __declspec(dllexport)
# define RFLX_DLLLOCAL
# define RFLX_DLLPUBLIC
#else
# ifdef GCC_HASCLASSVISIBILITY
#  define RFLX_EXPORT __attribute__((visibility("default")))
#  define RFLX_DLLLOCAL __attribute__((visibility("hidden")))
#  define RFLX_DLLPUBLIC __attribute__((visibility("default")))
# else
#  define RFLX_EXPORT
#  define RFLX_DLLLOCAL
#  define RFLX_DLLPUBLIC
# endif
# define RFLX_IMPORT
#endif

// Define RFLX_API for DLL builds
#ifdef REFLEX_DLL
# ifdef REFLEX_BUILD
#  define RFLX_API RFLX_EXPORT
# else
#  define RFLX_API RFLX_IMPORT
# endif  // REFLEX_BUILD
#else
# define RFLX_API
#endif // REFLEX_DLL

// Throwable classes must always be visible on GCC in all binaries
#ifdef _WIN32
# define RFLX_EXCEPTIONAPI(api) api
#elif defined(GCC_HASCLASSVISIBILITY)
# define RFLX_EXCEPTIONAPI(api) RFLX_EXPORT
#else
# define RFLX_EXCEPTIONAPI(api)
#endif
// end macros for symbol selection


// include config.h generated by autoconf
#if defined(HAVE_CONFIG)
# include "config.h"
#endif

#if defined(_AIX)
# define ANSICPP
# define NEED_STRCASECMP
#endif

#if defined(__alpha) && !defined(__linux)
# ifndef __USE_STD_IOSTREAM
#  define __USE_STD_IOSTREAM
# endif
#endif

// windows.h and oracle define CONST
#ifdef CONST
# undef CONST
#endif

#ifdef _WIN32
// Some pragmas to avoid warnings in MSVisualC
// Disable warning C4786: identifier was truncated to '255' characters in the debug information
# pragma warning ( disable : 4786 )
// Disable warning C4291: no matching operator delete found; memory will not be freed if
// initialization throws an exception
# pragma warning ( disable : 4291 )
// Disable warning C4250: inheritance via dominance
# pragma warning ( disable : 4250 )
#endif

// some compilers define the macros below in limits
#include <limits>

#ifndef LONGLONG_MAX
# define LONGLONG_MAX 0x7FFFFFFFFFFFFFFFLL
#endif
#ifndef LONGLONG_MIN
# define LONGLONG_MIN 0x8000000000000000LL
#endif
#ifndef ULONGLONG_MAX
# define ULONGLONG_MAX 0xFFFFFFFFFFFFFFFFLL
#endif
#ifndef ULONGLONG_MIN
# define ULONGLONG_MIN 0x0000000000000000LL
#endif


// Include files
#include <stdlib.h>
#include <string.h>
#include <string>
#include <cstring>
#include <vector>
#include <utility>
#include <exception>

namespace Reflex {
#if 0
// The definition of Reflex::longlong is now removed.
// It is not needed by the Reflex API, and it interfers
// with user code defining its own longlong, because
// the dictionaries pull it in via "using namespace Reflex".

// Large integer definition depends of the platform
# if defined(_WIN32) && !defined(__CINT__)
typedef __int64 longlong;
typedef unsigned __int64 ulonglong;
# else
typedef long long int longlong;    /* */
typedef unsigned long long int /**/ ulonglong;
# endif
#endif

// forward declarations
class Any;
class Type;
class Base;
class Scope;
class Object;
class Member;
class PropertyList;
class TypeTemplate;
class MemberTemplate;

typedef std::vector<std::string> StdString_Cont_Type_t;
typedef StdString_Cont_Type_t::const_iterator StdString_Iterator;
typedef StdString_Cont_Type_t::const_reverse_iterator Reverse_StdString_Iterator;

typedef std::vector<Type> Type_Cont_Type_t;
typedef Type_Cont_Type_t::const_iterator Type_Iterator;
typedef Type_Cont_Type_t::const_reverse_iterator Reverse_Type_Iterator;

typedef std::vector<Base> Base_Cont_Type_t;
typedef Base_Cont_Type_t::const_iterator Base_Iterator;
typedef Base_Cont_Type_t::const_reverse_iterator Reverse_Base_Iterator;

typedef std::vector<Scope> Scope_Cont_Type_t;
typedef Scope_Cont_Type_t::const_iterator Scope_Iterator;
typedef Scope_Cont_Type_t::const_reverse_iterator Reverse_Scope_Iterator;

typedef std::vector<Object> Object_Cont_Type_t;
typedef Object_Cont_Type_t::const_iterator Object_Iterator;
typedef Object_Cont_Type_t::const_reverse_iterator Reverse_Object_Iterator;

typedef std::vector<Member> Member_Cont_Type_t;
typedef Member_Cont_Type_t::const_iterator Member_Iterator;
typedef Member_Cont_Type_t::const_reverse_iterator Reverse_Member_Iterator;

typedef std::vector<TypeTemplate> TypeTemplate_Cont_Type_t;
typedef TypeTemplate_Cont_Type_t::const_iterator TypeTemplate_Iterator;
typedef TypeTemplate_Cont_Type_t::const_reverse_iterator Reverse_TypeTemplate_Iterator;

typedef std::vector<MemberTemplate> MemberTemplate_Cont_Type_t;
typedef MemberTemplate_Cont_Type_t::const_iterator MemberTemplate_Iterator;
typedef MemberTemplate_Cont_Type_t::const_reverse_iterator Reverse_MemberTemplate_Iterator;


namespace Dummy {
RFLX_API const StdString_Cont_Type_t& StdStringCont();
RFLX_API const Type_Cont_Type_t& TypeCont();
RFLX_API const Base_Cont_Type_t& BaseCont();
RFLX_API const Scope_Cont_Type_t& ScopeCont();
RFLX_API const Object_Cont_Type_t& ObjectCont();
RFLX_API const Member_Cont_Type_t& MemberCont();
RFLX_API const TypeTemplate_Cont_Type_t& TypeTemplateCont();
RFLX_API const MemberTemplate_Cont_Type_t& MemberTemplateCont();
RFLX_API Any& Any();
RFLX_API const Object& Object();
RFLX_API const Type& Type();
RFLX_API const TypeTemplate& TypeTemplate();
RFLX_API const Base& Base();
RFLX_API const PropertyList& PropertyList();
RFLX_API const Member& Member();
RFLX_API const MemberTemplate& MemberTemplate();
RFLX_API const Scope& Scope();
template <class T> inline const T&
Get() {
   static T t;
   return t;
}


}


/** The Reflex instance ensures the setup of the databases
    and provides access to some general information about the Reflex package */
class RFLX_API Instance {
public:
   /** default constructor */
   Instance();

   /** destructor */
   ~Instance();

   enum EState {
      kUninitialized, // before instance construction
      kInitializing, // the instance is being constructed
      kActive, // the instance is running
      kTearingDown, // the instance is being destructed
      kHasShutDown, // the instance has been destructed
      kNumStates
   };

   /** return true if Reflex has shutdown (end of process) */
   static bool HasShutdown();

   /** return Reflex instance state */
   static EState State();

   void Shutdown();

private:
   Instance(Instance * createSingleton);
   static Instance& CreateReflexInstance();

   static Instance* fgSingleton; // class singleton
   static EState fgState; // singleton's state
};    // struct Reflex

/** the Name of the package - used for messages */
RFLX_API const std::string& Argv0();     // returns "Reflex";

// these defines are used for the modifiers they are used in the following
// classes
// BA = BASE
// CL = CLASS
// FU = FUNCTION
// DM = DATAMEMBER
// FM = FUNCTIONMEMBER
// TY = TYPE
// ME = MEMBER
//                                BA  CL  DM  FM  TY  ME
enum ENTITY_DESCRIPTION {
   PUBLIC = (1 << 0),            //  X       X   X       X
   PROTECTED = (1 << 1),         //  X       X   X       X
   PRIVATE = (1 << 2),           //  X       X   X       X
   REGISTER = (1 << 3),          //          X   X       X
   STATIC = (1 << 4),            //          X   X       X
   CONSTRUCTOR = (1 << 5),       //              X       X
   DESTRUCTOR = (1 << 6),        //              X       X
   EXPLICIT = (1 << 7),          //              X       X
   EXTERN = (1 << 8),            //          X   X       X
   COPYCONSTRUCTOR = (1 << 9),   //              X       X
   OPERATOR = (1 << 10),         //              X       X
   INLINE = (1 << 11),           //              X       X
   CONVERTER = (1 << 12),        //              X       X
   AUTO = (1 << 13),             //          X           X
   MUTABLE = (1 << 14),          //          X           X
   CONST = (1 << 15),            //          X       X   X
   VOLATILE = (1 << 16),         //          X       X   X
   REFERENCE = (1 << 17),        //          X           X
   ABSTRACT = (1 << 18),         //      X       X   X
   VIRTUAL = (1 << 19),          //  X   X           X
   TRANSIENT = (1 << 20),        //          X           X
   ARTIFICIAL = (1 << 21),       //  X   X   X   X   X   X
   // the bits 31 - 28 are reserved for template default arguments
   TEMPLATEDEFAULTS1 = (0 << 31) & (0 << 30) & (0 << 29) & (1 << 28),
   TEMPLATEDEFAULTS2 = (0 << 31) & (0 << 30) & (1 << 29) & (0 << 28),
   TEMPLATEDEFAULTS3 = (0 << 31) & (0 << 30) & (1 << 29) & (1 << 28),
   TEMPLATEDEFAULTS4 = (0 << 31) & (1 << 30) & (0 << 29) & (0 << 28),
   TEMPLATEDEFAULTS5 = (0 << 31) & (1 << 30) & (0 << 29) & (1 << 28),
   TEMPLATEDEFAULTS6 = (0 << 31) & (1 << 30) & (1 << 29) & (0 << 28),
   TEMPLATEDEFAULTS7 = (0 << 31) & (1 << 30) & (1 << 29) & (1 << 28),
   TEMPLATEDEFAULTS8 = (1 << 31) & (0 << 30) & (0 << 29) & (0 << 28),
   TEMPLATEDEFAULTS9 = (1 << 31) & (0 << 30) & (0 << 29) & (1 << 28),
   TEMPLATEDEFAULTS10 = (1 << 31) & (0 << 30) & (1 << 29) & (0 << 28),
   TEMPLATEDEFAULTS11 = (1 << 31) & (0 << 30) & (1 << 29) & (1 << 28),
   TEMPLATEDEFAULTS12 = (1 << 31) & (1 << 30) & (0 << 29) & (0 << 28),
   TEMPLATEDEFAULTS13 = (1 << 31) & (1 << 30) & (0 << 29) & (1 << 28),
   TEMPLATEDEFAULTS14 = (1 << 31) & (1 << 30) & (1 << 29) & (0 << 28),
   TEMPLATEDEFAULTS15 = (1 << 31) & (1 << 30) & (1 << 29) & (1 << 28)
};


/** enum for printing names */
enum ENTITY_HANDLING {
   FINAL = (1 << 0),
   QUALIFIED = (1 << 1),
   SCOPED = (1 << 2),
   F = (1 << 4),
   Q = (1 << 5),
   S = (1 << 6)
};


/** enum containing all possible types and scopes */
enum TYPE {
   CLASS = 0,
   STRUCT,
   ENUM,
   FUNCTION,
   ARRAY,
   FUNDAMENTAL,
   POINTER,
   POINTERTOMEMBER,
   TYPEDEF,
   UNION,
   TYPETEMPLATEINSTANCE,
   MEMBERTEMPLATEINSTANCE,
   NAMESPACE,
   DATAMEMBER,
   FUNCTIONMEMBER,
   UNRESOLVED
};

/** enum containing all possible 'representation' types */
enum REPRESTYPE {
   REPRES_POINTER = 'a' - 'A',                 // To be added to the other value to refer to a pointer to
   REPRES_CHAR = 'c',
   REPRES_SIGNED_CHAR = 'c',
   REPRES_SHORT_INT = 's',
   REPRES_INT = 'i',
   REPRES_LONG_INT = 'l',
   REPRES_UNSIGNED_CHAR = 'b',
   REPRES_UNSIGNED_SHORT_INT = 'r',
   REPRES_UNSIGNED_INT = 'h',
   REPRES_UNSIGNED_LONG_INT = 'k',
   REPRES_BOOL = 'g',
   REPRES_FLOAT = 'f',
   REPRES_DOUBLE = 'd',
   REPRES_LONG_DOUBLE = 'q',
   REPRES_VOID = 'y',
   REPRES_LONGLONG = 'n',
   REPRES_ULONGLONG = 'm',
   REPRES_STRUCT = 'u',
   REPRES_CLASS = 'u',
   REPRES_ENUM = 'i',                   // Intentionally equal to REPRES_INT
   REPRES_NOTYPE = '\0'
                   // '1' is also a value used (for legacy implementation of function pointer)
                   // 'E' is also a value used (for legacy implementation of FILE*)
                   // 'a', 'j', 'T', 'o', 'O', 'p', 'P', 'z', 'Z', '\011', '\001', 'w' are also a value used (for support of various interpreter types)
};

enum EMEMBERQUERY {
   INHERITEDMEMBERS_DEFAULT,    // NO by default, set to ALSO by UpdateMembers()
   INHERITEDMEMBERS_NO,
   INHERITEDMEMBERS_ALSO
};

enum EDELAYEDLOADSETTING {
   DELAYEDLOAD_OFF,
   DELAYEDLOAD_ON
};

// Note TYPE and REPRESTYPE are 'small' enums and could be stored as 'char' to save space

/** the max unsigned int */
size_t NPos();


/**
 * typedef for function member type (necessary for return value of
 * getter function)
 */
typedef void (*StubFunction)(void*, void*, const std::vector<void*>&, void*);

/** typedef for function for Offset calculation */
typedef size_t (*OffsetFunction)(void*);

/** dummy types for type_info purposes */
class RFLX_API NullType {};
class RFLX_API UnknownType {};
/** place holders for protected types */
class RFLX_API ProtectedClass {};
class RFLX_API ProtectedEnum {};
class RFLX_API ProtectedStruct {};
class RFLX_API ProtectedUnion {};
/** place holders for private types */
class RFLX_API PrivateClass {};
class RFLX_API PrivateEnum {};
class RFLX_API PrivateStruct {};
class RFLX_API PrivateUnion {};
/** place holders for unnamed types (also typeinfo purposes) */
class RFLX_API UnnamedClass {};
class RFLX_API UnnamedEnum {};
class RFLX_API UnnamedNamespace {};
class RFLX_API UnnamedStruct {};
class RFLX_API UnnamedUnion {};

/** exception classes */
class RFLX_EXCEPTIONAPI(RFLX_API) RuntimeError: public std::exception {
public:
   RuntimeError(const std::string & msg): fMsg(Reflex::Argv0() + ": " + msg) {}
   ~RuntimeError() throw() {}
   virtual const char*
   what() const throw() { return fMsg.c_str(); }

   std::string fMsg;
};

} // namespace Reflex

namespace ROOT {
namespace Reflex {
using namespace ::Reflex;
}
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::NPos() {
//-------------------------------------------------------------------------------
   return (size_t) -1;
}


#endif // Reflex_Kernel
 Kernel.h:1
 Kernel.h:2
 Kernel.h:3
 Kernel.h:4
 Kernel.h:5
 Kernel.h:6
 Kernel.h:7
 Kernel.h:8
 Kernel.h:9
 Kernel.h:10
 Kernel.h:11
 Kernel.h:12
 Kernel.h:13
 Kernel.h:14
 Kernel.h:15
 Kernel.h:16
 Kernel.h:17
 Kernel.h:18
 Kernel.h:19
 Kernel.h:20
 Kernel.h:21
 Kernel.h:22
 Kernel.h:23
 Kernel.h:24
 Kernel.h:25
 Kernel.h:26
 Kernel.h:27
 Kernel.h:28
 Kernel.h:29
 Kernel.h:30
 Kernel.h:31
 Kernel.h:32
 Kernel.h:33
 Kernel.h:34
 Kernel.h:35
 Kernel.h:36
 Kernel.h:37
 Kernel.h:38
 Kernel.h:39
 Kernel.h:40
 Kernel.h:41
 Kernel.h:42
 Kernel.h:43
 Kernel.h:44
 Kernel.h:45
 Kernel.h:46
 Kernel.h:47
 Kernel.h:48
 Kernel.h:49
 Kernel.h:50
 Kernel.h:51
 Kernel.h:52
 Kernel.h:53
 Kernel.h:54
 Kernel.h:55
 Kernel.h:56
 Kernel.h:57
 Kernel.h:58
 Kernel.h:59
 Kernel.h:60
 Kernel.h:61
 Kernel.h:62
 Kernel.h:63
 Kernel.h:64
 Kernel.h:65
 Kernel.h:66
 Kernel.h:67
 Kernel.h:68
 Kernel.h:69
 Kernel.h:70
 Kernel.h:71
 Kernel.h:72
 Kernel.h:73
 Kernel.h:74
 Kernel.h:75
 Kernel.h:76
 Kernel.h:77
 Kernel.h:78
 Kernel.h:79
 Kernel.h:80
 Kernel.h:81
 Kernel.h:82
 Kernel.h:83
 Kernel.h:84
 Kernel.h:85
 Kernel.h:86
 Kernel.h:87
 Kernel.h:88
 Kernel.h:89
 Kernel.h:90
 Kernel.h:91
 Kernel.h:92
 Kernel.h:93
 Kernel.h:94
 Kernel.h:95
 Kernel.h:96
 Kernel.h:97
 Kernel.h:98
 Kernel.h:99
 Kernel.h:100
 Kernel.h:101
 Kernel.h:102
 Kernel.h:103
 Kernel.h:104
 Kernel.h:105
 Kernel.h:106
 Kernel.h:107
 Kernel.h:108
 Kernel.h:109
 Kernel.h:110
 Kernel.h:111
 Kernel.h:112
 Kernel.h:113
 Kernel.h:114
 Kernel.h:115
 Kernel.h:116
 Kernel.h:117
 Kernel.h:118
 Kernel.h:119
 Kernel.h:120
 Kernel.h:121
 Kernel.h:122
 Kernel.h:123
 Kernel.h:124
 Kernel.h:125
 Kernel.h:126
 Kernel.h:127
 Kernel.h:128
 Kernel.h:129
 Kernel.h:130
 Kernel.h:131
 Kernel.h:132
 Kernel.h:133
 Kernel.h:134
 Kernel.h:135
 Kernel.h:136
 Kernel.h:137
 Kernel.h:138
 Kernel.h:139
 Kernel.h:140
 Kernel.h:141
 Kernel.h:142
 Kernel.h:143
 Kernel.h:144
 Kernel.h:145
 Kernel.h:146
 Kernel.h:147
 Kernel.h:148
 Kernel.h:149
 Kernel.h:150
 Kernel.h:151
 Kernel.h:152
 Kernel.h:153
 Kernel.h:154
 Kernel.h:155
 Kernel.h:156
 Kernel.h:157
 Kernel.h:158
 Kernel.h:159
 Kernel.h:160
 Kernel.h:161
 Kernel.h:162
 Kernel.h:163
 Kernel.h:164
 Kernel.h:165
 Kernel.h:166
 Kernel.h:167
 Kernel.h:168
 Kernel.h:169
 Kernel.h:170
 Kernel.h:171
 Kernel.h:172
 Kernel.h:173
 Kernel.h:174
 Kernel.h:175
 Kernel.h:176
 Kernel.h:177
 Kernel.h:178
 Kernel.h:179
 Kernel.h:180
 Kernel.h:181
 Kernel.h:182
 Kernel.h:183
 Kernel.h:184
 Kernel.h:185
 Kernel.h:186
 Kernel.h:187
 Kernel.h:188
 Kernel.h:189
 Kernel.h:190
 Kernel.h:191
 Kernel.h:192
 Kernel.h:193
 Kernel.h:194
 Kernel.h:195
 Kernel.h:196
 Kernel.h:197
 Kernel.h:198
 Kernel.h:199
 Kernel.h:200
 Kernel.h:201
 Kernel.h:202
 Kernel.h:203
 Kernel.h:204
 Kernel.h:205
 Kernel.h:206
 Kernel.h:207
 Kernel.h:208
 Kernel.h:209
 Kernel.h:210
 Kernel.h:211
 Kernel.h:212
 Kernel.h:213
 Kernel.h:214
 Kernel.h:215
 Kernel.h:216
 Kernel.h:217
 Kernel.h:218
 Kernel.h:219
 Kernel.h:220
 Kernel.h:221
 Kernel.h:222
 Kernel.h:223
 Kernel.h:224
 Kernel.h:225
 Kernel.h:226
 Kernel.h:227
 Kernel.h:228
 Kernel.h:229
 Kernel.h:230
 Kernel.h:231
 Kernel.h:232
 Kernel.h:233
 Kernel.h:234
 Kernel.h:235
 Kernel.h:236
 Kernel.h:237
 Kernel.h:238
 Kernel.h:239
 Kernel.h:240
 Kernel.h:241
 Kernel.h:242
 Kernel.h:243
 Kernel.h:244
 Kernel.h:245
 Kernel.h:246
 Kernel.h:247
 Kernel.h:248
 Kernel.h:249
 Kernel.h:250
 Kernel.h:251
 Kernel.h:252
 Kernel.h:253
 Kernel.h:254
 Kernel.h:255
 Kernel.h:256
 Kernel.h:257
 Kernel.h:258
 Kernel.h:259
 Kernel.h:260
 Kernel.h:261
 Kernel.h:262
 Kernel.h:263
 Kernel.h:264
 Kernel.h:265
 Kernel.h:266
 Kernel.h:267
 Kernel.h:268
 Kernel.h:269
 Kernel.h:270
 Kernel.h:271
 Kernel.h:272
 Kernel.h:273
 Kernel.h:274
 Kernel.h:275
 Kernel.h:276
 Kernel.h:277
 Kernel.h:278
 Kernel.h:279
 Kernel.h:280
 Kernel.h:281
 Kernel.h:282
 Kernel.h:283
 Kernel.h:284
 Kernel.h:285
 Kernel.h:286
 Kernel.h:287
 Kernel.h:288
 Kernel.h:289
 Kernel.h:290
 Kernel.h:291
 Kernel.h:292
 Kernel.h:293
 Kernel.h:294
 Kernel.h:295
 Kernel.h:296
 Kernel.h:297
 Kernel.h:298
 Kernel.h:299
 Kernel.h:300
 Kernel.h:301
 Kernel.h:302
 Kernel.h:303
 Kernel.h:304
 Kernel.h:305
 Kernel.h:306
 Kernel.h:307
 Kernel.h:308
 Kernel.h:309
 Kernel.h:310
 Kernel.h:311
 Kernel.h:312
 Kernel.h:313
 Kernel.h:314
 Kernel.h:315
 Kernel.h:316
 Kernel.h:317
 Kernel.h:318
 Kernel.h:319
 Kernel.h:320
 Kernel.h:321
 Kernel.h:322
 Kernel.h:323
 Kernel.h:324
 Kernel.h:325
 Kernel.h:326
 Kernel.h:327
 Kernel.h:328
 Kernel.h:329
 Kernel.h:330
 Kernel.h:331
 Kernel.h:332
 Kernel.h:333
 Kernel.h:334
 Kernel.h:335
 Kernel.h:336
 Kernel.h:337
 Kernel.h:338
 Kernel.h:339
 Kernel.h:340
 Kernel.h:341
 Kernel.h:342
 Kernel.h:343
 Kernel.h:344
 Kernel.h:345
 Kernel.h:346
 Kernel.h:347
 Kernel.h:348
 Kernel.h:349
 Kernel.h:350
 Kernel.h:351
 Kernel.h:352
 Kernel.h:353
 Kernel.h:354
 Kernel.h:355
 Kernel.h:356
 Kernel.h:357
 Kernel.h:358
 Kernel.h:359
 Kernel.h:360
 Kernel.h:361
 Kernel.h:362
 Kernel.h:363
 Kernel.h:364
 Kernel.h:365
 Kernel.h:366
 Kernel.h:367
 Kernel.h:368
 Kernel.h:369
 Kernel.h:370
 Kernel.h:371
 Kernel.h:372
 Kernel.h:373
 Kernel.h:374
 Kernel.h:375
 Kernel.h:376
 Kernel.h:377
 Kernel.h:378
 Kernel.h:379
 Kernel.h:380
 Kernel.h:381
 Kernel.h:382
 Kernel.h:383
 Kernel.h:384
 Kernel.h:385
 Kernel.h:386
 Kernel.h:387
 Kernel.h:388
 Kernel.h:389
 Kernel.h:390
 Kernel.h:391
 Kernel.h:392
 Kernel.h:393
 Kernel.h:394
 Kernel.h:395
 Kernel.h:396
 Kernel.h:397
 Kernel.h:398
 Kernel.h:399
 Kernel.h:400
 Kernel.h:401
 Kernel.h:402
 Kernel.h:403
 Kernel.h:404
 Kernel.h:405
 Kernel.h:406
 Kernel.h:407
 Kernel.h:408
 Kernel.h:409
 Kernel.h:410
 Kernel.h:411
 Kernel.h:412
 Kernel.h:413
 Kernel.h:414
 Kernel.h:415
 Kernel.h:416
 Kernel.h:417
 Kernel.h:418
 Kernel.h:419
 Kernel.h:420
 Kernel.h:421
 Kernel.h:422
 Kernel.h:423
 Kernel.h:424
 Kernel.h:425
 Kernel.h:426
 Kernel.h:427
 Kernel.h:428
 Kernel.h:429
 Kernel.h:430
 Kernel.h:431
 Kernel.h:432
 Kernel.h:433
 Kernel.h:434
 Kernel.h:435
 Kernel.h:436
 Kernel.h:437
 Kernel.h:438