WO2001027754A2

WO2001027754A2 - Compressed storage and transmission of high-level computer languages

Info

Publication number: WO2001027754A2
Application number: PCT/US2000/025403
Authority: WO
Inventors: Yuval Fisher
Original assignee: Conexant Systems, Inc.
Priority date: 1999-10-13
Filing date: 2000-09-14
Publication date: 2001-04-19
Also published as: WO2001027754A9; AU7829400A; WO2001027754A3

Abstract

A system and method for compressing source code representations of platform-independent programs for storage, execution and transmission. In one embodiment MPEG-4 scripts are compressed before being transmitted to and executed on client computer systems. A recursive syntax description language is used to represent the high level computer language. In one example embodiment, BNF is used as a representation of the high level computer language. A parse-tree is created from the recursive syntax description language. The parse-tree shows all possible expansions of a program in accordance with the recursive syntax description language. Each script or computer program written in the high level language is represented by a subset of the parse-tree. Each multiple path branch is pre-assigned a unique binary sting value. A specific parse-tree of a program corresponds to a sequence of binary strings that represents specific branches selected from the tree of all possible parses, following a depth first transversal of the parse-tree. The encoded binary string is used to transmit, store and execute the computer program or script.

Description

COMPRESSED STORAGE AND TRANSMISSION OF HIGH-

LEVEL COMPUTER LANGUAGES

Background of the Invention

Field of the Invention

The present invention relates generally to compressed storage and transmission of high- level computer languages and more particularly to a system and method for representing a computer program written in a high-level language in a highly compressed format that is suitable for execution, storage and transmission.

Related Art

Many of today's platform independent computer programs are written using a high-level computer language. These computer programs differ from conventional computer programs in several ways. For example, conventional programs written using a high-level language, such as 'C or 'C+ + ', are typically compiled or assembled. The end result of the compiled or assembled program is an executable program comprising platform-dependent machine code.

Advantageously, the machine code is in a compressed format that generally takes up less storage space than the high-level source code, which is no longer needed for program execution. Thus, an advantage to using this method is that the more compressed executable code is better suited for storage and/or transmission purposes. For example, the executable version of the code takes up less storage space in computer storage devices and consumes less bandwidth when transmitted over computer networks, such as the Internet, than does the source version of the code. The disadvantage to using this method is that the programs are not platform independent. That is, these programs typically require a particular operating system and/or a particular microprocessor (or other hardware dependency) to run. Typically, in order to allow the program to run on different platforms, a separate executable program is generated for each platform. A further disadvantage is that these platform-dependent programs may no longer run properly when the operating system is revised and/or the machine configuration is altered.

To alleviate these disadvantages, many modern high-level computer program languages are designed to be platform-independent.. For example, ECMAScript is a computer language that is designed to run on many platforms. A program written in ECMAScript can be executed on any type of computer system that has an appropriate browser installed. Thus, any computer system, running any operating system, such as Windows, Macintosh, Unix, or Linux, can run these ECMAScript programs, as long as an appropriate browser, such as Netscape Navigator or Microsoft Explorer is installed. HTML is another example of a high-level content description language that is platform-independent.

The problem is that many of these platform-independent programs must remain in their source-code state for storage, execution and transmission. That is, unlike conventional programs, where a more compressed version of the program is typically stored and transmitted over computer networks and the like, the larger and more inefficient source code version of the platform-dependent programs must be maintained. The source code requires more space and network bandwidth then its executable code counterpart using conventional programming techniques. Thus, what is required is a system and method for compressing source code representation of platform-independent programs for storage, execution and transmission purposes. Summary of the Invention

Accordingly, the present invention provides a system and method for compressing source code representations of platform-independent programs for storage, execution and transmission. The present invention is applicable to any high-level computer language. That is, the present invention can be used to produce a compressed version of any computer program written in any high-level computer language. The compressed version is then used, rather than the non-compressed version, for any purpose, such as storing, transmitting or executing the program.

