Sun Microsystems, Inc.

Oracle America, Inc.

Graham Hamilton

Peter B Kessler

Jeffrey D Nisewanger

Sanjay R Radia

Jonathan J Gibbons

Michael L Powell

Panagiotis S Kougiouris

Steven Robert Kleiman

Sami Shaio

Michael N Nelson

Swee Boon Lim

Brian T Lewis

Jacob Y Levy

James G Mitchell

Eduardo Pelegri-Llopart

Laurence P Cable

Laurence P G Cable

Alan Bishop

Arthur A Van Hoff

James H Waldo

Ann M Wollrath

Nedim Fresko

Yousef A Khalidi

Peter W Madany

James J Voll

Roger S Riggs

Robert B Hagmann

Theron D Tock

Dean R Long

David M Bristor

Joshua J Bloch

Marianne Mueller

Alan G Bishop

Panagiotis Kougiiouris

John Chapin

According to one embodiment of the invention, the JAVA compiler is modified so that when the JAVA compiler determines, while compiling source code, that an invocation of a first method, which expects to receive a reference to an object, passes, to the first method, a reference to a second method instead of a reference to an object, the JAVA compiler does not issue a compile-time error as the JAVA compiler normally would. Instead, the JAVA compiler generates compiled code (e.g., byte code) that the JAVA compiler would have generated if the source code had (a) defined a 'bridge' class that implemented a method that invoked the second method and (b) contained, in the invocation of the first method, a reference to an object that was an instance of the 'bridge' class in the place of the reference to the second method.

Supporting method references in the JAVA language

A system and method for providing traceable acknowledgement of a digital data distribution license is presented. A license specifying terms applicable to a user requesting a distribution of data maintained in digital form is defined. The digital data distribution is encoded by application of a phrase used to convolute the digital data distribution. The phrase signifies an acknowledgement by the user to be bound by the license terms. The digital data is distributed. Access to the digital data distribution requires application of the phrase to deconvolute the digital data distribution.

System and method for providing traceable acknowledgement of a digital data distribution license

One embodiment of the present invention provides a system for associating metadata attributes with program elements. During operation, the system receives source code containing syntactic elements that specify metadata attributes for program elements, wherein the metadata attributes do not affect program execution. The system then parses the source code to obtain the metadata attributes. Next, the system associates the metadata attributes with corresponding program elements and determines values associated with the metadata attributes. Finally, the system incorporates the metadata attributes, including identifiers for the associated values and the associated program elements, into object code for the program, thereby allowing the metadata attributes to be accessed from the object code. Another embodiment of the present invention provides a system for accessing metadata attributes for program elements from object code through an application programming interface (API).

Method and apparatus for associating metadata attributes with program elements

A system or method enables a two tier computer application to operate in a three tier computer environment without specific programming for the three tier environment. Such a system or method receives a database call at a computer system and maps the database call to a general programming language call of a computer application. The general programming language call is executed to invoke functions of the computer application that correspond to functions of the database call. The general programming language call may be an Enterprise Java Bean (EJB) call. An application server receives the database call and maps the database call to the general programming language call. In response to executing the general programming language call, the application server generates a second database call to the database that may either correspond directly or indirectly to the database call received at the application server. The database calls may both be SQL calls. The general computer programming language may have EJB components that are analyzed to determine the correspondence between the database elements and the elements of the components that access the database elements. Methods of the EJB components may be identified for use in determining the correspondence. The methods may be identified by searching for a method of the form &#x3c;command prefix&#x3e;XXX, where the prefix is a 'get' or 'set' method.

Database access bridge system and process

Data structures, methods and devices for reducing computing overhead by utilizing different invocation paths for same process and different process invocations in a distributed client/server based computing system are disclosed. In one aspect of the invention, calls to a servant that do not share the same process as the requesting client are routed through a transport layer, and calls to servants that do share the same process as the requesting client are passed directly to the servant, thereby bypassing the transport layer. In another aspect of the invention, distinct remote and local method tables are provided to facilitate intelligent routing of requests. In still another aspect of the invention, the appropriate method table for an object reference is intelligently selected based upon the location of the identified object.

