Abstract: A computer system which operates by means of a plurality of programs and which controls the giving and receiving of data between programs in memory, the computer system including: a data storage area for storage of data which includes data having differing data formats, such as numeric data or character strings; and a data driver which controls the giving and receiving of data between the plurality of programs and the data storage area, wherein in the case in which data is to be passed from a first program to a second program of the plurality of programs, the data driver storing data from the first program into the data storage area, and in accessing the stored data, converting it to a format specified by the second program and passing the data to the second program. In this configuration, it is possible to give and receive data between programs without either considering the differences between systems or platforms, or having to change the common interface between programs.

Abstract: There is provided a system and method in a heterogeneous multiprocessing system for performing external procedure calls from a Client Program to a Server Program, both of which are stored in a common memory. The Client Program is executed by a first CPU under control of a first operating system and the Server Program is executed by a second CPU under control of a second operating system. The first and second operating systems are also stored in the common memory. The Client Program includes a Proxy Procedure for invoking a Server program function, and a Stub Procedure for converting parameter and result data from the first to the second operating system. The Client Program further includes a Protocol Procedure for passing data between the Client and Server CPUs.

Abstract: In a method of operating a computer system having a plurality of processes, creating a plurality of object references, each object reference corresponding to a target object. The processes optionally executing on a plurality of computers connected by a network. For each object reference, creating a table of binding information hints. The table is indexed by a particular transport protocol and each entry in the table of binding information hints includes information to be used to attempt to establish a connection from the process to the target object using the indexing transport protocol. Merging the tables of binding information hints upon receiving an object reference. Other systems and methods are disclosed.

Abstract: A computer program product simulates shared code threads with Windows NT fibers. Computer code is included for reusing shared code threads which complete.

Abstract: A visual development system is described which provide “method pointers” allowing a developer/user to achieve delegation between objects programmatically as well as visually. Delegation “binds” an event source with an event handler. This binding is directly supported within the programming language of the system. Using a simple assignment statement, the user can assign a handler of one object (i.e., delegated-to object) to the method pointer of another object (i.e., delegated-from object). A delegation through assignment leads to not only the address of the method being copied but also the address of the delegated-to object (i.e., “this” pointer) being copied into the method pointer. The method pointer, when called, can invoke the pointed-to method on that (delegated-to) object, complete with the context (e.g., local data) of the object. The object knows about itself and, thus, can provide the appropriate context.

Abstract: Concurrent sequential processes synchronize by intra-process amend operations and inter-process operations. To each interactive subset of processes a part of an associated I/O channel is assigned. Each inter-process operation includes one or more update operations for exchanging information between an associated process of the pair and its in-channel part, and also one or more adapt operations for in-channel moving of information between the respective parts assigned to the processes of the pair.

Abstract: Uniform access to and interchange between objects with use in any environment that supports interface composition through interface inheritance and implementation inheritance from a common base class is provided. Proxies are used to provide both cross-language and remote access to objects. The proxies and the local implementations for objects share a common set of interface base classes, so that the interface of a proxy for an object is indistinguishable from a similar interface of the actual implementation. Each proxy is taught how to deal with call paramters that are proxies of the other kind. A roster of language identifiers is developed, and a method is added to each object implementation which, when called, checks whether it matches the language that the object implementation is written in. If so, it returns a direct pointer to the object implementation. Common client coding can then be used to deal with both same language and cross-language calls.

Abstract: A computer system having a system ROM comprising a flash or bulk EPROM replacing a block flash or boot block EPROM, and a second ROM to store the primary boot code. In a first embodiment, a single block EPROM is replaced with a bulk EPROM and a ROM, where the ROM is preferably a one-time programmable ROM. The primary boot code is copied into the ROM thereby preventing its erasure. The bulk EPROM is reprogrammed if desired. Separate decode logic detects an address to the primary boot code and enables the ROM. In a second system using a block EPROM and a bulk EPROM as the system ROM, the block EPROM is replaced with a bulk EPROM, and the primary boot code is copied into both bulk EPROMs, preferably at mirrored locations. An external switch is provided with appropriate logic, so that the user may select between either of the bulk EPROMs to boot the system. Thus, if the system is unable to boot from one of the bulk EPROMs, the user may flip the switch to access the primary boot code from the other bulk EPROM.

Abstract: The groupware development assisting system includes a format definition portion which defines a format of the electronic mail given or received among nodes, an object definition portion which defines the operation condition information of a software object forming one of nodes inputting or outputting the electronic mail, a transferring order definition portion which designates a transferring route showing the delivery and receipt of the electronic mail among the nodes and a format of the electronic mail given or received by the transferring route.

Abstract: A data processing system at least a portion of which operates under control of an object-oriented program. The data processing system contains an object-oriented system, in which a plurality of objects are defined by the above object-oriented program, each of the plurality of objects belongs to a corresponding one of a plurality of classes as an instance of the corresponding one of the plurality of classes, and one or more inheritance relationships are defined between at least one pair of classes among the plurality of classes based on inheritance coupling information. An inheritance coupling information setting unit receives a first request, and sets at least one piece of the inheritance coupling information in a data storage area, in response to the first request. The inheritance coupling information held in the inheritance coupling information indicating unit can be referred to by at least one of the above plurality of objects.

