Method and apparatus for interfacing a javascript interpreter with library of host objects implemented in java

ABSTRACT

A JavaScript interpreter may be interfaced with a JavaScript library of host objects implemented in Java. A JavaScript program may be accessed and parsed, an intermediate representation of the program may be generated, and the intermediate representation may be executed by interfacing with the library of host objects. In one embodiment, the JavaScript program is embedded in HTML documents in a Web browser. The browser is programmed to intercept the JavaScript code and pass execution control to an interpreter engine implemented in Java. The interpreter engine may access the program's library of host objects through an interface to the library and execute the intermediate representation to produce the desired results as programmed in the original JavaScript source program. The implementation of the interface enables the implementation of the interpreter engine to be independent from the implementation of the library of host objects and independent from the implementation of the browser.

INFORMATION

DETAILED DESCRIPTION OF THE INVENTION

While the invention is described herein by way of example for several embodiments and illustrative drawings, those skilled in the art will recognize that the invention is not limited to the embodiments or drawings described. It should be understood, that the drawings and detailed description thereto are not intended to limit the invention to the particular form disclosed, but on the contrary, the intention is to cover all modifications, equivalents and alternatives falling within the spirit and scope of the present invention as defined by the appended claims.

DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

A preferred embodiment of the present invention may be developed using the Java programming language as provided in the Java Development Kit (JDK), version 1.1.7 from Sun Microsystems.

Referring now to FIG. 2, in one embodiment, a JavaScript source program may be embedded in HTML . The HTML may be processed by a Web browser , such as Netscape Navigator or Microsoft Internet Explorer. A JavaScript tag in the HTML may be used to identify the beginning of the JavaScript code section within the HTML. Upon encountering a JavaScript tag , the Web browser may pass execution control to an interpreter engine . The interpreter engine may interpret the JavaScript code , execute it, and present the results to the user . Non-JavaScript code in the HTML may be executed by the Web browser .

The interpreter engine is further illustrated in FIG. 3, according to one embodiment. Once the Web browser has identified an input stream of JavaScript source code in the HTML document, the Web browser may pass processing control to a parser component of the interpreter engine. The parser may examine the syntax of the incoming JavaScript source code to produce a validated listing of JavaScript code before the code is translated by the interpreter. The parsed JavaScript code may then be processed by a representation generator component of the interpreter engine. The representation generator component takes as input the validated JavaScript code and produces an intermediate representation using a proprietary Java code equivalent of the JavaScript code . The intermediate Java code representation may then be interpreted by an interpreter component . The interpreter component may use a library interface to communicate with a JavaScript host objects library to execute the intermediate representation and produce desired results as programmed in the original JavaScript source program .

As one of ordinary skill in the art will appreciate, there are various methods by which a Web browser may be enabled to recognize the parser component as the appropriate subroutine to which the Web browser passes control upon encountering the JavaScript tag . One method is by placing “hooks” into the Web browser which instruct the browser to call certain entry point methods of the parser component when a JavaScript tag is encountered in the HTML code. The general method of placing such “hooks” in a Web browser by using the JDK Reflection API is well known to those of ordinary skill in the art. Other well-known methods of instructing one program to invoke another may be applied to instruct a Web browser to invoke the parser component . These methods include use of the “OnAction” keyword and “Form” tag.

In the preferred embodiment of the present invention, the parser component may be written using Java CC, a publicly available utility published by Metamata. Using the Java CC utility, the parser component may be written to accept the syntax (grammar) of the input language to be parsed, i.e., the JavaScript syntax. This enables the parser component to parse the input steam of JavaScript source code to ensure that the correct syntax is followed. The parser component produces a validated listing of JavaScript code . The parser may create Java objects based on what is parsed from the input stream of the JavaScript source code . The Java objects, which may contain field names and methods, may be stored using a technique such as hash tables. The use of hash tables may facilitate fast access of field names and methods during the entire process of interpreting and executing the JavaScript source code .

As stated above, a Java CC source file may define the JavaScript grammar in one embodiment. The following illustrates the creation of Java CC source file definitions and three related parser methods as used in the preferred embodiment of the present invention:

