Abstract: The present invention provides a method for routing a telephone call based on a calendar telephony interface. The method can include parsing telephone data associated with the telephone call, and determining from the parsed telephone data, a called telephone number and an identity of a person associated with the called number. The method further can include retrieving an XML formatted calendar entry associated with the identified person and extracting call control information from the XML formatted calendar entry. Accordingly, the telephone call based on the extracted routing information can be routed.

Abstract: A digital object delivery/management system includes a library of stored digital objects and a shared database containing web server access codes and a mapping indicating which users are authorized to access which stored digital objects. The shared database is coupled to a file transfer protocol (FTP) server and a web server. The FTP server is additionally coupled to the library. The web server presents at least one web page providing instructions for users seeking access to digital objects contained in the library, authenticates users according to the web server access codes, generates temporary FTP access codes for use by authenticated users in accessing authorized objects at the FTP server, and redirects authenticated users to the FTP server. The FTP server authenticates users according to the temporary FTP access codes, and, upon successful authentication, makes digital objects contained in the library available to requesting users pursuant to the mapping.

Abstract: The method, system and tangible medium storing computer readable software of the present invention, provide for program constructs, such as commands, declarations, variables, and statements, which have been developed to describe computations for an adaptive computing architecture, rather than provide instructions to a sequential microprocessor or DSP architecture. The invention includes program constructs that permit a programmer to define data flow graphs in software, to provide for operations to be executed in parallel, and to reference variable states and historical values in a straightforward manner. The preferred method, system, and software also includes mechanisms for efficiently referencing array variables, and enables the programmer to succinctly describe the direct data flow among matrices, nodes, and other configurations of computational elements and computational units forming the adaptive computing architecture.

Abstract: The invention provides a method and apparatus for an extensible markup language (XML) calendar-telephony interface. The method can include the steps of defining an markup language element having a user defined tag that represents a calendar entry. The markup language element can have attributes which can represent call control instructions or information. The attributes can also be formatted using a markup language format that utilizes user defined tags. The elements and/or attributes can be formatted using XML format. The call control instruction can be provided to a telephony application upon initiation of a call or by request. A calendar application program can be used for maintaining calendar entries which can be stored in a database and made accessible to the telephony call control application.

Abstract: Checking program elements and program element behaviors for adherence to software development rules. An analysis engine receives a rule assembly containing metadata and intermediate language instructions representing one or more rules. The analysis engine also receives a target assembly containing metadata and intermediate language instructions representing one or more program elements and/or one or more program element behaviors. The analysis engine identifies (e.g., through reflection or retrieval of intermediate language instructions) a program element or program element behavior from the target assembly that is to be checked for adherence to a rule from the rule assembly. The analysis engine applies the rule to the program element or program element behavior to check the program element or program element behavior for adherence to the rule. Results can be stored for later viewing by a programmer.

Abstract: The algorithm for creating and translating cross-platform compatible software is a set of processes that create or translate software. The creation process involves writing the software in the language of choice then compiling it into a standard Cross-platform assembly language binary. Then the Translator software, which is specific to the processor and/or operating system the software is executed on, translates the Cross-platform assembly language into the processors specific assembly language and also processes any graphics or other information the software might need on that platform.

Abstract: Among developers and the software industry as an aggregate, there exists a pressing need for a utility which converts the interface definition specified in IDL format to an Extensible Markup Language (XML) format. Indeed, as an unstructured definition language, the Common Object Request Broker Architecture (CORBA) IDL is well suited and particularly effective for describing data structures and interfaces, though, the existing state of the art remains constrained and limited in extracting this information for further manipulation. The Metamodel for IDL to XML Parsing and Translation invention employs the IDL-to-Java (IDLJ) utility common to Sun's™ Java™ Development Kit. The Metamodel innovatively goes beyond the existing art and harnesses the IDL parsing ability of the IDLJ and generates an XML output for the parsed contents. For ease of XML manipulation, the Metamodel for IDL to XML Parsing and Translation utilizes the JDOM library to store and output the said XML.

Abstract: A mechanism for controlling threads in a Java application while avoiding the unsafe conditions inherent in the use of existing java.lang.Thread methods. In one embodiment, a first class is defined for handling threads in an application. The first class uses a target variable to indicate whether a thread should continue to run, or whether it should be stopped. This first class provides a start( ) method to set up the target variable, a stop( ) method to set the target variable to indicate that the thread should be stopped, and an abstract run( ) method. The functionality of the run( ) method is provided by one or more additional classes which extend the first class. The additional classes override the abstract run( ) method and define the tasks to be performed by threaded objects instantiated from these classes. When a thread needs to be stopped, the corresponding target variable is set to indicate that it should be stopped.