In one embodiment of the present invention, MPEG-4 scripts are compressed before being transmitted to and executed on client computer systems, such as set-top boxes and the like. In this example embodiment, a Backus Naur Form (BNF) representation of the high level script language (in this example, ECMAScript), is used to encode an MPEG-4 script. In one example, a parse-tree structure is created based on the BNF grammar representation. The parse-tree shows all possible expansions of an ECMAScript in accordance with the BNF grammar description.

Each script or computer program written in the high level language can then be represented by a subset of the parse-tree. Each branch in the parse-tree is pre-assigned a unique binary string. That is, for example, if a particular node has 4 branches, they are labeled: "00", "01", " 10" and "11" . In one embodiment, nodes that have only one branch are not labeled with a binary string to save space during storage and/or transmission. That is, when the BNF grammar allows for only one parsing rule to be selected for expansion, that branch has no label because there is no need to encode that particular selected branch. In this example, when the decoder encounters a node with only one selection, that branch is automatically selected. Accordingly, each specific program parse-tree corresponds to a sequence of binary strings that selects specific branches from the complete parse-tree, in one embodiment, a depth first transversal is used. Storing a representation of the ECMAscript in this fashion, not only saves storage space, transmission bandwidth and transmission time, but also facilitates execution of the program by executing a pre-parsed version of the program.

Brief Description of the Figures

The present invention is described with reference to the accompanying drawings, wherein:

FIG. 1 is a diagram depicting an example operational environment according to one embodiment of the present invention.

FIG. 2 is a diagram depicting the details of the MPEG-4 Renderer according to one embodiment of the present invention.

FIG. 3 is a diagram depicting a program structure that is useful for describing the encoding and decoding aspects according to one embodiment of the present invention.

FIG. 4 is a diagram depicting a section of BNF code of a high-level computer language according to one embodiment of the present invention.

FIG. 5 is a diagram showing a parse-tree in accordance with one embodiment of the present invention.

FIG. 6 is a diagram showing a parse-tree in accordance with one embodiment of the present invention.

FIG. 7. is a flowchart depicting a recursive encoding process in accordance with one embodiment of the present invention.

FIG. 8 is a general computer that can be used to implement portions of the present invention.

In the figures, like reference numbers generally indicate identical, functionally similar, and/or structurally similar elements.

Detailed Description of the Preferred Embodiments

The present invention is applicable to any high-level computer language. That is, the present invention can be used to produce a compressed version of any computer program written in any high-level computer language. The compressed version is then used, rather than the non-compressed version, for any purpose, such as storing, transmitting or executing the program. A particular embodiment of the present invention is described in the examples below.

These examples use MPEG-4 scripts as the example high-level language. However, after reading the disclosure, it would be apparent to persons skilled in the relevant art(s), that these principles can be applied to any high-level computer language. Accordingly, the use of the exemplary embodiment involving MPEG-4 scripts should not be construed to limit the scope and breadth of the present invention.

FIG. 1 is a diagram depicting an example operational environment according to one embodiment of the present invention. In this example embodiment, a broadcast server 4 is coupled to a client 2 via a communication link 8. The communication link can be any type of communication link such as a direct wired connection, a wireless radio or other wireless connection, a computer network, such as a LAN, WAN or combination thereof, a private network, and/or a public network such as the Internet or the like. In this example, the broadcast server 4 transmits data, including audio, video, three- dimensional scene data, and program scripts to the client 2. The program scripts are computer programs written in a high-level computer language. In this example, the high-level computer language is called ECMAscript.

The client, in this example, is a set-top box or any type of computer system, such as a general-purpose computer system or the like. The primary component in the client 2 of interest in this example, is the MPEG-4 renderer 6. In this example, MPEG-4 data sent by the broadcast server 4, is a data stream of multi-media content, comprising audio, video, three- dimensional scene and script data. The script data provides programmed information and is used to provide users with interactive capabilities, such as movie selection, language selection, or any other user interaction.

Details of the example MPEG-4 renderer 6 is shown in FIG. 2. In this example, the

MPEG-4 renderer comprises 4 components, namely the 3D component 20, the video component 22, the audio component 24 and the script component 26. The 3D component 20 decodes data streams and renders three-dimensional scenes on a display device (not shown), such as a television set or a computer display device. The video component 22 is used to decode a stream of video information and render it on the display device. The audio component is used to decode audio data and render it on an audio device (not shown). The script component 26, in this example, is used to execute program scripts on the client 2.

