Data processing: software development – installation – and managem – Software program development tool – Translation of code
Reexamination Certificate
1995-06-07
2003-02-11
Lao, Sue (Department: 2151)
Data processing: software development, installation, and managem
Software program development tool
Translation of code
C717S122000, C709S241000
Reexamination Certificate
active
06519767
ABSTRACT:
FIELD OF THE INVENTION
This invention relates generally to compiling executable programs, and more particularly relates to compiling executable programs to be compatible with previous versions of such programs.
BACKGROUND OF THE INVENTION
A significant development in the computer programming field is that of object oriented programming. Object-oriented programming generally refers to computer programs, programming languages and tools which utilize the concept of “objects.” The term “object” generally refers to an instance of a programmer-defined data structure (the data or variables of which are referred to as the object's “properties”) and functions that manipulate that structure (referred to as “member functions,” “member procedures,” or simply “members” of the object). In other words, objects are a combination of a data structure with a set of functions that perform methods on the data structure. The term “class” generally refers to the definition of an object. Object concepts can be applied to programs formed with most any programming language, including C, Basic, and others. Various object-oriented programming languages, such as Microsoft Corporation's Visual Basic version 4 programming environment, and the C++, and Smalltalk programming languages, provide formal syntax by which object-oriented concepts may be more easily expressed.
One benefit to the use of objects is that their members define a standard way for other programs to interact with or access the object's properties. A set of semantically related functions implemented on an object is generally referred to as an “interface” of the object. Each object typically includes at least one interface, but in some object-oriented systems (such as OLE 2 described below) may include more than one interface. By allowing access to an object's members through an interface, the object effectively “exposes” its functionality for use by other application programs. For example, a simple object with a property, “Color,” may have an interface which includes two members, “GetColor” and “SetColor,” which manipulate that property. Other application programs which have access to this object's interface can make use of its functionality by calling the GetColor and SetColor members of that interface.
Microsoft Corporation's Object Linking and Embedding 2 (“OLE 2”) provides a system for creating object-oriented applications for use with its Windows operating system. OLE 2 provides a way for objects supplied by one application program (hereafter referred to as the “object application” or “object server”) to be controlled by another application program (hereafter referred to as a “controlling application” or “client application”). After an object server is created, its programmer or developer can distribute the object server in the form of an executable file for use by others. Other developers and end users can then create client applications which make use of the functionality embodied in the object server's objects by accessing those objects through their interfaces. Accordingly, OLE 2 provides a way for the functionality embodied in the object server to be useable by any number of client applications.
In order to access the interfaces of an object server, client applications are created by compiling the client applications using a specific version of the object server (i.e. “built against” an existing version of the object server which may have been distributed to the client application's developer by the object application's developer). When built against a specific object server, the client application will have embedded in it detailed assumptions about the set of interfaces that the object server supports, and the definition of those interfaces. For example, in OLE 2, interfaces to objects of an object server can be virtual function table interfaces or dispatch interfaces. An object implements a virtual function table interface by providing a virtual function table (vtable), which is an array containing pointers to members of the object such that the signatures of the members and their offsets within the vtable are exactly as specified in the definition of that interface. Members in the interface are accessed by client applications according to the particular offset of their function pointers within the vtable. More particularly, code is built into the client application which accesses a member by locating the function pointer at the member's respective offset within the vtable, and issuing a call instruction to that function pointer. The assumption that the pointer to a member can be found at a particular vtable offset in the interface is thus embedded in the client application.
An object implements a dispatch interface by providing a dispatching interface (IDispatch) implementation whose “invoke” function supports a dispatch identifier (DISPID) to member mapping as specified by the interface's definition. The IDispatch interface is implemented in conformance with the description in Corbett, et al., Method and System for Invoking Methods of an Object through a Dispatching Interface, U.S. Pat. No. 5,515,536 which is hereby incorporated by reference. Members in the interface are accessed by client applications according to their respective DISPIDs. More particularly, code is built into the client application which accesses a member by calling the invoke function and passing the member's DISPID as an argument. The assumption that the DISPID will be mapped to the desired member is thus embedded in the client application.
Additionally, before a client application can begin accessing members within an interface, it must first gain access to the interface itself by obtaining a pointer to the interface. In OLE 2, object servers may provide a type library conforming to the description in U.S. patent application Ser. No. 07/959,056, entitled “Method and System for Interfacing to a Type Library,” which is hereby incorporated by reference. The type library contains definitions of the classes of objects supplied by the object server and their interfaces.
So that client applications can get a pointer to interfaces on the object server's objects, each object server registers information in a system registry provided in the operating system by which the classes that the object server supplies and their interfaces can be identified. This information includes a library identifier (library ID) associated with the object server's type library and a unique class identifier (CLSID) associated with each of the classes it supplies, and also may include a unique interface identifier (IID) associated with each interface of the classes. In Microsoft Corporation's Windows operating system, version 3.1, for example, object servers register their identifiers in a system registry that is maintained in a file named, “REG.DAT,” generally located in a directory with default name, “\WINDOWS.” In Microsoft Corporation's Windows NT operating system, object server identifiers are kept in a “HKEY_CLASSES_ROOT” section of a system registry maintained in the “\WINDOWS\SYSTEM32\CONFIG” directory.
OLE 2 further provides application programming interface (API) functions (e.g. CoCreateInstance and CoGetClassObject) which, given a CLSID, and IID passed in a call to the function, creates an object based on the definition of the class associated with the CLSID, and returns a pointer to the interface associated with the IID. Client applications obtain an initial pointer to an interface on an object with built-in code that calls such API functions with a CLSID to uniquely identify the object's class in the system registry, and an IID that identifies the class' interface. Accordingly, the assumption that the CLSID correctly identifies the class, and the IID correctly identifies the desired interface additionally is built into the client application.
Client applications also have embedded assumptions concerning the library ID associated with the object server's
Carter Alan W.
Kumar Rajiv
Solomon Andrew R.
Klarquist & Sparkman, LLP
Lao Sue
Microsoft Corporation
LandOfFree
Compiler and method for automatically building version... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Compiler and method for automatically building version..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Compiler and method for automatically building version... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3160710