Abstract: A computer implemented method of and apparatus for printing values in a fixed number of column spaces using Java is described. A value desired to be formatted to a predetermined length string and an indexed lookup table having predetermined formatted string entries are used. An index based on the number of characters needed to represent the value is calculated and then used to locate a desired length formatted string entry in the lookup table. The desired length formatted string entry is then combined with a string representation of the value to form a predetermined length string.

Abstract: 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).

Abstract: A data processing representation is expressed in the form of code sections, which may be nested, using multiple programming languages. The representation is read by an execution engine. The execution engine identifies the language of each code section, and a corresponding language specific processing unit is invoked to process the code section. The processing unit reads that section, identifying sub-sections specified in it's associated language and other sub-sections specified in unknown languages. It executes the sub-sections specified in its associated language with the intended semantics and in the appropriate order. When a sub-section specified in an unknown language is encountered, it delegates processing of that sub-section back to the execution engine, which repeats this process for the unknown sub-section. The execution result is returned back to the requesting language specific processing unit, which continues processing from where it left off.

Abstract: A performance analyzer for object-oriented programming code distinguishes between an object which is substantively used within the creating method, and one which is merely created in the creating method and passed back to a calling method. In the preferred embodiment, a trace record is generated when the object is first accessed, to indicate the method which caused the operation, but no trace record is generated on subsequent object accesses. The performance analyzer may parse the trace to determine whether an object access trace record occurred in the creating method, or in some other method. Preferably, the program being analyzed is written in Java, and the performance analyzer is an instrumented Java Virtual Machine (JVM), i.e., a JVM to which trace and/or other performance analytic capabilities are added.

Abstract: A computer controlled object oriented programming system for distributive program development over networks such as the internet with implement for interfacing a plurality of programming objects with each other to provide combination objects combining programming functions of said objects, each object including predetermined interface data defining a required common interface with the other programming objects as well as a framework of events and attributes and methods for manipulating the attributes. These objects may be combined with each other via their common interfaces to form combination objects, and such combination objects may in turn be further combined with other objects and combination objects to form objects of increasing complexity which function as complete programs. General purpose operations and functions are added to existent object oriented programs in an object attribute independent process. Also, this addition may be done dynamically to such existent programs.

Abstract: A system, method and article of manufacture are provided for using a dynamic object in a programming language. In general, an object is defined with an associated first value and second value. The first value is used in association with the object during a predetermined clock cycle. The second value is used in association with the object before or after the predetermined clock cycle.

Abstract: A mixed language expression execution method and apparatus includes an execution engine equipped to determine whether an execution context has previously been created for an expression, upon receiving a request to execute the expression. If not, one is created, invoking one or more expression processors, to contribute to the initialization of the execution context. If created or upon creation, the expression (including its sub-expressions, if any) is executed, using the execution context. The result is then returned to the requester. In one embodiment, the execution context is object oriented, and includes various methods to facilitate the initialization and execution. Further, at least one expression processor includes a load and an execute interface equipped to use these methods.

Abstract: A method and apparatus for depicting programming state of programming objects through a combination of associating semantic stat space with programming objects, updating semantic state through affiliated state updates with each programming action, and resolving the alternative programming states with a convergence operator defined on the semantic state space of the programming object type. The state reflection process is further defined in cases where the visual programming object participates in multiple execution paths, as would be the case in, for example, an IF statement wherein the variable is used on both the Left and Right sides. More particularly, this technique resolves these differing states back into a single state representation for the programming object.

Abstract: A computer-implemented method for converting a UML rendering of an RSM-based metamodel to a UML rendering of a MOF-based metamodel. The method includes the steps of removing inheritance from classes defined within a Repository Services Model (“RSM”) and removing each explicit “construct” operation from each class in the RSM-based metamodel Next, each use in the RSM-based metamodel of an RSM type is changed to use a non-RSM type. After this, each element of the RSM-based metamodel is converted to a corresponding MOF-based element and a determination is made as to whether or not the RSM naming service is used in the RSM-based metamodel, and if so “name” attributes are added that would have been inherited from the RSM classes. A <<metamodel>> stereotype is added to the UML rendering of the MOF-based metamodel; and the MOF properties are set on the UML rendering.

