Abstract: A system and method for processing a variable looping statement into a constant looping statement to enable loop unrolling. A lower bound and an upper bound of the loop index within the variable looping statement are determined. A constant looping statement is then formed using the lower bound and upper bound to define a range over which the loop index varies within the constant looping statement. The constant looping statement further includes a conditional statement that reflects conditions in the initial expression and/or the exit expression of the variable looping statement. The conditional statement controls execution of the body of the generated constant looping statement, which includes the body from the original variable looping statement. Loop unrolling may then be performed on the generated constant looping statement.

Abstract: The present invention is a method and apparatus for runtime binding of object members. The invention extends the late binding functionality allowed for virtual functions by static compiled programming languages like C, C++, JAVA, to all class members and class methods (functions) of all objects (classes), including virtual functions. According to one embodiment access to any member or method of any object results in a runtime search to find the member or method and to verify that the member or method exists. This eliminates the need to type cast to get access to members of a derived class. Each member of a class has an access control level associated with it, and according to another embodiment this access control protocol is honored by the runtime search to make sure that the user has access to only public members, and not private members.

Abstract: The present invention provides a method and apparatus for the unification of the semantics of classes and functions in a programming language. The semantic rules follow the pattern of: keyword name(parameters), where keyword is either class or function. Both the function and class bodies contain statements that are executed after the structure is instantiated. In either construct, these statements comprise constructor code. A function also optionally returns a value. In one embodiment, software is written in an interpreted programming language implementing the present invention. The interpreter instantiates a class on the memory heap. The class remains instantiated until the class destructor is called. A function is instantiated on the memory stack. The function remains instantiated until the final line of constructor code is executed. The function is then automatically destroyed.

Abstract: Embodiments of the present invention are directed to a method and apparatus for providing an iteration operator for an object instance in a dynamically typed language. In one embodiment, a class provides a special operator which produces values which can be iterated through. In one embodiment, a class provides a foreach operator. When the foreach operator is called for an instance of a class, a list of values are returned. In one embodiment, when a foreach statement encounters an instance of a class where the statement expects a list of values to iterate through, the statement calls the foreach operator of the class and iterates through the returned values. In one embodiment, a class provides a special operator which defines how an instance of the class is incremented. In another embodiment, a class provides a special operator which defines how an instance of the class is decremented.

Abstract: The present invention provides a method and apparatus for determining runtime size and type information in dynamically typed languages. In one embodiment of the present invention, a dynamic size and type system is added to a programming language. In one embodiment, an operator which returns a size associated with an object is dynamically executed at runtime. In another embodiment, if the object is an instance of a class, then the class may provide an instance of its own size operator to perform the calculation. In another embodiment, an operator which returns a type associated with an object is dynamically executed at runtime. In one embodiment, if the object is an instance of a class, then the class may provide an instance of its own type operator to perform the calculation.

Abstract: The present invention provides a method and apparatus for implementation of an input/output stream operator in a dynamically typed language. This operator is built into the language, and allows a value of one type to be streamed to a value of another type by taking the form fromvalue → tovalue. Since the programming language is dynamic, the type of values on either side of the → operator is of any supported type, and can be modified depending upon the type of operands. For example, a value of any type can be streamed to a value of type “stream”. In this instance, the destination value is attached to, for example, a device such as a terminal or disk drive. A value of type “stream” can also be streamed into a value of any type. In this instance an external source is inputted, for example, into a program.

Abstract: The present invention provides a method and apparatus by which functions may be derived from other finctions in a programming language. A function is essentially processed as a class, except that the object is automatically destructed after the final line of code is executed. In one or more embodiments of the present invention, a function has the ability to inherit from a superfunction. Inheritance in this context means that all functions in the hierarchy execute in order from the lowest level superfunction to the derived function invoked by the calling statement. Further, the derived function has access to all nonprivate methods and variables defined in the superfunctions. All functions in the hierarchy remain instantiated until the derived function has executed. At this point, the functions are destructed in reverse hierarchical order. If a function in the hierarchy enters an error condition, the execution process is halted.

Abstract: The present invention provides a method and apparatus for statement boundary detection. In one embodiment of the present invention, a parser determines a natural end of a statement, where possible, based upon the context of the input stream and the syntax of the programming language. Thus, no statement terminator is necessary when a natural end to a statement is determined. The parser uses the natural end of a statement to terminate one statement and begin parsing another statement. In one embodiment, a special statement termination token is required to terminate a statement when no natural statement end exists. In another embodiment, a special statement termination token can be used to terminate a statement when a natural end of the statement exists.

Abstract: The present invention provides a method and apparatus for the lexical analysis of computer source code. The lexical analyzer is dynamically configured at runtime to recognize a one or more reserved words or operators. Thus, the analyzer has the ability to interact with multiple languages. In one or more embodiments of the present invention, the analyzer is instantiated by a host application, for example, the parser of a compiler. The host application adds a list of tokens to the analyzer that must be recognized. These tokens comprise at least a subset of the reserved words and operators of the computer language. In one embodiment, the host application then queries the analyzer for the next token in the source code. In another embodiment, tokens are added during the query phase as needed. In a separate embodiment, tokens are dynamically removed from the analyzer as the needs of the host application change.

Abstract: A method and apparatus for computation is provided. A main cluster crossbar is connected to a plurality of statically scheduled routing processors. A first sub-cluster crossbar is associated with a first one of the plurality of statically scheduled routing processors where the first sub-cluster crossbar is connected to a first plurality of execution processors. A second sub-cluster crossbar is associated with a second one of the plurality of statically scheduled routing processors where the second sub-cluster crossbar is connected to a second plurality of execution processors.

Abstract: Embodiments of the present invention are directed to a method and apparatus for extending a program element in a dynamically typed programming language. In one embodiment, a program element is extended without altering the source code defining the program element. An extend structure is used to extend a program element in a particular program. In one embodiment, the program element is a function. The function is extended by adding code to be executed by the function. In another embodiment, the program element is an enumeration. The enumeration is extend by adding additional constants to the enumeration. In another embodiment, the program element is a class. In one embodiment, a class is extended by adding code to the constructor of the class. In another embodiment, a class is extended by adding member variables to the class. In yet another embodiment, a class is extended by adding member functions to the class.