Once the parser has parsed the input stream of the JavaScript program , the parsed JavaScript code may be translated into an intermediate representation Java code by the representation generator component . The intermediate format of the preferred embodiment may be an arbitrary scheme that is similar to Java byte code. As one skilled in the art will appreciate, the intermediate format may be any scheme that adequately represents the input JavaScript code for execution by a JavaScript interpreter. The representation or intermediate format of the preferred embodiment is particularly suitable for execution by a stack-machine implemented interpreter written in Java. However, as one skilled in the art will readily appreciate, it is not required that the intermediate format be designed such that it may be executed by stack-machine implemented interpreter. Depending on the representation scheme used, alternatively designed interpreters may be used without departing from the present invention.

As stated above, the representation of the input JavaScript program may be accomplished using many different schemes. The preferred embodiment of the present invention demonstrates one representation scheme using Java classes and objects. Referring now to FIG. 4, a representation scheme example according to a preferred embodiment is illustrated. The input JavaScript source code sample is “Echo(“2+3:”+(2+));.” The JavaScript code performs the simple function of adding two numbers and displaying the result. Box shows a representation of the JavaScript code as it is accomplished in the preferred embodiment. More particularly, box lists logical commands representing the JavaScript code , and box lists Java objects and classes which correspond to the logical representations . Box illustrates the foregoing with Java program code. The representation generator may use a stack data structure to store the intermediate representation as Java objects. For example, the JavaScript function “Echo” is represented with two pushes on the stack data structure. First, the logical command “call” is pushed on the stack to indicate the presence of a function or method. Second, the name of the function “echo” is pushed on the stack. The Java object “call” is an instance of the Java class JvScFunctionalCall. Similarly, the Java object “echo” is an instance of the Java class JvScName, used for storing host objects. The names of host objects may be names of methods or functions which are called to perform specific functions. And similarly, Java classes, such as JvScOperator, JvScString and JvScNumber may be created to hold Java objects, such as the operator “add,” the string “2+3” and the integer “2” respectively. The parameters and commands in the intermediate representation may be Java objects.

Referring now to FIG. 5, box illustrates a hierarchy of the JavaScript runtime objects and its relationship to a hierarchy of library objects . The class JvScAtom may generally consist of a JvScOperator class and the JvScDatum class . The JvScOperator class may contain objects such as “MUL,” “ADD,” “CALL,” “GETFIELD” and “RETURN.” The JvScDatum class includes JvScName (e.g., name of a method or function), JvScNumber (e.g., the integer “2” used in an ADD operation) and JvScObject (which is inserted in the stack data structure discussed above). As stated above, the representation generator may use a stack data structure to store the intermediate representation as Java objects.

The stack used in the representation scheme of the preferred embodiment may be an array of Java objects. Each element of this array (stack) may be either a command or a parameter. Each element may derive from an abstract Java class with very generic functionality and may contain data pertaining to the operator or data type it represents, sufficient for a stack machine interpreter to perform actions equivalent to those specified in the original JavaScript program . The Java class to which an object in the array (stack) belongs, may determine whether the particular object is a command or a parameter. As one of ordinary skill in the art will appreciate, there are numerous methods of representing in memory the operators and the operands of a compiled program. In the preferred embodiment of the present invention, the logical representation uses the well-known Polish notation scheme.

The intermediate representation may have several advantages, such as a small memory footprint. Furthermore, the representation scheme of the preferred embodiment may enable faster execution of the JavaScript code by the interpreter component .

The following illustrates the representation generator component of the preferred embodiment and an associated representation scheme suitable for execution by a stack-machine implemented interpreter:

Once the representation generator has translated the parsed JavaScript code to produce the intermediate representation , the interpreter component may use the library interface to communicate with the JavaScript host objects library to execute the intermediate representation and produce the desired results , as programmed in the original JavaScript source program .