Abstract: A method for creating and using program comment fields in a program listing to augment the functionality of a program language architecture. Standard comment fields are uniquely identified to contain special augmenting commands. These commands are used by program editors to augment the program functions. A help notification mechanism is provided to automatically provide appropriate comment field hints to the programmer.

Abstract: An instruction system for issuing instructions from a first computer system (50-90) for execution by a second computer system (10, 20, 40) is described. The instruction system comprises instructions of a first type having an effect on the second computer system which is determinable by the first and second computer systems, and instructions of a second type, the effect of which is not determinable by the first computer system. The instructions of the second type each include a descriptor for aiding a user to determine the effect of the respective instruction at the first computer system.

Abstract: A method, applications programming interfaces (API), and mechanism for converting between JAVA classes and XML. In a file containing JAVA data representations, each JAVA class having elements to be converted to an XML representation is annotated in a manner enabling appropriate conversion processing by an API generating therefrom an XML file. The annotation enables instances of Java class objects to be converted to an XML representation and XML representations to be converted to Java class objects.

Abstract: One embodiment of the present invention provides a system that detects violations of type rules in a computer program. The system operates by locating a type casting operation within the computer program, wherein the type casting operation involves a first pointer and a second pointer. The system then checks the type casting operation for a violation of a type rule. If a violation is detected, the system indicates the violation. In one embodiment of the present invention, if the first pointer is defined to be a structure pointer and the second pointer is not defined to be a structure pointer, the system indicates a violation of a type rule. In one embodiment of the present invention, if the first pointer is defined to point to a first structure type and the second pointer is defined to point to a second structure type, the system determines whether the first structure type and the second structure type belong to the same alias group. If not, the system generates an error to indicate a type violation.

Abstract: This invention relates to a programming station for an automation application that will be executed in an automation equipment. The programming station stores at least one file in an internal memory containing a description grammar for automation applications in text format, for at least one of the graphic automation languages (Ladder, SFC, FBD) using a single, hierarchised and object oriented language. It also contains a set of one or several description files, each description file describing part of the automation application and being expressed in this single language. The single, hierarchised and object oriented language is the XML (eXtended Markup Language) language.

Abstract: In order to use object-oriented models over the Internet for applications in different type systems it is necessary to marshal and unmarshal objects between Java, SQL and XML. Hand-writing specific code to do this is difficult. A computer-implemented method of generating serialization code for representing a model in a plurality of type systems is disclosed, the method comprising the steps of: i) producing an input file from the model for a given set of objects; and ii) providing a code generator for acting on the input file to generate the serialization code.

Abstract: Systems, methods and computer program products are provided for sharing resources within an Extensible Markup Language (XML) document that defines a console (i.e., a graphical user interface or GUI) for managing a plurality of application programs and tasks associated therewith. Upon receiving a user request to perform a task associated with an application program managed by a console, resource containers at each scoping level within the XML document are searched for one or more resources required to perform the task. A search is initiated at the scoping level where a task to be performed is defined and proceeds in ascending order towards the root scoping level until the resource is located. When found, a clone of each located resource is generated. The task is then performed using the clone of the resource. The clone of the resource may be discarded after the task has been performed.

Abstract: Documentation of a software application is automatically generated for the classes, written in an object oriented-language, which comprise the application. The classes within the application are typically arranged in a hierarchy and contain productions of a specification grammar in Extended Backus Naur form. The automatically generated documentation corresponding to these productions are closely wired to the underlying class hierarchy by creating hypertext links between the productions in different classes. Thus, these generated hyperlinks allow browsing of the automatically generated documentation according to the hierarchical structure of the classes in the object-oriented class hierarchy being documented.

Abstract: A system for adding functionality to a graphical user interface of a non-Java based, or native, application, using the Java programming language is provided. A Java window, or dialog, is configured to be accessible by a native application. While the native application is executed in a first thread, a Java dialog is launched in a second thread. Execution of the native application in the first thread is then continued. The Java dialog next calls the native application and registers itself with the native application. Also, the native code can control the Java dialog like other dialogs supported by the native code. A command for a Java dialog from a native application is routed to an invisible dialog. The invisible dialog passes that command to the Java dialog through a native interface connection. A very seamless integration between the Java and native code thus occurs. The graphical user interface operates and visually appears as if controlled from a single source of code.