Method and apparatus for improving the performance of object invocation

A method for enabling an application program to communicate with a network server, includes the steps of downloading a document from a document server to the application program, downloading code from a code server associated with the document server to the application program, the code including a network protocol handler for the network server, and using the network protocol handler to communicate with the network server.

Method and apparatus for enabling application programs to communicate with network clients and servers

Methods, software, and apparatus for analyzing a software component within an application builder tool are disclosed. The present invention relates, in one aspect, to a method for analyzing a software component that can be visually moved within an application builder tool running on a computer. The method involves obtaining the software component to be analyzed and determining if the software component has an associated information class. When it is determined that the software component has an associated information class, the information class is queried about information stored within the information class, otherwise automatic analysis using design patterns is applied to analyze the class. In one embodiment, the information stored within the information class relates to methods, properties, and/or events.

Method and apparatus for software component analysis

A computer-implemented method and apparatus in a computer system for inter-process communication. A first procedure allocates a first buffer in a first memory space shared by the first procedure (e.g. a client process) and a second procedure (e.g. a kernel or server process). The first procedure then marshals arguments for communicating with the second procedure in the first buffer. The first procedure indicates that a message for the second procedure is being passed and passes a first reference to the first buffer in the first memory space to the second procedure. The second procedure detects the indication of the message by the first procedure. The second procedure then references the first buffer and copies the arguments contained in the first buffer into a temporary buffer. The second procedure can then deallocate the first buffer. In implemented embodiments of the present invention, inter-process communication is more efficient because the first buffer is deallocated upon receipt of the communication by the second process.

Method and apparatus for space-efficient inter-process communication

Methods and apparatus in an object oriented programming environment for invocation of objects with interface inheritance. An object reference using mtables contains two parts, more specifically, a pointer to the data for an object and a pointer to the methods on the object. The methods on the object are represented by a collection of mtables. An mtable for a given interface consists of pointers to mtables for inherited interfaces and pointers to functions implementing the operations declared in the interface. An mtable pointer in an object reference points to an mtable for an apparent interface of the object reference. Mtables for any inherited interfaces are reached by indirection from the mtables for the apparent interface.

Method and mechanism for invocation on objects with interface inheritance

A method of loading objects from primary memory includes the step of creating hash values for listed objects to create a hash index specifying a set of hash values. The hash index is loaded into primary memory to form a primary memory hashed index object directory. A calculated hash value is derived for an invoked object. The calculated hash value is matched with a hash value in the primary memory hashed index object directory. In response to this matching operation, an object corresponding to the calculated hash value is loaded into primary memory.

Apparatus and method for loading objects from a primary memory hash index

Doors are implemented in an existing operating system by using a novel adaptation of existing data structures and procedures which represent and control data files of the operating system. A door is represented by a file descriptor and is managed by existing mechanisms of an operating system, such as the Unix operating system, which are also used to manage files. A door is represented by a door node, which is a novel extension of the conventional vnode structure which in turn is used in conventional operating systems to represent the state of a computer resource, e.g., a data file. A door node is adapted such that most conventional file access and control procedures, e.g., procedures open( ) and close( ), can be used to access and control door with minimal adaptation. A door node is formed by appending fields which are specific to a door node's representation of the state of a door to fields of the door node which are analogous to the fields of a vnode, which represents the state of a resource and which has a conventional structure. Thus, the fields of a door node which precede the fields specific to the representation of the state of a door are of the size, location, and format of analogous fields in a conventional vnode. A client process obtains a file descriptor which identifies a door by supplying the name of the door to the operating system.

Remote procedure calling using an existing descriptor mechanism

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. CONTOCC has the ability to read the IDL data and generate either normal C++ stub files or the special client-side stub description files.

Client-side stub interpreter

Method and apparatus for enabling application programs to communicate

Growing community of inventors

Palo Alto, CA, United States of America

Graham Hamilton