home *** CD-ROM | disk | FTP | other *** search
/ PC World 2002 May / PCWorld_2002-05_cd.bin / Software / TemaCD / activetcltk / ActiveTcl8.3.4.1-8.win32-ix86.exe / ActiveTcl8.3.4.1-win32-ix86 / include / itclInt.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-10-22  |  10.9 KB  |  272 lines
  1. /*
  2.  * ------------------------------------------------------------------------
  3.  *      PACKAGE:  [incr Tcl]
  4.  *  DESCRIPTION:  Object-Oriented Extensions to Tcl
  5.  *
  6.  *  [incr Tcl] provides object-oriented extensions to Tcl, much as
  7.  *  C++ provides object-oriented extensions to C.  It provides a means
  8.  *  of encapsulating related procedures together with their shared data
  9.  *  in a local namespace that is hidden from the outside world.  It
  10.  *  promotes code re-use through inheritance.  More than anything else,
  11.  *  it encourages better organization of Tcl applications through the
  12.  *  object-oriented paradigm, leading to code that is easier to
  13.  *  understand and maintain.
  14.  *  
  15.  *  ADDING [incr Tcl] TO A Tcl-BASED APPLICATION:
  16.  *
  17.  *    To add [incr Tcl] facilities to a Tcl application, modify the
  18.  *    Tcl_AppInit() routine as follows:
  19.  *
  20.  *    1) Include this header file near the top of the file containing
  21.  *       Tcl_AppInit():
  22.  *
  23.  *         #include "itcl.h"
  24.  *
  25.  *    2) Within the body of Tcl_AppInit(), add the following lines:
  26.  *
  27.  *         if (Itcl_Init(interp) == TCL_ERROR) {
  28.  *             return TCL_ERROR;
  29.  *         }
  30.  * 
  31.  *    3) Link your application with libitcl.a
  32.  *
  33.  *    NOTE:  An example file "tclAppInit.c" containing the changes shown
  34.  *           above is included in this distribution.
  35.  *  
  36.  * ========================================================================
  37.  *  AUTHOR:  Michael J. McLennan
  38.  *           Bell Labs Innovations for Lucent Technologies
  39.  *           mmclennan@lucent.com
  40.  *           http://www.tcltk.com/itcl
  41.  *
  42.  *     RCS:  $Id: itclInt.h,v 1.8 2001/09/16 15:02:41 davygrvy Exp $
  43.  * ========================================================================
  44.  *           Copyright (c) 1993-1998  Lucent Technologies, Inc.
  45.  * ------------------------------------------------------------------------
  46.  * See the file "license.terms" for information on usage and redistribution
  47.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  48.  */
  49. #ifndef ITCLINT_H
  50. #define ITCLINT_H
  51.  
  52. #include "tclInt.h"
  53. #include "itcl.h"
  54.  
  55. #ifdef BUILD_itcl
  56. # undef TCL_STORAGE_CLASS
  57. # define TCL_STORAGE_CLASS DLLEXPORT
  58. #endif
  59.  
  60.  
  61. /*
  62.  *  Common info for managing all known objects.
  63.  *  Each interpreter has one of these data structures stored as
  64.  *  clientData in the "itcl" namespace.  It is also accessible
  65.  *  as associated data via the key ITCL_INTERP_DATA.
  66.  */
  67. struct ItclObject;
  68. typedef struct ItclObjectInfo {
  69.     Tcl_Interp *interp;             /* interpreter that manages this info */
  70.     Tcl_HashTable objects;          /* list of all known objects */
  71.  
  72.     Itcl_Stack transparentFrames;   /* stack of call frames that should be
  73.                                      * treated transparently.  When
  74.                                      * Itcl_EvalMemberCode is invoked in
  75.                                      * one of these contexts, it does an
  76.                                      * "uplevel" to get past the transparent
  77.                                      * frame and back to the calling context. */
  78.     Tcl_HashTable contextFrames;    /* object contexts for active call frames */
  79.  
  80.     int protection;                 /* protection level currently in effect */
  81.  
  82.     Itcl_Stack cdefnStack;          /* stack of class definitions currently
  83.                                      * being parsed */
  84. } ItclObjectInfo;
  85.  
  86. #define ITCL_INTERP_DATA "itcl_data"
  87.  
  88. /*
  89.  *  Representation for each [incr Tcl] class.
  90.  */
  91. typedef struct ItclClass {
  92.     char *name;                   /* class name */
  93.     char *fullname;               /* fully qualified class name */
  94.     Tcl_Interp *interp;           /* interpreter that manages this info */
  95.     Tcl_Namespace *namesp;        /* namespace representing class scope */
  96.     Tcl_Command accessCmd;        /* access command for creating instances */
  97.  
  98.     struct ItclObjectInfo *info;  /* info about all known objects */
  99.     Itcl_List bases;              /* list of base classes */
  100.     Itcl_List derived;            /* list of all derived classes */
  101.     Tcl_HashTable heritage;       /* table of all base classes.  Look up
  102.                                    * by pointer to class definition.  This
  103.                                    * provides fast lookup for inheritance
  104.                                    * tests. */
  105.     Tcl_Obj *initCode;            /* initialization code for new objs */
  106.     Tcl_HashTable variables;      /* definitions for all data members
  107.                                      in this class.  Look up simple string
  108.                                      names and get back ItclVarDefn* ptrs */
  109.     Tcl_HashTable functions;      /* definitions for all member functions
  110.                                      in this class.  Look up simple string
  111.                                      names and get back ItclMemberFunc* ptrs */
  112.     int numInstanceVars;          /* number of instance vars in variables
  113.                                      table */
  114.     Tcl_HashTable resolveVars;    /* all possible names for variables in
  115.                                    * this class (e.g., x, foo::x, etc.) */
  116.     Tcl_HashTable resolveCmds;    /* all possible names for functions in
  117.                                    * this class (e.g., x, foo::x, etc.) */
  118.     int unique;                   /* unique number for #auto generation */
  119.     int flags;                    /* maintains class status */
  120. } ItclClass;
  121.  
  122. typedef struct ItclHierIter {
  123.     ItclClass *current;           /* current position in hierarchy */
  124.     Itcl_Stack stack;             /* stack used for traversal */
  125. } ItclHierIter;
  126.  
  127. /*
  128.  *  Representation for each [incr Tcl] object.
  129.  */
  130. typedef struct ItclObject {
  131.     ItclClass *classDefn;        /* most-specific class */
  132.     Tcl_Command accessCmd;       /* object access command */
  133.  
  134.     int dataSize;                /* number of elements in data array */
  135.     Var** data;                  /* all object-specific data members */
  136.     Tcl_HashTable* constructed;  /* temp storage used during construction */
  137.     Tcl_HashTable* destructed;   /* temp storage used during destruction */
  138. } ItclObject;
  139.  
  140. #define ITCL_IGNORE_ERRS  0x002  /* useful for construction/destruction */
  141.  
  142. /*
  143.  *  Implementation for any code body in an [incr Tcl] class.
  144.  */
  145. typedef struct ItclMemberCode {
  146.     int flags;                  /* flags describing implementation */
  147.     CompiledLocal *arglist;     /* list of arg names and initial values */
  148.     int argcount;               /* number of args in arglist */
  149.     Proc *procPtr;              /* Tcl proc representation (needed to
  150.                                  * handle compiled locals) */
  151.     union {
  152.         Tcl_CmdProc *argCmd;    /* (argc,argv) C implementation */
  153.         Tcl_ObjCmdProc *objCmd; /* (objc,objv) C implementation */
  154.     } cfunc;
  155.  
  156.     ClientData clientData;      /* client data for C implementations */
  157.  
  158. } ItclMemberCode;
  159.  
  160. /*
  161.  *  Basic representation for class members (commands/variables)
  162.  */
  163. typedef struct ItclMember {
  164.     Tcl_Interp* interp;         /* interpreter containing the class */
  165.     ItclClass* classDefn;       /* class containing this member */
  166.     char* name;                 /* member name */
  167.     char* fullname;             /* member name with "class::" qualifier */
  168.     int protection;             /* protection level */
  169.     int flags;                  /* flags describing member (see below) */
  170.     ItclMemberCode *code;       /* code associated with member */
  171. } ItclMember;
  172.  
  173. /*
  174.  *  Flag bits for ItclMemberCode and ItclMember:
  175.  */
  176. #define ITCL_IMPLEMENT_NONE    0x001  /* no implementation */
  177. #define ITCL_IMPLEMENT_TCL     0x002  /* Tcl implementation */
  178. #define ITCL_IMPLEMENT_ARGCMD  0x004  /* (argc,argv) C implementation */
  179. #define ITCL_IMPLEMENT_OBJCMD  0x008  /* (objc,objv) C implementation */
  180. #define ITCL_IMPLEMENT_C       0x00c  /* either kind of C implementation */
  181. #define ITCL_CONSTRUCTOR       0x010  /* non-zero => is a constructor */
  182. #define ITCL_DESTRUCTOR        0x020  /* non-zero => is a destructor */
  183. #define ITCL_COMMON            0x040  /* non-zero => is a "proc" */
  184. #define ITCL_ARG_SPEC          0x080  /* non-zero => has an argument spec */
  185.  
  186. #define ITCL_OLD_STYLE         0x100  /* non-zero => old-style method
  187.                                        * (process "config" argument) */
  188.  
  189. #define ITCL_THIS_VAR          0x200  /* non-zero => built-in "this" variable */
  190.  
  191. /*
  192.  *  Representation of member functions in an [incr Tcl] class.
  193.  */
  194. typedef struct ItclMemberFunc {
  195.     ItclMember *member;          /* basic member info */
  196.     Tcl_Command accessCmd;       /* Tcl command installed for this function */
  197.     CompiledLocal *arglist;      /* list of arg names and initial values */
  198.     int argcount;                /* number of args in arglist */
  199. } ItclMemberFunc;
  200.  
  201. /*
  202.  *  Instance variables.
  203.  */
  204. typedef struct ItclVarDefn {
  205.     ItclMember *member;          /* basic member info */
  206.     char* init;                  /* initial value */
  207. } ItclVarDefn;
  208.  
  209. /*
  210.  *  Instance variable lookup entry.
  211.  */
  212. typedef struct ItclVarLookup {
  213.     ItclVarDefn* vdefn;       /* variable definition */
  214.     int usage;                /* number of uses for this record */
  215.     int accessible;           /* non-zero => accessible from class with
  216.                                * this lookup record in its resolveVars */
  217.     char *leastQualName;      /* simplist name for this variable, with
  218.                                * the fewest qualifiers.  This string is
  219.                                * taken from the resolveVars table, so
  220.                                * it shouldn't be freed. */
  221.     union {
  222.         int index;            /* index into virtual table (instance data) */
  223.         Tcl_Var common;       /* variable (common data) */
  224.     } var;
  225. } ItclVarLookup;
  226.  
  227. /*
  228.  *  Representation for the context in which a body of [incr Tcl]
  229.  *  code executes.  In ordinary Tcl, this is a CallFrame.  But for
  230.  *  [incr Tcl] code bodies, we must be careful to set up the
  231.  *  CallFrame properly, to plug in instance variables before
  232.  *  executing the code body.
  233.  */
  234. typedef struct ItclContext {
  235.     ItclClass *classDefn;     /* class definition */
  236.     CallFrame frame;          /* call frame for object context */
  237.     Var *compiledLocals;      /* points to storage for compiled locals */
  238.     Var localStorage[20];     /* default storage for compiled locals */
  239. } ItclContext;
  240.  
  241. /*
  242.  *  Compatibility flags.  Used to support small "hacks".  These are stored
  243.  *  in the global variable named itclCompatFlags.
  244.  */
  245. #define ITCL_COMPAT_USECMDFLAGS 0x0001    /* Tcl8.4a1 introduced a different Command
  246.                      * structure, and we need to adapt
  247.                      * dynamically */
  248.  
  249. #include "itclIntDecls.h"
  250.  
  251. /*
  252.  * Since the Tcl/Tk distribution doesn't perform any asserts,
  253.  * dynamic loading can fail to find the __assert function.
  254.  * As a workaround, we'll include our own.
  255.  */
  256.  
  257. #undef  assert
  258. #ifdef  NDEBUG
  259. #define assert(EX) ((void)0)
  260. #else
  261. #if defined(__STDC__)
  262. #define assert(EX) (void)((EX) || (Itcl_Assert(#EX, __FILE__, __LINE__), 0))
  263. #else
  264. #define assert(EX) (void)((EX) || (Itcl_Assert("EX", __FILE__, __LINE__), 0))
  265. #endif  /* __STDC__ */
  266. #endif  /* NDEBUG */
  267.  
  268. #undef TCL_STORAGE_CLASS
  269. #define TCL_STORAGE_CLASS DLLIMPORT
  270.  
  271. #endif /* ITCLINT_H */
  272.