Abstract: A transactional adapter for an object-oriented data processing system maintains a tree of transactions corresponding to messages between objects. A message is transformed into a child transaction, but only when any access restrictions are met. Until then it is held in a “pending” set which is part of the parent transaction's state definition. When a child commits, its parent maintains the access restrictions imposed by the child if the parent is recoverable and discards them otherwise.

Abstract: The present invention discloses a system for providing communication between applets. A browser, such as an HTML web browser, is executed within a computer and a server program including a protocol, such as the HTTP protocol, is executed in the browser. A first page is executed within the browser and a first applet, such as a Java applet, is executed within the first page. A second page is executed within the browser and a second applet is executed within the second page. The second applet transmits data to the server program using the protocol. The first applet executing in the first page processes the data transmitted from the second applet to the server program. The first applet may be used to establish a connection with a remote server over a network using a second protocol, such as POP3, IMAP4, LDAP, SMTP, and transmit the data received from the second applet to the remote server via the network using the second protocol.

Abstract: A method and mechanism for efficiently handling connections in a computer system between client sockets and data sockets of a server. The server includes a receive-any thread having a socket mask associated therewith to listen for new connection requests and for activity on data sockets handled thereby. The server further includes receive-direct threads associated with at least some of the data sockets for handling data communication. When a receive-direct connection has no activity for a period of time, the connection is migrated to a receive-any connection. When a receive-any connection becomes active, the connection is migrated to a receive-direct connection if a receive-direct thread is available.

Abstract: A structure and method for routing information desired by a particular entity within a pen-based computer system to that entity are provided. The desired information is contained in “packages” containing the desired information in one or more “parts” and also containing a package directory (located in front of the parts) that identifies the package and provides selected information about the package and its parts. The packages are received and processed by a package manager that maintains a registry of entities that desire specified types of information (parts) that might be found in an incoming package. When the package manager receives a package containing such information, it routes the part containing that information to a “part handler” associated with the entity requesting the information. The package manager then updates a package registry to reflect that the package has been successfully delivered.

Abstract: A processor detects a function which includes no function call instruction and no update of the return address /calculation register from an assembler program. After the detection, the processor outputs a special return address to the end of the function detected, and executes the assembler program. The processor stores a return address not only on the stack but in the return address/calculation register. When the special return instruction has been fetched, the return address is moved from the return address/calculation register without accessing to the stack.

Abstract: Data structures, methods, and devices for facilitating servant invocation in a distributed client-server based object oriented operating system are disclosed. In one aspect of the invention, descriptor data structures, which contain a typecode indicator, a marshaling function identifier, and an unmarshaling function identifier, are used to enable modules of application code to be shared between different objects, thereby facilitating servant invocation by increasing the amount of commonized code in the operating system. In another aspect of the invention, a server invocation object is used in the execution of a method call. In still another aspect of the invention, a commonized code base is used to process typecode interpreted and compiled calls to a server process.

Abstract: A system and method provide for synchronous operation of linked command objects in a general purpose software application. The software application provides a user with a variety of operations that manipulate available data objects. The software application manages the data objects in a number of contexts. Each context manages the existence and execution of a number of command objects. Each command object operates on one or more data objects in its context. To support synchronous operations that affect the state of data objects in more than one context, command objects are linked to each other. When one command object is executed, the context of the command object identifies a command object linked to the executed command object and initiates the execution of the linked command object via the context that manages that command object. This synchronization allows for synchronous undo and redone operations. The delete states of the command objects are also synchronized.

Abstract: An intelligent creator design pattern for instantiating a new application subclass of an application base class without revising existing application code in an object-oriented programming system. The intelligent creator design pattern of this invention specifies a base class to be inherited by an intelligent creator subclass added to an existing application to instantiate a new application subclass responsive to recognition of predetermined application input data without modification to the remainder of the application code. A dynamic list object that includes methods for autonomously updating a list of references to all intelligent creator subclasses eliminates knowledge of specific creator subclasses from the application. The dynamic list object code need not be updated when adding creator subclasses because the list object is self-updating responsive to the recognition methods of each new creator subclass added to the application.

Abstract: A variety of methods and apparatus for managing deactivation and deletion of objects and server processes are taught. According to some embodiments of the present invention, a thread of execution termed the reaper thread systematically cycles through a computer process deactivating and/or deleting objects based upon a variety of criteria. One suitable criterion for object deactivation is based upon the amount of time lapsed since a client has requested services of the object. According to the timeout criterion, the reaper thread determines the period of time since the last client requested services from the object, compares this to a timeout value which may be defined by any suitable entity, and proceeds with deactivation and/or deletion accordingly. Object deletion may have a separate criterion or be specifically requested by a client. A deletion flag may be set to indicate that object deletion is requested.

Abstract: The present invention provides an elegant and compact way to provide mechanisms for invocation of objects by client applications and for argument passing between client applications and object implementations, which reduce the memory space required for the client-side stubs, without the client application or the operating system knowing the details of how these mechanisms work. Moreover, these mechanisms function in a distributed computer environment with similar ease and efficiency, where client applications may be on one computer node and object implementations on another. Additionally the invention is independent of the particular C++ compiler used for generation of the stub code. The mechanism used to reduce this memory space comprises a stub generator (called "CONTOCC"), a data base of client-side stub description files and a stub-interpreter which knows how to read these client-side stub description files. CONTOCC reads interface definition language ("IDL") files and generates corresponding C++ files.