In accordance with the example embodiment of the present invention, these scripts are written in ECMAScripts and are part of the MPEG-4 standard. In accordance with the present invention, the ECMAScripts are represented in a compressed format to reduce transmission bandwidth, storage and transmission-time requirements. In addition, the compressed format of the ECMAScripts facilitates script execution by the script component 26. Specifically, the decoder module 28 is used to decode the compressed ECMAScript in accordance with the principles described below.

FIG. 3 is a block diagram depicting a typical generic computer program written in a high-level language. As shown, the program 30 can be represented in a hierarchical fashion. The program component 30 represents the root of the hierarchical tree. The next level of nodes in the hierarchy of a typical program are functions 32-38. Functions can be further broken down into one or more statements 48-54. In this example, 4 types of statements are shown, an IF statement 48, a WHILE statement 50, a FOR statement 52, and an ASSIGNMENT statement 54. The last level of the tree, shows the actual syntax of each type of statement. For example, the IF statement 48 comprises the word "if" followed by an open parenthesis "(", followed by some type of condition (defined elsewhere), followed by a closed parenthesis ")" , followed by an open curly bracket "{" , followed by a compound statement

(defined elsewhere), followed by a closed curly bracket "}". Similarly, the syntax for an assignment statement 54 is defined as LEFTVAL = EXPRESSION. Both LEFTVAL and

EXPRESSION are defined elsewhere (not shown) .

A well known method for describing high-level languages, referred to as Backus Naur

Form or BNF, will now be used to describe the coding and decoding methods in accordance with a preferred embodiment of the present invention. An example of a BNF description of ECMAScript is shown in FIG. 4. A more complete BNF description is shown below, after the description of FIG. 4.

Referring now to FIG. 4, the first set of lines 80 define a script. In this example, a script is the equivalent of a program 30 and represents the root node of the hierarchical tree. In this example, a script comprises "funcs" or an empty (null) string. Note that the vertical line represents a choice (i.e. an OR function) in BNF.

As shown by section 82, "funcs" can either comprise a single "func" or a "func" and

"funcs" . Note the recursive nature of this description. This very compressed format tells one skilled in the art that a script may comprise an empty string 80 or one or more functions (i.e. func), where the number of functions in which the script can comprise is unlimited, due to the recursive nature of the BNF description.

Next, "func" is defined in line 84. In this example, a "func" is defined as the word "FUNCTION" followed by something called "bgnFunc" (defined below) , followed by an open parenthesis "(" followed by something called "args" (defined below), followed by closed parenthesis ")" , followed by something called stmntblk (defined below). Note that part of this description comprises the actual syntactical representation of a function, namely the word "FUNCTION" and the open and close parenthesis. The lower case words or "tokens" are defined elsewhere in the BNF description.

Next as shown in line 85, the "bgnFunc" token is defined as "IDENTIFIER". In this example, the IDENTIFIER is a constant user defined string. Next, as shown in line 86, the token "args" is defined. In this example, "args" may comprise either "args" followed by a COMMA, followed by an IDENTIFIER, or just an IDENTIFIER or, an empty string.

Next, as shown by section 88 a "stmntblock" is defined as an open curly bracket, followed by "stmnts" followed by a closed curly bracket. Alternatively, a "stmntblock" can comprise an empty string or a single "stmnt" .

As shown by section 90, "stmnts" is defined as "stmnts" followed by "stmnt" or a single "stmnt" or "stmnts error" . Next as indicated by section 92, "stmnt" is defined as an

"if", "for", "while", "comma_expr ';' ", "return ';' ", "with", "break ';'" or "continue';'".

Next as shown by section 94, return is defined as the word "RETURN" followed by "comma_expr" or just the word "RETURN" . Finally, as shown by section 96, the "if" statement is defined as the word "IF" followed by an open parenthesis, followed by "comma_expr" followed by closed parenthesis, followed by the token "stmntblk" , which is defined above. Alternatively, an "if" statement may comprises an the word "IF" followed by an open parenthesis, followed by "comma_expr" followed by closed parenthesis, followed by the token "stmntblk" , followed by the word "ELSE" followed by "stmntblk" . Persons skilled in the art will recognize that an entire high-level language can be described in this fashion. Listed below, is a more complete BNF description of the example high-level script language ECMAScript.