The interpreter may pop elements off the stack, executes them and places the result back on the stack. The interpreter may execute streams of Java objects (e.g., “push” and “2+3”) in the stack containing commands and parameters belonging to various Java classes (e.g., JvScOperator or JvScString). The interpreter may pop one or more elements off the stack depending on what instruction is being executed. For example, if an “ADD” operator is encountered, then the interpreter knows that it must pop two more elements which will form the operands for the “ADD” operation. The following illustrates the execution of the intermediate representation Java code by the interpreter , according to one embodiment:

Referring to FIG. 3, the interpreter component may use the library interface to communicate with the JavaScript host objects library to execute the intermediate representation . In a JavaScript program execution environment, there may be several functionally independent components. The JavaScript interpreter and the JavaScript library are two of the most important components. In a preferred embodiment, the JavaScript program execution environment may be implemented using the Java programming language. The preferred embodiment may provide a mechanism whereby host objects in a JavaScript library are accessible to the interpreter in an execution environment designed in Java.

The method and system of the preferred embodiment may provide an interface between the JavaScript interpreter and the JavaScript library objects , where both the interpreter and the library objects are written in Java. The interface enables the implementation of the interpreter to be independent of the implementation of the library objects . Furthermore, the implementation of the interpreter may be independent of the HTML browser in which it runs. The foregoing relationship between the interpreter, the library objects and the browser may make it possible to easily incorporate the interpreter in any Java-enabled browser with an arbitrary library objects implementation.

Still referring to FIG. 3, the library objects may be derived from abstract Java classes. The interpreter may use the JDK Reflection API for at least two purposes. First, the Reflection API may enable the interpreter to access specific information (such as properties) about known objects and classes in the library . Such information may include, for example, the availability of particular fields and methods within objects. Second, the Reflection API may enable the interpreter to execute methods if they are not privately protected. The interface may also enable manipulation of field values and call methods of an object. Additionally, fields and methods may be dynamically added or deleted in a class or object. The techniques of hash tables and the JDK Reflection API may be utilized to facilitate the foregoing processing.

One JavaScript standards specification requires five basic host objects that must be present in the local library of a JavaScript interpreter. All other objects that are called by a JavaScript program must be available in other libraries accessible to the JavaScript interpreter. The programmer of the JavaScript source code must know what objects, other than the five basic host objects, are accessible to the interpreter which will execute the JavaScript source code. The Web browser in which the JavaScript program runs may provide additional non-required host objects in its libraries. As one of ordinary skill in the art will appreciate, new fields and methods may be added or deleted to any object during run time.

As defined by a JavaScript standards specification, an object in JavaScript does not necessarily only bear traces of the class to which it belongs. The JavaScript object may have characteristics that are different from other objects belonging to the same class. Thus, objects in JavaScript may act as independent entities with methods and fields which may be different from the methods and fields in other objects belonging to the same class. However, objects in the same class may have certain basic methods and fields in common.

Still referring to FIG. 3, during the processing of the JavaScript source code in the preferred embodiment, the interpreter encounters fields and methods in the JavaScript program. The interpreter may create Java objects in a library containing the fields and the methods. However, as the input stream of JavaScript source code is processed, the interpreter may learn more information about fields and methods which it has previously encountered. The library interface may provide the interpreter the dynamic capability to update Java objects and their related properties or attributes.

In an embodiment, the library interface may have three primary Java methods through which any interaction with an object is carried out. The three primary Java methods may be “get field,” “set field” and “invoke method.” These methods may be used in conjunction with JavaScript objects and classes whose methods and fields are known to the JavaScript library , but not known to the interpreter . The Reflection API may be used to access the JavaScript library and thus inform the interpreter about methods and fields contained in any particular object.