Abstract: For a large system having an associated monitoring system with one or more user interfaces that each requires a large amount of direct user interaction, a scripting language especially well suited to write a script (that generates liaison interface between the user and the existing user interfaces) is provided. The liaison interface requires much less direct user interaction by taking the place of the user in the extensive direct interaction required by the existing user interfaces. Such a scripting language that includes an integration construct data structure that permits commands of discrete interfaces to be integrated in a single script that is to be executed by a machine. Also provided are scripts according to the scripting language, that include at least two of the integration construct data structures.

Abstract: A system and method is provided defining a standard software application development framework that can be customized and linked to building blocks by various utilities and project layers, to implement standard business rules in an assembled code. Application developers can set programming standards through a template. By setting these standards, application developers use the system and method to define the naming convention, appearance of the code, reserve places for the comments, and ensure that specific types of code appear at a predefined locations in the code. The template is used while assembling the code.

Abstract: At present, there are very few programming languages to develop and run applications in communications, especially in messaging.

Abstract: A method is provided, the method comprising defining an actual size of each variable in a programming language at a declaration time when the actual size of the respective variable can be defined and declaring at least one variable in the programming language to have a dynamic size at the declaration time when the actual size of the at least one variable is not known. The method also comprises defining the actual size of the at least one variable in the programming language when the actual size of the at least one variable becomes known after the declaration time.

Abstract: Method and apparatus are disclosed for the intensive use of garbage collection in order to determine the exact amount of memory that is consumed by a running application at any point of its execution. A garbage collector executes immediately prior to allocations of memory during execution of a program. The amount of memory used by the application is known after each such allocation of memory, and is very close to or equal to its theoretical requirement. A developer is also enabled to determine whether a specified memory allotment for an application is ever exceeded.

Abstract: A system and environment in which the data within the system can be defined and manipulated in terms of a world model or Ontology, and for which the DBA and GUI portions of the programming tasks can be specified and automatically generated from this Ontology is provided.

Abstract: A method of assembling executable instructions includes mapping a first file scope symbol table for a first source code file being assembled, the first file scope symbol table including a reference for each symbol declaration within each corresponding section of code, determining nested sections of code included in the first source code file, mapping a nested scope symbol table for each determined nested section of code, with each nested scope symbol table including a reference for each symbol declaration within each corresponding section of code and assembling a portion of an executable instruction that corresponds to a symbol reference included in a coded instruction, the portion of the executable instruction based on a symbol mapped by one of the symbol tables.

Abstract: A method and apparatus are disclosed for modeling XML applications using an extended UML notation. The present invention extends the UML model template to include an additional compartment, referred to as a constant attribute compartment. The constant attribute compartment allows the constant attributes of an XML element to be explicitly represented in the UML model. The disclosed UML model can thereby distinguish XML elements and XML attributes using the additional constant attribute compartment to represent attributes that remain constant through all instances of an object. The UML modeling of XML elements is more clear and readable by separately modeling the constant attributes and the variable attributes of the XML element. The present invention facilitates the automatic generation of XML schemas and source code with the appropriate software tools.

Abstract: A partial evaluator, or pre-compiler, for a computer program enables a user to provide, at suitable places within a program, language constructs which cause certain expressions within the program to be evaluated at runtime or at partial evaluation time. These language constructs can be used to shorten runtime, such as by avoiding unnecessary duplication of code at runtime.

Abstract: A statement evaluation technique is based on bi-evaluation of programming statements. A programming language statement is evaluated that includes a first and a second sub-statement. The first sub-statement is evaluated and an evaluation success result is determined if evaluation succeeds, or a distinguished value if evaluation fails. The distinguished value is a value that is not included in the range of possible evaluation success results of the first sub-statement. Further, it is determined whether the second sub-statement is to be evaluated. If this is the case, an evaluation success result of the second sub-statement is determined if evaluation succeeds, or the distinguished value if evaluation fails. The range of possible evaluation success results of the second sub-statement does not include the distinguished value. The evaluation result of the statement is determined depending on at least whether evaluation of the first sub-statement succeeds or fails.

Abstract: Provided are a computer implemented method, system, and program for translating a class schema in a source language to a target language. Class element definitions in a source file in the source language are received. The definitions of the class elements define instances of metadata types providing metadata for the class elements. Statements in the target language are generated to implement class elements defined in the source file. Statements are generated in the target language to define metadata elements for metadata types. For each metadata data type instance defined with one class element in the source file, at least one statement is generated in the target language to associate the metadata element generated for the metadata type with the implementation of the class element corresponding to the class element defined with the metadata type instance in the source file.