Table 1 BNF Description of MPEG-4 ECMAScript implementation start script

/* general structure */ script : funcs 1 /* empty * / ; funcs funcs func 1 func; func : FUNCTION bgnFunc '(' args ') ' stmntblk; bgnFunc : IDENTIFIER; args : args COMMA IDENTIFIER

1 IDENTIFIER 1 /* empty */; stmntblk : ' { ' stmnts ' } '

1 1 ' '

1 stmnt; stmnts : stmnts stmnt

1 stmnt

1 stmnts error; stmnt if 1 for 1 while 1 comma expr ' ; '

1 return ' ; ' 1 with break ' ; '

1 continue ' ; ' ; return : RETURN comma expr I RETURN; if : IF ' ( ' comma_expr ' ) ' stmntblk

I IF ' (' comma_expr ')' stmntblk ELSE stmntblk; for : FOR ' ( ' opt_expr ' ; ' opt_expr ' ; ' opt_expr ' stmntblk

I FOR ' ( ' var IN expr ' ) ' stmntblk; break : BREAK; continue : CONTINUE; with : WITH ' ;xpr stmntblk; while : WHILE comma expr ' ) ' stmntblk;

I /* empty */; comma_expr: expr

I expr COMMA comma_expr; expr : ' ( ' comma_expr ' ) ' I MINUS expr %prec NOT

I NOT expr

I ONESCOMP expr

I leftvar ASSIGN expr

I leftvar PLUSEQ expr

1 leftvar MINUSEQ expr

I leftvar MULTIFLYEQ expr

1 leftvar DIVIDEEQ expr

1 leftvar MODEQ expr

I leftvar ANDEQ expr

1 leftvar OREQ expr

I leftvar XOREQ expr

I leftvar LSHIFTEQ expr

I leftvar RSHIFTEQ expr

I leftvar RSHIFTFILLEQ expr

I INCREMENT expr I DECREMENT expr I expr INCREMENT I expr DECREMENT

I expr CONDTEST expr CONDSEP expr expr EQ expr expr NE expr expr LT expr expr LE expr

I expr GE expr expr GT expr expr LAND expr expr LOR expr expr PLUS expr expr MINUS expr expr MULTIPLY expr expr DIVIDE expr expr MOD expr expr AND expr expr OR expr expr XOR expr expr LSHIFT expr expr RSHIFT expr expr RSHIFTFILL expr STRING NUMBER objmethodcall funccall objmembe access arrayderef var ; params : params COMMA expr

1 expr