The JavaScript library may contain a static set of predefined objects containing methods and fields. In one embodiment, all objects within the input stream of JavaScript source code must exist in the JavaScript library . However, certain objects within the JavaScript source code may contain methods and fields which are not known to the JavaScript library . When this occurs, the JavaScript library may be dynamically updated with the new methods and fields. Similarly, the interpreter may need to be aware of the new methods and fields. The dynamic update of the library may be accomplished with the use of hash tables. In a preferred embodiment, the JavaScript library may include a hash table for each object. Initially, the hash table for each object may be empty. When the input JavaScript program introduces a new method or field, an entry may be created in the hash table corresponding to the new method or field. The name of the new method or field may be used as the key to the hash table entry. The key serves as the means by which the new method or field may be accessed to acquire information about the method or field. For methods, the information to be accessed may be the code section associated with the new method, and for fields, the information to be accessed may be the data holder or the field value. The interpreter may access the hash tables to get values of the new fields and to execute the code associated with the new methods.

The newly added fields and methods in the hash tables may remain available to all JavaScript program and interpreter invocations so long as the current session of the HTML browser is running. Once the HTML browser is closed, the newly updated methods and fields in the hash tables may be lost and therefore, the methods and fields may not be available to future JavaScript program and interpreter invocations in a subsequent session of the HTML browser. The clearing of the new methods and fields in the hash tables at the end of an HTML browser session may be done pursuant to a JavaScript standards specification.

In the preferred embodiment the source code associated with the newly added methods is not compiled when a reference to it is stored in the hash table. Instead, an intermediate representation is stored within the engine. This technique may solve certain problems encountered by the prior art. Some prior art methods compile the source code associated with the newly added methods and store the new source code in object code format for future use. The prior art technique is not efficient because it uses large amounts of memory to store the compiled object code and uses valuable processing time to convert the source code to object code. In the present invention, these problems may be overcome by storing an intermediate representation of the original JavaScript syntax.

The present invention does not require that the library host objects (and their associated methods) be written in Java. The objects and methods may be native code but the entry point is written in Java, in a preferred embodiment, because in the preferred embodiment the interpreter may require methods to have a Java entry point so that the interpreter can call on such routines.

One desirable attribute of the present invention may be the independence and interchangeability of the JavaScript library . The preferred embodiment may include one implementation of the JavaScript library . This implementation may be written in Java based on a JavaScript standards specification. The JavaScript library may be independent of the interpreter . Therefore, any other implementation of the JavaScript library may be easily substituted for the library used in the preferred embodiment. As mentioned previously, both the interpreter and the JavaScript library may also be independent of the HTML browser. The independence and interchangeability of the JavaScript library may permit customization of the library to different environments, such as through the addition of objects, and their corresponding methods and fields, that may be better suited to certain HTML browsers.

The following illustrates how the interpreter component may use the library interface to communicate with the JavaScript host objects library to execute the intermediate representation , according to one embodiment:

Although the forgoing description has focused on Java implementations, other similar programming languages may be used as well. Any of the foregoing embodiments may be implemented by programming a suitable general-purpose machine having appropriate hardware. The machine may comprise a single computer or computing device. Alternatively, the machine may comprise a plurality of computers or computing devices connected by a communications link.

Various embodiments may further include receiving, sending or storing instructions and/or data implemented in accordance with the foregoing description upon a carrier medium. Generally speaking, a carrier medium may include storage media or memory media such as magnetic or optical media, e.g., disk or CD-ROM, volatile or non-volatile media such as RAM (e.g. SDRAM, DDR SDRAM, RDRAM, SRAM, etc.), ROM, etc. as well as transmission media or signals such as electrical, electromagnetic, or digital signals, conveyed via a communication medium such as network and/or a wireless link.

It will be appreciated by those of ordinary skill having the benefit of this disclosure that the illustrative embodiments described above are capable of numerous variations without departing from the scope and spirit of the invention. Various modifications and changes may be made as would be obvious to a person skilled in the art having the benefit of this disclosure. It is intended that the following claims be interpreted to embrace all such modifications and changes and, accordingly, the specifications and drawings are to be regarded in an illustrative rather than a restrictive sense.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a flow diagram of a typical method of interpreting JavaScript programs;

FIG. 2 is a flow diagram illustrating one embodiment of interception of JavaScript code in HTML for execution by a Java-based JavaScript interpreter;

FIG. 3 is a flow diagram illustrating an embodiment of various components for interpreting JavaScript programs;