Abstract: A unified event programming model standardizes event programming for disparate eventing protocols. The unified event programming model simplifies programming events for different object types by abstracting away protocol-specific details. A protocol-independent compiler construct allows a programmer to specify events for an event source. Other protocol-independent compiler constructs allow a programmer to specify how to hook and unhook an event receiver from events. Based upon protocol-independent compiler constructs and an eventing protocol type value, a compiler generates an event source or event receiver implementation that is specific to an eventing protocol.

Abstract: A software mechanism for enabling a programmer to embed selected machine instructions into program source code in a convenient fashion, and optionally restricting the re-ordering of such instructions by the compiler without making any significant modifications to the compiler processing. Using a table-driven approach, the mechanism parses the embedded machine instruction constructs and verifies syntax and semantic correctness. The mechanism then translates the constructs into low-level compiler internal representations that may be integrated into other compiler code with minimal compiler changes. When also supported by a robust underlying inter-module optimization framework, library routines containing embedded machine instructions according to the present invention can be inlined into applications. When those applications invoke such library routines, the present invention enables the routines to be optimized more effectively, thereby improving run-time application performance.

Abstract: An object oriented programming technology enables multiple objects to be snapped into a given container or client. Thus, for example, multiple ActiveX controls can be snapped into one given container and these controls may be accessed in a fashion which can be truly termed binary compatible. That is, each of the controls can be accessed without requiring recompiling even when they have different identifiers and/or different interfaces. In one embodiment, this may be accomplished by providing SetGUID and GetGUID functions in a layer class associated with the objects. The identifier of the desired object can be obtained from the system database and set in the layer class to selectively access one of at least two objects in the same container without recompiling.

Abstract: A new fundamental unit of programming which couples semantic and syntactic relationships, and a system for compiling those units and programs written in those units. A Sym is comprised of a Name, an Inherit Statement, a Self Description, and a Definition. Syms couple syntactic and semantic relationships through their use of Syntactic References in their Self Description and Semantic References in their Definition. Syms and programs written in Syms are compiled through the Sym Execution System.

Abstract: A programming language is provided that permits the use of both dynamically scoped variables and statically scoped variables, and that allows a programmer to select which scoping is desired for a particular variable. The programming language comprises at least one language construct for defining statically scoped variables to be used if a static scoped variable is desired and at least one language construct for defining dynamically scoped variables to be used if a dynamically scoped variable is desired. A method, apparatus, and computer-readable medium are also provided.

Abstract: This invention is about a method of digital circuit design using programming language. It can solve problems raised by describing hardware using programming language, e.g. difficulties in describing changes within the same time step, and limitations in designing by sequential process. Separate variables are used to indicate registers and input of the registers. After the process of module section, the secondary variables are assigned to primary variables in a non-blocking assignment section. Combination circuits, which are used by more than one modules in module section, are defined in a assignment section and before module execution. Several clocks and gated clocks are described in non-blocking assignment section and loop section.

Abstract: This invention provides for the implementation of dynamic “event to method” adapter class generation. Event to method adapter classes and objects are automatically and dynamically generated and wired to source and target objects as required using a runtime environments language such as the Beans Markup Language (BML). Adapter classes and objects are automatically and dynamically generated as required while the application program loads and runs. Dynamically generated classes and objects need to exist only at the time that a running application calls for the adapters use, and can be dynamically modified or exchanged in order to optimize the running application or modify application functionality.

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 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: Verification of intermediate language code. In one embodiment, a computer-implemented method first verifies metadata of an intermediate language code for consistency and accuracy, and then verifying the intermediate language code for consistency and accuracy. This latter part in one embodiment is accomplished by performing first a syntactic check of the intermediate language code, and then a semantic check of the intermediate language code.

Abstract: A state machine for an assembler capable of processing structured assembly language is disclosed. The state machine for an assembler capable of processing structured assembly language IF constructs includes five states, namely, an IF state, an ELSE state, an END_IF state, an ELSE_IF state, and a SETUP_IF state. In response to recognizing a SETUP_IF clause during the IF state or the ELSE_IF state, the process transitions to the SETUP_IF state. In response to recognizing an ELSE_IF clause during the SETUP_IF state, the process transitions to the ELSE_IF state.