I /* empty ⁺ / / /. funccall : IDENTI FIER ' ( ' params ' ) ' ; objmethodcall : expr DOT IDENTIFIER ' (' params ' ) ' ; leftvar : objmemt eraccess

I arrayderef

I var; objmemberaccess : expr DOT IDENTIFIER; arrayderef : expr RIGHTBRACKET comma_ expr LEFTBRACKET;

var : IDENTIFIEF

FIG. 5 is an example of a simple script that is useful for describing the encoding and decoding technique in accordance with one embodiment of the present invention. Block 100 depicts a simplified script comprising two functions. This script can be encoded by referring to the above BNF description of the language and coding an ordinal that represents the path taken at each node. FIG. 5 shows a graphical representation of this method.

As shown, the root node is the script node 110. As indicated by the above BNF description of this example high-level language, a script 110 comprises either "funcs" or an empty string. In this example, a one bit ordinal can be used to describe this path. In this case, "0" can be used to represent the case where the script 110 comprises "funcs" and " 1 " can be used to represent the case where the script 110 comprises a null string. As shown, the paths not taken is represented by the dotted lines in the script tree 110. In this example, the path shown the script node 110 to the funcs node 112 is completely described by the single bit value "0" .

As should be appreciated by those skilled in the relevant art(s), the entire script 100 can be described in this fashion. Thus, the compressed format of the script in accordance with an embodiment of the present invention comprises a sequence of bits. The sequence of bits are decoded by the decoder 28 and used to reconstruct the original program. This method of encoding consumes considerably less computer memory than conventional representations of computer source code programs. Thus a recursive method that performs the following steps can be used to reconstruct the entire program. This recursive method is shown in FIG. 7.

Fig. 6 is an example that of a parse-tree Structure in accordance with an embodiment of the present invention. This is a parse-tree which shows all possible expansions in accordance with the BNF grammar description of the ECMAScript language. The program, shown in block 140 is a subset the tree of all possible expansions. In addition, this figure shows the actual encoding that can be used to describe the program 140.

As shown, each branch of this tree is labeled with a unique binary string. In this example, the path taken to reconstruct the first function in the script 140 is shown in bold fonts.

It should be noted that when a node has only one branch - that is, when the BNF grammar allows only one parsing rule to be selected for expansion, the branch has no label. Similarly, when this occurs, there is no need to encode a bit string.

A specific parse-tree of a program corresponds to a sequence of binary strings that selects specific branches from the tree of all possible parses, following a depth first transversal of the parse-tree. In the parse-tree shown in FIG. 6, ellipsis are used to denote portions of the tree that are not continued. The tree contains the specific instantiations of IDENTIFIER for the script 140.

The root node is the script node 142. Next, as shown, a one bit value is used to describe the selected path. That is a "0" is used because the script 140 contains func. A " 1" would have been used to encode the script 140, if it merely contained an empty string. Thus, in this example, as shown by the bold font under block 144, the first bit in the compressed program representation is a "0" because the script is non-empty. Next, as shown, block 144 expands to block 146 ( uncs func). Therefore, as shown a "0" is used as the next bit in the bit stream used to represent the script 140. Next, a " 1 " is used to expand the funcs 146 into func 160. Next, as shown, there is no need to encode the path from func 160, as only one path is possible, namely the expansion to block 168 (bgnfunc, args, and stmntblk). From there, starting from left to right, the identifier "a" is encoded into the bitstream. This is followed by a "00" which identifies the path from args 168 to block 172 (args, identifier).

Note that in a preferred embodiment, the smallest number of bits that can be used to describe the path are encoded. For example, because node 140 only has two choices, one bit is used to describe the selected choice. Similarly, as shown, the arg node 152 has three possible choices, therefore, two bits are used to describe the selected choice. This logic is built into both the encoder and decoder and is based on the number of choices as defined by the BNF description of the language.

Next, as shown, the bitstream is encoded with "01" to indicate the path from block 172 (args) to identifier 176. Next, as shown, the letter "x" is encoded into the bit stream indicate the value for the identifier 176.

Next, as shown, the "y" is encoded into the bitstream to indicate the value of the 172 identifier. This completes the representation for the declaration of the first function in the script 140. The representation for the script body is not shown. The bitsteam, as shown comprises the following information "0 0 1 a 00 01 x y ", where the letters a x and y are encoded in any fashion desired in accordance with each specific embodiment of the present invention.

The next function in the script 140, is encoded in a similar fashion. As should be apparent to persons skilled in the relevant art(s), in a preferred embodiment, a recursive algorithm is used that performs a depth-first transversal of the parse-tree in which, for example, the left most node is selected first and fully expanded before the other nodes are processed in the recursive algorithm.

As stated, storing a representation of the ECMAscript in this fashion, not only saves storage space, transmission bandwidth and transmission time, but also facilitates execution of the program. For example, many computer languages, whether interpreted or compiled are typically parsed. Thus, having the program pre-parsed, in the above fashion, results in a more efficient execution of the program because the parsing step does not have to be repeated

FIG. 7 is a flowchart depicting a recursive encoding process in accordance with one embodiment of the present invention.

The process begins with step 130, where a BNF or equivalent description of the high- level language is created. Next, as shown in step 132, the next node is parsed. As indicated by step 134, each possible path is assigned a particular number. The number of bits used to describe each path is selected such that the minimal number of bits are used to conserve storage space. Next, as indicated by step 136, the selected path number is encoded into the bit stream and stored on a storage device. This can also involve encoding a character or other information into the bit stream. Next, as indicated by step 138, the process recursively calls itself until all nodes have been processed. The end result is a bit stream that is a compressed representation of the script or high-level program.

Example implementation

The following is an example of a specific implementation of the present invention. This example is used for exemplary purposes only and should not be construed to limit the scope and breadth of the present invention which can be used to compress any type of high-level computer language.

Description of encoded bit stream The script itself is encoded using an efficient bit stream syntax. For example, the minimal number of bits are assigned to each choice in the BNF grammar for an ECMAscript.

These bits are then sent, to the client 6, following the selection of BNF statement during parsing of the script. In one embodiment, an exception to this is made for both numeric and string constant values. For example, numeric values can be stored as floats, using any acceptable method of encoding floating point numbers.

String constants may be stored as null terminated character sequences. Identifiers can be optionally sent as string constants (during their first reference, with subsequent occurrences using numerical back reference). Alternatively, string constants may be stored as numerical references, in which case the identifier names are lost in the encoding.

In one embodiment, it may be desirable to add one more "escape" choice to which we assign value 0 for each choice in the BNF grammar. This would provide a mechanism to allow for future changes. This value can be used as an escape mechanism to read some yet-to-be- decided number of bits that specify other choices in the grammar.

Syntax

Example Decoding Function

The following is an example of a algorithm that can be used to decode a script in accordance with a prefen-ed embodiment of the present invention. The pseudo code below uses a language similar to the SDL (scene description language), as used in the MPEG-4 standard. The code is self explanatory and would be apparent to persons skilled in the relevant art(s) .

Syntax

class EncodedScript { bit (1 ) hasFunction while (hasFunction) { Function function; bit (1 ) hasFunction

} class Function {

Identifier identifier; Arguments arguments; StatementBlock statementBlock; }

class Arguments { bit (1 ) hasArgument while (hasArgument) { Identifier identifier; bit (1 ) hasArgument

} } class StatementBlock { bit (1 ) isCompoundStatement if (isCompoundStatement) { bit (1 ) hasStatement while (hasStatement) { Statement statement; bit (1 ) hasStatement

} } else {

Statement statement; }

} class Statement { bit (3) statementType switch statementType { case ifStatementType:

IFStatement ifStatement; break; case forStatementType: FORStatement forStatement; break; case whileStatementType:

WHILEStatement whileStatement; break; case returnStatementType: RETURNStatement returnStatement; break; case compoundExpressionType:

CompoundExpression CompoundExpression; break; case breakStatementType: case continueStatementType: break;

}

} class IFStatement {

CompoundExpression compound Expression; StatementBlock statement Block; bit (1 ) has ELSEStatement if (has ELSEStatement) {

StatementBlock statementBlock; } } class FORStatement {

OptionalExpression optionalExpression;

StatementBlock statementBlock; }

class WHILEStatement {

CompoundExpression CompoundExpression; StatementBlock statementBlock; }

class RETURNStatement { bit (1 ) retumValue if (returnValue) { CompoundExpression CompoundExpression;

} } class CompoundExpression { do { Expression expression; bit (1 ) hasExpression } while (hasExpression);

} class optionalExpression { bit (1 ) hasCompoundExpression if (hasCompoundExpression) {

CompoundExpression CompoundExpression;

} }

class Expression { bit (6) expressionType switch expressionType { case curvedExpressionType: // (CompoundExpression)

CompoundExpression CompoundExpression; break; case negativeExpressionType: // -expression case notExpressionType: // lexpression case onescompExpressionType: // -expression case incrementExpressionType: // ++expression case decrementExpressionType: // --expression case postlncrementExpression Type: // expression++ case postDecrementExpression Type: // expression — Expression expression; break; case conditionExpressionType: // expression ? expression : expression

Expression expression; Expression expression;

Expression expression; break; case stringExpressionType: String string; break; case numberExpressionType: Number number; break; case variableExpressionType:

Identifier identifier; break; case functionCallExpressionType: case objectConstructExpressionType:

Identifier identifier;

Params params; break; case objectMemberAccessExpressionType:

Expression expression;

Identifier identifier; break; case objectMethodCallExpressionType:

Expression expression;

Identifier identifier;

Params params; break; case arrayDereferenceExpressionType:

Expression expression;

CompoundExpression CompoundExpression; break; default: // =, +=, -=, ^*=, /=, %=, &=, |= ^Λ= «=, »=, >»=, // ==, !=, <, <=, >, >=, +, -, ^*, /, %, &&, ||, &, I, // ^Λ, «, », >»

Expression expression;

}

} class Params { bit (1) hasParam while (hasParam) {

Expression expression; bit (1 ) hasParam

} } class Identifier { bit (1 ) received if (received) { bit (num) identifierCode // num is calculated by counting

// number of distinguished identifiers // received so far } else {

String string;

}

} class String { bit (8) utfδChar while (utf8Char!=0) { bit (8) utfδChar

} } class Number { bit (1 ) islnteger if (islnteger) { bit (5) numbits // number of bits the integer is represented bit (numbits) value // integer value

} else { bit (4) floatChar // 0-9, ., E, END_SYMBOL while (floatChar!=END_SYMBOL) { bit (4) floatChar }

} }

The present invention may be implemented using hardware, software or a combination thereof and may be implemented in a computer system or other processing system. In fact, in one embodiment, the invention is directed toward a computer system capable of carrying out the functionality described herein. An example computer system 201 is shown in FIG. 8 The computer system 201 includes one or more processors, such as processor 204. The processor 204 is connected to a communication bus 202. Various software embodiments are described in terms of this example computer system. After reading this description, it will become apparent to a person skilled in the relevant art how to implement the invention using other computer systems and/ or computer architectures. Computer system 202 also includes a main memory 206, preferably random access memory (RAM), and can also include a secondary memory 208. The secondary memory 208 can include, for example, a hard disk drive 210 and/or a removable storage drive 212, representing a floppy disk drive, a magnetic tape drive, an optical disk drive, etc. The removable storage drive 212 reads from and/or writes to a removable storage unit 214 in a well known manner. Removable storage unit 214, represents a floppy disk, magnetic tape, optical disk, etc. which is read by and written to by removable storage drive 212. As will be appreciated, the removable storage unit 214 includes a computer usable storage medium having stored therein computer software and/or data.

In alternative embodiments, secondary memory 208 may include other similar means for allowing computer programs or other instructions to be loaded into computer system 201.

Such means can include, for example, a removable storage unit 222 and an interface 220.

Examples of such can include a program cartridge and cartridge interface (such as that found in video game devices), a removable memory chip (such as an EPROM, or PROM) and associated socket, and other removable storage units 222 and interfaces 220 which allow software and data to be transferred from the removable storage unit 222 to computer system 201.

Computer system 201 can also include a communications interface 224. Communications interface 224 allows software and data to be transferred between computer system 201 and external devices. Examples of communications interface 224 can include a modem, a network interface (such as an Ethernet card), a communications port, a PCMCIA slot and card, etc. Software and data transferred via communications interface 224 are in the form of signals which can be electronic, electromagnetic, optical or other signals capable of being received by communications interface 224. These signals 226 are provided to communications interface via a channel 228. This channel 828 carries signals 226 and can be implemented using wire or cable, fiber optics, a phone line, a cellular phone link, an RF link and other communications channels.

In this document, the terms "computer program medium" and "computer usable medium" are used to generally refer to media such as removable storage device 212, a hard disk installed in hard disk drive 210, and signals 226. These computer program products are means for providing software to computer system 201.

Computer programs (also called computer control logic) are stored in main memory and/or secondary memory 208. Computer programs can also be received via communications interface 224. Such computer programs, when executed, enable the computer system 201 to perform the features of the present invention as discussed herein. In particular, the computer programs, when executed, enable the processor 204 to perform the features of the present invention. Accordingly, such computer programs represent controllers of the computer system 201.

In an embodiment where the invention is implemented using software, the software may be stored in a computer program product and loaded into computer system 201 using removable storage drive 212, hard drive 210 or communications interface 224. The control logic

(software), when executed by the processor 204, causes the processor 204 to perform the functions of the invention as described herein.

In another embodiment, the invention is implemented primarily in hardware using, for example, hardware components such as application specific integrated circuits (ASICs). Implementation of the hardware state machine so as to perform the functions described herein will be apparent to persons skilled in the relevant art(s).

In yet another embodiment, the invention is implemented using a combination of both hardware and software.

While various embodiments of the present invention have been described above, it should be understood that they have been presented by way of example only, and not limitation. Thus, the breadth and scope of the present invention should not be limited by any of the above- described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents.

Claims

What is Claimed is:

1. A method for compressing a computer program written in a high-level computer language capable of being defined using a recursive syntax description language, said method comprising the steps of:

creating a parse-tree representation of the computer program based on the recursive syntax description language, said parse-tree comprising a plurality of nodes and branches;

assigning a unique value to each multiple-path branch associated with each node in the parse-tree, wherein each multiple-path branch represents an alternative selection in accordance with the recursive syntax description language;

encoding a bitstream using said assigned values for describing the computer program in terms of selected branches in the parse-tree; and

storing the encoded bitstream in a computer storage device.

2. The method of claim 1, further comprising the step of transmitting the encoded bitstream to a client computer system over a computer network.

3. The method of claim 1, wherein the computer program is executed directly from the encoded bitstream representation.

4. The method of claim 1 , wherein the high level computer language is ECMAScript.

5. The method of claim 1, wherein the computer program is an MPEG-4 Script.

6. The method of claim 2, wherein the computer network is the Internet.

7. The method of claim 2, wherein the client computer system is a set-top box.

8. The method of claim 2, wherein the client computer system is a general purpose computer system.

9. The method of claim 2, wherein the client computer system comprises an MPEG-4 renderer.

10. A method for compressing an MPEG-4 script comprising the steps of:

creating a parse-tree of the MPEG-4 script based on a BNF code representation;

assigning a value to each multiple-path branch in the parse-tree, wherein each multiple- path branch represents an alternative path in accordance with the BNF code representation;

storing the encoded bitstream in a computer storage device.

11. The method of claim 10, further comprising the step of transmitting the encoded bitstream to a client computer system over a computer network.

12. The method of cl aim 10, wherein the computer program is executed directly from the encoded bitstream representation.

13. The method of claim 11 , wherein the computer network is the Internet.

14. The method of claim 11 , wherein the client computer system is a set-top box.

15. The method of claim 11 , wherein the client computer system is a general purpose computer system.

16. The method of claim 11 , wherein the client computer system comprises an MPEG- 4 renderer.

17. A system for compressing a computer program written in a high-level computer language capable of being defined using a recursive syntax description language, said system comprising:

an parse-tree creator for creating a parse-tree representation of the computer program based on the recursive syntax description language, said parse-tree comprising a plurality of nodes and branches;

an assignor for assigning a unique value to each multiple-path branch associated with each node in the parse-tree, wherein each multiple-path branch represents an alternative selection in accordance with the recursive syntax description language;

an encoder for encoding a bitstream using said assigned values for describing the computer program in terms of selected branches in the parse-tree; and

a storage device for storing the encoded bitstream.

18. A computer program product comprising a computer useable medium having computer program logic stored therein, said computer program logic for enabling a computer to compress a computer program written in a high-level computer language capable of being defined using a recursive syntax description language, wherein said computer program logic comprises:

means for enabling the computer to create a parse-tree representation of the computer program based on the recursive syntax description language, said parse-tree comprising a plurality of nodes and branches;

means for enabling the computer to assign a unique value to each multiple-path branch associated with each node in the parse-tree, wherein each multiple-path branch represents an alternative selection in accordance with the recursive syntax description language;

means for enabling the computer to encode a bitstream using said assigned values for describing the computer program in terms of selected branches in the parse-tree; and

means for enabling the computer to store the encoded bitstream in a computer storage device.

19. The computer program product of claim 18 , wherein said computer program logic further comprises means for enabling the computer to transmit the encoded bitstream to a client computer system over a computer network.

20. The computer program product of claim 18, wherein said computer program logic further comprises means for enabling the computer to execute the computer program directly from the encoded bitstream representation.