FIG. 4 illustrates a method according to one embodiment for converting JavaScript code to an equivalent intermediate representation; and

FIG. 5 illustrates the hierarchy of the JavaScript runtime objects and its relationship to the hierarchy of library objects, according to one embodiment.

CLAIMS

1. A method, comprising: detecting one or more script language instructions in a document; generating a platform-independent programming language representation of the one or more script language instructions, wherein the platform-independent programming language representation of the one or more script language instructions is different from the script language; and interpreting and executing each of one or more instructions of the platform-independent programming language representation, wherein said interpreting and executing comprises: interfacing with an object library comprising a plurality of program objects; and accessing one or more of the plurality of program objects, wherein the one or more accessed program objects are used to implement the one or more instructions of the platform-independent programming language representation; wherein said interpreting and executing produces results in accordance with the original one or more script language instructions.

2. The method as recited in claim 1, wherein said detecting is performed by a Web browser, and wherein said generating, said interpreting and executing, and said interfacing with an object library are performed by an interpreter engine.

3. The method as recited in claim 2, wherein the interpreter engine interfaces with the object library through an object library interface external to the Web browser and the interpreter engine.

4. The method as recited in claim 2, wherein the one or more instructions of the platform-independent programming language representation are stored in a stack data structure, wherein the interpreter engine is a stack-machine interpreter engine that pops the one or more instructions off the stack data structure during said interpreting and executing.

5. The method as recited in claim 1, wherein said generating a platform-independent programming language representation of the one or more script language instructions comprises validating that the one or more script language instructions conform to script language syntax.

6. The method as recited in claim 1, wherein said generating a platform-independent programming language representation of the one or more script language instructions comprises modifying a first of the one or more program objects.

7. The method as recited in claim 6, wherein said modifying the first program object comprises adding at least one of methods and fields to the first program object.

8. The method as recited in claim 1, wherein the script language is JavaScript.

9. The method as recited in claim 1, wherein the document is a markup language document.

10. The method as recited in claim 9, wherein the markup language is Hypertext Markup Language (HTML).

11. The method as recited in claim 1, wherein said detecting is performed by a Java-based Web browser executing within a Java Virtual Machine.

12. The method as recited in claim 1, wherein the platform-independent programming language is the Java programming language.

13. The method as recited in claim 1, wherein the plurality of program objects includes Java programming language objects.

14. A system, comprising: a processor; a memory coupled to said processor and operable to store program instructions; and an object library comprising a plurality of program objects; wherein the program instructions are executable by the processor to execute a script comprising one or more script language instructions; wherein, in said executing the script, the program instructions are further executable by the processor to: generate a platform-independent programming language representation of the script, wherein the platform-independent programming language representation of the one or more script language instructions is different from the script language; and interpret and execute each of one or more instructions of the platform-independent programming language representation; wherein, in said interpreting and executing, the program instructions are further executable by the processor to: interface with the object library to access one or more of the plurality of program objects, wherein the one or more accessed program objects are used to implement the one or more instructions of the platform-independent programming language representation; and wherein said interpreting and executing produces results in accordance with the original one or more script language instructions.

15. The system as recited in claim 14, wherein the script language is JavaScript.

16. The system as recited in claim 14, wherein the script is embedded in a markup language document.

17. The system as recited in claim 14, wherein said executing the script is performed by an interpreter engine executing within a Java Virtual Machine.

18. The system as recited in claim 14, wherein the platform-independent programming language is the Java programming language, and wherein the plurality of program objects are Java programming language objects.

19. A system, comprising: a device, comprising: a processor; a memory coupled to said processor and operable to store program instructions implementing a first process and a second process; an object library comprising a plurality of program objects and accessible to processes executing within the device through an object library interface; wherein the first process is executable within the device to: detect one or more script language instructions in a document; and pass execution to the second process in response to said detecting; wherein the second process is executable within the device to: generate a platform-independent programming language representation of the detected one or more script language instructions, wherein the platform-independent programming language representation of the one or more script language instructions is different from the script language; and interpret and execute each of one or more instructions of the platform-independent programming language representation; wherein, in said interpreting and executing, the second process is further executable to access one or more of the plurality of program objects in the object library through the object library interface to implement the one or more instructions of the platform-independent programming language representation; wherein said interpreting and executing produces results in accordance with the original one or more script language instructions.

