text: the following detailed description describes on embodiment of this invention which is particularly well suited for use in the object - oriented language known as c ++. however , it is to be understood that the teachings of this invention are equally applicable to any object - oriented technology , including languages other than c ++. the embodiment of this invention will now be described with reference to fig1 and 2 which depict the operation of and interaction between the following modules : a . the class scanner . class scanner 101 is used to determine the attributes of classes contained in header files 102 of a compiled class library 122 . class scanner 101 extracts class information 103 from the header files contained in class library 122 in order to have ready access to sufficient information to understand the nature of each class . class scanner 101 is , preferably , run only once ( unless the library changes ), with the extracted information being stored for ready access without the need to run class scanner 101 again . in the event class library 122 is altered , class scanner 101 can either scan the entire class library again to extract information pertaining to each class , or can be used to extract information only pertaining to the new or altered classes , thus increasing the speed of operation . besides extracting class information , class scanner 101 also generates various object manipulation functions ( omf ) 112 ( fig3 ) for each scanned class . these functions perform various operations on objects such as invoking their methods , accessing their attributes , performing object copy , and the like . b . the class selector . class selector 104 is a mechanism to allow a user to choose classes from those available on the class information file provided by class scanner 101 . only objects from these selected classes are then accessible by object handler 130 . c . the object handler . object handler 130 . provides a convenient mechanism for utilizing class information 103 pertaining to each class , which information has been extracted by class scanner 101 . object handler 130 thus allows a user to gain access to an object in a convenient manner . d . the interpretive dispatcher . interpretive dispatcher 120 manipulates an object , using the access to the object which is established by object handler 104 . interpretive dispatcher 120 allows immediate execution of object - oriented source code by recognizing and executing the object - oriented code syntax . in accordance with the teachings of this invention , since class scanner 101 has extracted information pertaining to each class automatically , interpretive dispatcher 120 avoids the need to declare which header files will be used and their attributes , which provides a distinct advantage over prior art object - oriented compilers . a more detailed description of one embodiment of these modules is now provided . fig3 and 4 form a flow chart of one embodiment of class scanner 101 . in order to allow access to classes , the knowledge of the structure of these classes must be made known . in &# 34 ; c ++&# 34 ;, all class definitions are available and can be found in . h files , which together with the compiled classes form the class library 122 . this library could be developed by the user or obtained from external sources . in step 107 , class scanner 101 first combines . h files 102 in compiled class library 122 into a single viragotemp3 -. cxx file 108 , which is then preprocessed in step 109 to create file . scanh 110 . file . scanh 110 is then parsed in step 111 in order to obtain and store in class information file 103 the following information about each class : besides this information , class scanner 101 also stores information about typedefs and global variable declarations . class scanner 101 also generates through step 111 c ++ source code to form various object manipulation functions ( omf ) 112 to perform desired operations on the scanned classes . for example , the following object manipulation functions are created for each class scanned : a . a function to invoke the class method ( including static method ). naturally , it is to be understood that not all applications will need each of these functions , or additional functions maybe useful in certain applications . the selection of functions , including functions not described in this example , is apparent to those of ordinary skill in the art in light of the teaching of this invention . furthermore , for embodiments of this invention which utilize other than c ++ object oriented code , functions may be used other than the examples given above . annex i , below , provides examples of code generated for each of these object manipulation functions 112 of class scanner 101 . besides parsing file . scanh , step 111 also executes the create -- exp -- ifile to create the expand -- ifile . h file 112 . in addition , class scanner 101 also generates code for a function that creates a table of sizes to store the size of a class returned by the function g . above . after the c ++ source code for the above object manipulation functions 112 have been generated and the expand -- ifile . h file have been created , they are translated to c source code by a c ++ translator such as the cfront translator available from at & amp ; t . the resulting translated omf source code 113 is then patched by patch program 114 provided in accordance with the teachings of this invention . patched code 115 is then compiled by a c compiler to form the object manipulation functions ( omf ) library 116 , which forms part of object handler 103 , as depicted in fig2 . when an object - oriented function is executed , it normally returns a value which is either a class object , a type of pointer , or a fundamental type , depending upon the operation of the function . however , for the above object manipulation functions 112 , a descriptor of the return value rather than the value itself is returned . the descriptor has a structure defined as : ______________________________________ struct descriptor { int type ; int flag ; union { void * return . sub .-- value ; int * vint ; . . all fundamental types . . . class1 * vclass1 ; class1 ** v1class1 ; class1 *** v2class1 ; class2 * vclass2 ; class2 ** v1class2 ; class2 *** v2class2 ; . . . . }; ______________________________________ in the above descriptor structure , &# 34 ; type &# 34 ; describes the type specification of the return value , and &# 34 ; flag &# 34 ; is used to indicate how the descriptor is to be freed after use . as shown in the above descriptor structure , each class includes one line for each level of indirection ; the above descriptor structure example has three levels of indirection for class 1 and class 2 . for the structure defined above , each scanned class can have a pointer to an object , a pointer to pointer to an object , and a pointer to pointer to pointer to an object . should more indirection be needed , the union structure can be extended . for example , when an int is to be returned , the return -- value in the descriptor structure is the address of that int . when an object is to be returned , the return -- value is the address of that object . when a pointer to an object is to be returned , the return -- value is the address of the object address pointer . appendix i are c and c ++ source code listings for the following files which serve as one embodiment of class scanner 101 suitable for use with the c ++ object - oriented language . class selector 104 ( fig1 ) allows a user to select only those classes whose objects the user wishes object handler 130 to access . the class information of these selected classes is then used as input to generate the c ++ source code of the dispatch tables ( dt ) to the object manipulation functions ( omf ) 105 . this c ++ source code is then translated to c source code , which is then compiled and stored as dt to omf library 106 , one of the three libraries of object handler 130 . dispatch tables are well known in the art and thus specific code used to implement a suitable dispatch table is not discussed . appendix ii are c and c ++ source code listings for the following files which serve as one embodiment of class selector 104 suitable for use with the c ++ object - oriented language . object handler 130 includes object entry functions ( oef ) library 118 , dt to omf library 106 , and omf library 116 . oef library 118 is obtained by translating using a c ++ translator and then compiling using a c compiler the c ++ source code of the object entry functions 117 written in accordance with this invention . object handler 130 is the interface to compiled class library 122 . interpretive dispatcher 120 uses object handler 130 to gain access to attributes and methods of user - defined compiled classes . there are several entry points to object handler 130 . these entry points , which constitute object entry functions ( oef ) library 118 , call the corresponding generated object manipulation functions of omf library 116 through dispatch tables of dt to omf library 106 , which in turn make calls to compiled class library 122 . ______________________________________a . struct descriptor * call . sub .-- method ( char * classname , char * methodname , void * objectptr , struct descriptor * argument . sub .-- array [], int argument . sub .-- count ; b . struct descriptor * call . sub .-- getattr ( char * classname , char * attributename , void * objectptr ); c . void call . sub .-- copy ( struct descriptor * from ); d . void call . sub .-- cast ( char * fromclass , char * toclass , void * fromclassobjectptr ); e . void call . sub .-- assign ( void * fromobjectptr , void * toobjectptr , char * classname ); f . struct descriptor * call . sub .-- array ( char * classname , int sub1 , int sub2 ...); g . int get . sub .-- sizeof ( char * classname ); ______________________________________ in function call -- method ( function &# 34 ; a &# 34 ;), the arguments in the array of descriptor may not be the exact match of a class method . in this case , integral promotions , integral conversions , arithmetic conversions , pointer conversions , and / or reference conversions had to be performed on the argument list to make it an exact match before dispatching the argument list to the functions generated by class scanner 101 . appendix iii are c and c ++ source code listings for the following files which serve as one embodiment of object handler 130 suitable for use with the c ++ object - oriented language . object handler 130 also includes object manipulation functions contained in library 116 , and dispatch tables to object manipulation functions , contained in dt to omf library 106 . the object manipulation functions are generated by class scanner 101 while the dispatch tables to object manipulation functions are generated by class selector 104 , as described above . interpretive dispatcher 120 accepts c ++ statements as char * and converts it into tokens of immediate codes . these codes are then evaluated . should access to classes be needed , interpretive dispatcher 120 calls the respective routines in object handler 130 to do the job . interpretive dispatcher 120 is shown in fig2 as a library . this library is obtained by translating using a c ++ translator and then compiling using a c compiler the source code of the interpretive dispatcher written in accordance with this invention . the format to be used by another program to make a call to interpretive dispatcher 120 is , for example , as follows : dml ( char * statements ); where &# 34 ; statements &# 34 ; is a string of program code which is to be interpreted by interpretive dispatcher 120 . ______________________________________class customer { char name [ 30 ]; float amount ; static customer * lookup ( char * customername ); void setamount ( float amt ) { amount = amt ;} } ______________________________________ to set the amount of customer &# 34 ; foobar &# 34 ; to 1234 . 56 , the following call is made to interpretive dispatcher 120 : as interpretive dispatcher 120 dynamically accepts any string of statements and executes them , interpretive dispatcher 120 together with object handler 130 can conveniently be used with or embedded in object - oriented tools to interactively develop applications . dispatcher 120 can also be integrated with an object - oriented database for interactive query or data manipulation using compiled classes . this is convenient , for example , for use with screen builders , object - oriented databases ( including allowing a client on a network to send a string of statements , for example , over a communication network to a server for execution ), and for use in connection with report generators . interpreters are well known in the art and thus specific code used to implement a suitable interpreter will not be discussed . finally , in order to use this invention to develop applications , the following libraries are linked together into a single body of executable code 131 : this linking enables tools ( including screen builders and report generators ) or object - oriented databases 121 to have an interpretive object - oriented facility for on - line and interactive access of pre - compiled classes in the class library 122 , i . e . classes which have been written using object - oriented source code and have been compiled into object code to form class library 122 . the details of one embodiment of the generated codes for each of the class scanner object manipulation functions 112 described above are as follows : before method invocation , object handler 130 has already created a global object pointer ( void * objectptr ) pointing to the object instance , a global array of descriptors ( struct descriptor * global -- argument ) which describes the arguments of the method , and a count of the number of descriptors . thus , to generate code for a function to invoke , for example , a class method of class0 , i . e . : where the method name is a -- method , the return value is a class object of class3 , and the arguments are int , class1 , and pointer to class2 ( class2 *), the following code is generated : ______________________________________class3 temp = objectptr → a . sub .-- method ( *( global . sub .-- argument [ 0 ]→ vint ), *( global . sub .-- argument [ 1 ]→ vclass1 ), *( global . sub .-- argument [ 2 ]→ v1class2 )); ______________________________________ if the method is a static method , then the following code is generated : ______________________________________class3 temp = class0 :: a . sub .-- method ( *( global . sub .-- argument [ 0 ]→ vint ), *( global . sub .-- argument [ 1 ]→ vclass1 ), *( global . sub .-- argument [ 2 ]→ v1class2 )); ______________________________________ a descriptor of temp should be built and returned . however , because temp is a local variable , it will be destructed when the function exits out of its local scope . to prevent temp from being destructed , temp could be declared static , but this will incur a huge memory overhead . to overcome these problems , in accordance with the teachings of this invention , the &# 34 ; c &# 34 ; output of the c ++ translator is patched in order to change the code to behave as if temp is dynamically allocated and no destructor is called when the scope of temp ends . as well known to the art a c ++ code , when translated , for example , by utilizing cfront , a c ++ translator available from at & amp ; t , becomes c code which can be compiled utilizing a standard c compiler . ______________________________________ class3 temp = objectptr → a . sub .-- method ( *( global . sub .-- arg [ 0 ]→ vint ), *( global . sub .-- arg [ 1 ]→ vclass1 ), *( global . sub .-- arg [ 2 ]→ v1class2 )); ______________________________________ would be translated by the c ++ translator to something like the following c code : ______________________________________ struct class3 . sub .---- 1temp ; . sub .---- ct . sub .---- 6class3fv ( & amp ; . sub .---- 1temp ); . sub .---- 1temp = a . sub .-- method . sub .---- 6class0fi6class1p6class2 ( ( struct class0 *) object , (*( global . sub .---- argument [ 0 ])→ . sub .---- o2 . sub .---- 12value struct . vint ), (*( global . sub .---- argument [ 1 ])→ . sub .---- o2 . sub .---- 12value struct . vclass1 ), (*( global . sub .---- argument [ 2 ]→ . sub .---- o2 . sub .---- 12value . sub .-- struct . vclass2 ));. sub .---- dt . sub .---- 6class3fv ( & amp ;. sub .---- 1temp , 2 ); ______________________________________ since temp is destroyed once it exits its scope , in accordance with the teachings of this invention a patch program has been written which when used scans the generated c code which has been generated by the c ++ translator and which replaces all local variables ( such as -- 1temp as shown in the above translated code with pre - defined global variables ( such as glo -- temp ). glo -- temp is allocated sufficient memory space to hold what a -- method would return . in addition , the patch scan program also removes the destructor that was used to remove temp when it exits its scope . ______________________________________ . sub .---- ct . sub .---- 6class3fv ( & amp ; glo . sub .-- temp ); glo . sub .-- temp = a . sub .-- method . sub .---- 6class0fi6class1p6class2 ( ( struct class0 *) object , (*( global . sub .---- argument [ 0 ])→ . sub .---- o2 . sub .---- 12value struct . vint ), (*( global . sub .---- argument [ 1 ])→ . sub .---- o2 . sub .---- 12value struct . vclass1 ), (*( global . sub .---- argument [ 2 ])→ . sub .---- o2 . sub .---- 12value . sub .-- struct . vclass2 )); ______________________________________ accordingly , in accordance with this aspect of the present invention , instead of a descriptor of local variable temp , a descriptor of global variable glo -- temp is built and returned . this return value , being a global variable , can be used even outside the scope where temp is declared . before method invocation , interpretive dispatcher 120 has already created a global object pointer ( void * objectptr ) pointing to the object instance . this function simply return the descriptor of the attribute . for example , to return the attribute x of the following class : 1 . allocate space for a descriptor from dynamic memory with a memory allocation function called malloc as follows : this function can be used by interpretive dispatcher 120 to make a copy of an object instance . this function contains the following generated code for a class x : objectptr refers to the object instance where a copy is to be made . this objectptr is created by the object handler . the variable temp is again only local . the same patch to &# 34 ; c &# 34 ; code generated by the c ++ translator is used , as explained previously with regard to the function to invoke class method . in the case where only a single inheritance is used , the function simply returns the original pointer values no matter whether the casting is from base classes to derived classes or from derived classes to base classes . in the case of multiple inheritance and non - virtual base classes , the function generates casting code from base classes to derived classes and from derived classes to base classes . for multiple inheritance involving virtual base classes , the function generates casting code only for casting from derived classes to base classes , because for standard &# 34 ; c ++&# 34 ; casting of virtual base classes to derived classes is not supported by c ++. this function contains generated code that takes two arguments of void * to , void * from of class x to perform : this function contains generated code that allocates a descriptor as follows : this generated code then fills in the type and flag information into the descriptor . this generated code also contains the following information , depending upon whether a one - dimensional or two - dimensional array is required : and also code that stores the value of this size in a table of sizes which is also created by class scanner 104 . the invention now being fully described , it will be apparent to one of ordinary skill in the art that many changes and modifications can be made thereto without departing from the spirit or scope of the appended claims . ## spc1 ##