20. The system as recited in claim 19, wherein the object library and the object library interface are external to the first process and the second process.

21. The system as recited in claim 19, wherein the system further comprises a Java Virtual Machine executable within the device, and wherein the first process is a Java-based Web browser executable within the Java Virtual Machine, and wherein the second process is a JavaScript interpreter engine executable within the Java Virtual Machine.

22. The system as recited in claim 19, wherein the one or more instructions of the platform-independent programming language representation are stored in a stack data structure, wherein the interpreter engine is a stack-machine interpreter engine that pops the one or more instructions off the stack data structure during said interpreting and executing.

23. The system as recited in claim 19, wherein, in said generating a platform-independent programming language representation of the one or more script language instructions, the second process is further executable to add at least one of fields and methods to at least one of the one or more program objects.

24. The system as recited in claim 19, wherein the document is a markup language document.

25. The system as recited in claim 19, wherein the platform-independent programming language is the Java programming language.

26. The system as recited in claim 19, wherein the plurality of program objects includes Java programming language objects.

27. A system, comprising: an object library comprising a plurality of platform-independent programming language objects; an object library interface configured to provide access to the plurality of platform-independent programming language objects in the object library to processes within the system; a first process configured to interpret and execute each of one or more instructions of a platform-independent programming language representation of a sequence of script language instructions, wherein the platform-independent programming language representation of the one or more script language instructions is different from the script language; wherein, in said interpreting and executing, the first process is further configured to access one or more of the plurality of platform-independent programming objects in the object library through the object library interface to implement the one or more instructions of the platform-independent programming language representation; wherein said interpreting and executing produces results in accordance with the sequence of script language instructions.

28. The system as recited in claim 27, wherein the first process is further configured to generate the platform-independent programming language representation from the sequence of script language instructions prior to said interpreting and executing.

29. The system as recited in claim 27, wherein the system further comprises a Java Virtual Machine, wherein the script language is JavaScript, and wherein the first process is a JavaScript interpreter executable within the Java Virtual Machine.

30. The system as recited in claim 27, wherein the platform-independent programming language is the Java programming language.

31. A carrier medium comprising program instructions, wherein the program instructions are computer-executable to implement: detecting one or more script language instructions in a document; generating a platform-independent programming language representation of the one or more script language instructions, wherein the platform-independent programming language representation of the one or more script language instructions is different from the script language; and interpreting and executing each of one or more instructions of the platform-independent programming language representation, wherein said interpreting and executing comprises: interfacing with an object library comprising a plurality of program objects; and accessing one or more of the plurality of program objects, wherein the one or more accessed program objects are used to implement the one or more instructions of the platform-independent programming language representation; wherein said interpreting and executing produces results in accordance with the original one or more script language instructions.

32. The carrier medium as recited in claim 31, wherein said detecting is performed by a Java-based Web browser executing within a Java Virtual Machine, wherein the script language is JavaScript, and wherein said generating, said interpreting and executing, and said interfacing with an object library are performed by a JavaScript interpreter engine executable with the Java Virtual Machine.

33. The carrier medium as recited in claim 32, wherein the JavaScript interpreter engine interfaces with the object library through an object library interface external to the Java-based Web browser and the JavaScript interpreter engine.

34. The carrier medium as recited in claim 31, wherein said generating a platform-independent programming language representation of the one or more script language instructions comprises adding at least one of fields and methods to at least one of the one or more program objects.

35. The carrier medium as recited in claim 31, wherein the platform-independent programming language is the Java programming language, and wherein the plurality of program objects includes Java programming language objects.

COPYRIGHT

User acknowledges that Fairview Research and its third party providers retain all right, title and interest in and to this xml under applicable copyright laws. User acquires no ownership rights to this xml including but not limited to its format. User hereby accepts the terms and conditions of the License Agreement.