Abstract: The present invention includes program storing unit 11 for storing a program, parsing/dependence-information generating unit 12 for generating dependence information and a syntax tree for a program, dependence-information storing unit 13 for storing dependence information, syntax-tree storing unit 14 for storing a syntax tree, dependence-information tracking unit 17 for extracting interface information on a program fragment according to specifying-information specifying the program fragment and extracting a part of a program fragment associated with interface information according to selection information for selecting the interface information, and information input/output unit 15 for passing specifying-information and selection information to dependence-information tracking unit 17 and outputting interface information and a part of a program fragment passed from dependence-information tracking unit 17.

Abstract: A system, method, and article of manufacture for caching a pre-processed version of an interpreted application at the time the interpreted application is first interpreted and executed by a computer, thereby improving response time for subsequent executions of the interpreted application. The pre-processed version of the interpreted application captures all execution paths through the interpreted application, despite the fact that the first execution of the interpreted application may only exercise a subset of the possible execution paths therein. Modifications to the interpreted application are dynamically detected, so that the pre-processed version can be replaced in the cache as needed.

Abstract: A structured multithreaded programming system is described for integrated use with existing and new programming languages and systems. The structured multithreaded programming system enables programs to be developed which include both multithreaded and multithreadable code constructs. The multithreaded code constructs require explicitly concurrent execution. The multithreadable code constructs can be executed either sequentially or concurrently, at the selection of the programmer or computer user. When executed concurrently, the different threads of execution in a multithreaded program developed with this system can be synchronized using innovative synchronization objects. One type of synchronization object is a special type of counter, which can be constrained to be monotonically increasing in value. Another related type of synchronization object is a special type of flag, which can be constrained to have its value set monotonically.

Abstract: A present invention emulation class revision process performs emulation class revisions. In one embodiment of the present invention an indication of an emulation class revision initiation is received. A safe state for performing the emulation class revision is established. In one exemplary implementation the safe state retains prior processing results. An emulation class revision is performed.

Abstract: In a threading mechanism, a system and method for providing automatic value inheritance when a parent thread creates a child thread. Upon thread creation, the system iterates over all of the inheritable thread-local values associated with a parent thread and initializes a child's values of these inheritable thread-local values, based on an appropriate child value method. The child's values may be a copy of the parent's values, or a predetermined function of the parent's values.

Abstract: An authorization architecture for authorizing access to resource objects in an object-oriented programming environment. In one distributed environment, the permission model of JAAS (Java Authentication and Authorization Service) is replaced or enhanced with role-based access control. Thus, users and other subjects (e.g., pieces of code) are assigned membership in one or more roles, and appropriate permissions or privileges to access resource objects are granted to those roles. Permissions may also be granted directly to users. Roles may be designed to group users having similar functions, duties or similar requirements for accessing the resources. Roles may be arranged hierarchically, so that users explicitly assigned to one role may indirectly be assigned to one or more other roles (i.e., descendants of the first role). A realm or domain may be defined as a namespace, in which one or more role hierarchies are established.

Abstract: A storage medium is disclosed. The storage medium having stored on it a set of programming instructions defining a number of data objects and operations on the data objects for use by another set of programming instructions to enable the other set of programming instructions to be compilable into either a version suitable for use in a hardware/software co-simulation that effectively includes calls to hardware simulation functions that operate to generate bus cycles for a hardware simulator, or another version without the effective calls, but explicitly expressed instead, suitable for use on a targeted hardware.

Abstract: The grammar of this invention is an approach to regular expressions which introduces advantages to programmers who use regular expressions for scanning, searching, and tokenizing text:

Abstract: Software development tools, such as a static analyzer, debugger or source browser, incorporates techniques to process macro expansions and provide display of macro expansion information, so as to facilitate program analysis and debugging during the development process. The tool processes macro expansions during a build of a programming project's source files, and collects and records the macro expansion information into an output file or database. The tool then utilizes the recorded information to provide a displays of the macro expansions in a graphical user interface of the tool, such as for source browsing or viewing static analysis.

Abstract: The use of XML types can allow the combination of XML- and Java-type systems, which overcomes many deficiencies in existing marshaling and unmarshaling systems by translating XML schemas which define XML data in an XML document into XML types in Java. Unlike traditional attempts at translating between XML and Java, XML schemas realized as XML types can remain fully faithful to the XML, and are capable of a number of XML data operations. In addition, the XML types can be easily transformed among themselves and Java types, and a lightweight store retaining XML information at tag level allows incremental XML marshaling and unmarshaling. This description is not intended to be a complete description of, or limit the scope of, the invention. Other features, aspects, and objects of the invention can be obtained from a review of the specification, the figures, and the claims.

Abstract: A programming language type system includes, in a memory, a set of numeric type including integer types, fixed-point types and floating-point types, a set of type propagation rules to automatically determine result types of any combination of integer types, fixed-point types and floating-point types, constant annotations to explicitly specify a result type of a literal constant, context-sensitive constants whose type is determined from a context of a constant according to the set of type propagation rules, an assignment operator to explicitly specify a type of a value or computation, and operator annotations to explicitly specify a result type of a computation.

Abstract: The specification may disclose a method of overloading a programming language programs, where a distinction between the overloaded methods are their return parameter types.

Abstract: The invention relates to the field of source code development and in particular a method and system for generating a tutorial application from one or more selected source code elements. The invention provides for a user to select one or source code elements and one or more data elements to be tagged to one or more source code elements. The selected source code elements are tagged using a mark-up language and a tutorial application is generated displaying the tagged selected source code elements and the data elements.

Abstract: The present system imports data from a source schema into a target schema while keeping the semantics, structure, and constraints of the data intact. The system is driven by user inputs that define a set of correspondences between the source schema and the target schema. The system meets the requirement that data produced at the target not violate the schema of the target; rather, the data must conform to the target schema. The system can be applied in both target materialization and query unfolding, producing all the meaningful queries required in data translation by finding all the associations that exist in the schemas. Each query maps from a source association to a target association. The user selects a subset of those queries that match the desired data translation. Target constraints are taken into account by the present system to infer the user intention and to guarantee that the generated data satisfies the structure and constraints of the target schema.

Abstract: A system and method for an ejection failure mechanism is provided. The system receives a request to eject an ejectable resource, and, provides information associated with a failure of the ejection of the ejectable resource, if ejection of the ejectable resource is unsuccessful. The system thus provides a deterministic mechanism through which information associated with failure of the ejection of an ejectable resource can be communicated. As such, an initiator of the request to eject can receive information associated with a cause of the ejection failure.

Abstract: A system and method for enriching object oriented programming languages by employing XML literals, embedded expressions, and a flexible validator is provided. Object instantiation is accomplished by employing XML literals with optional embedded expressions. The XML literals themselves provide a means for concise programmatic denotation, which facilitates coding and debugging of XML data. XML embedded expressions, inter alia, allow complex objects to be constructed dynamically. The validation system and method provides flexible validation for the XML literals and embedded expressions using inference rules to describe when a literal expression is valid and what the resulting witness or proof is for the value denoted by the literal.

Abstract: A system and method for multi-language compilation is provided. The system and method provide a mechanism for two or more separately written compiler components to co-operate in the compilation of mixed language compilation units. The system mitigates problems associated with conventional approaches to dealing with embedded code blocks. Extensibility is facilitated through the use of a common compiler infrastructure (CCI) in the form of a base class library. Compilers for specific languages are written as extensions of these classes. Common conventions and a flexible extensibility mechanism facilitate cooperation amongst the compilers.

Abstract: A system and method for interfacing additional translation logic via composer(s) to a compiler to extend the capabilities of the compiler is provided. Generally, composer(s) can be software libraries that provide employment of componentization and polymorphism to compiler add-ons in order to extend compiler capabilities. One or more composers can be accessible to the compilation process by reference(s) made in a source code file. For example, additional translation logic for data types and/or expressions (e.g., markup language) created after compiler design can be made accessible to a compiler via composer(s), thus extending the existing compiler. The present invention mitigates problems associated with conventional compiler extending schemes and affords for compile code optimization without having to consider substantially all of the operations of a single query.

Abstract: There is disclosed a simplified rating language for crafting price plans for ratable events which may be interpreted by either a source level interpreter resident upon a device also comprising a device based rating engine or via a virtual machine designed for said rating language.

Abstract: Certain exemplary embodiments can provide a computer-based translation method that translates source information into target information using knowledge that arises from relationships between elements of the source information.

Abstract: 14A method includes providing an executable code that is executable on a series of mobile phone models, and loading the executable code into a memory of a selected mobile phone. The method further includes providing a plurality of parameter sets having a uniform data format, each parameter set corresponding to at least one mobile phone, and then, determining the parameter set corresponding to the selected mobile phone. The method finally includes loading the selected parameter set into the memory of the selected mobile phone. According to the method, the executable code and the selected parameter set combined form operational program code of the selected mobile phone.

Abstract: A computer programming system for scripting and executing an application program including a processor, an object oriented programming language system, and a memory. The processor executes the applications program under the control of an operating system. The memory is associated with the processor and stores the operating system, the object oriented programming language system, and the application program. The object oriented programming language system includes a scripting program for composing code written in a text file according to an object oriented programming grammar, a parser program for converting the code written in the text file into one or more executable task actions and one or more properties of one or more objects, and an execution engine for executing the one or more task actions upon the one or more properties of one or more objects.

Abstract: Methods and systems are provided for mapping markup language data and schema, such as eXtensible Markup Language (XML) data and XML schema, to selected fields (cells, columns, rows) of a spreadsheet application document. An XML schema file is associated with a spreadsheet application document by providing a mechanism of adding the schema definitions to the spreadsheet application document. Furthermore, XML schema constructs such as elements, attributes, and simple content are associated to regions in the spreadsheet application document by providing a tree view structure of a generalized instance of a given XML schema file. A user may drag and drop markup language nodes representing elements, attributes and simple data content, from the tree view structure of the generalized instance of the XML schema file onto a spreadsheet worksheet grid.

Abstract: Described is a system, method, and data structure that enables an executable assembly associated with a subclass to be generated from a subclass definition within a markup document. In accordance with the invention, the subclass definition is written based on a schema. The schema may be XML-based. The schema includes a subclass tag for defining a name for the subclass. The name is associated with a type for an object that is instantiated when the executable assembly executes. The schema further includes one or more hints, such as for specifying a programming language to compile the subclass definition, for specifying a superclass from which the subclass derives, for specifying actions to perform when the object becomes instantiated, for creating an event definition and event handler for the subclass, and for specifying a property that becomes a member within the object when the object is instantiated.

Abstract: A system and method for translating output received from an electronic device. In one embodiment, the method comprises receiving self test output (STO) from an electronic device, retrieving identification information from the STO, retrieving an output decoder corresponding to the identification information and translating the STO into a specified format using the output decoder. The output decoder may be generated from the same computer code used to generate the output of the electronic device. The output decoder may include descriptive information used to describe the output generated by the electronic device. In one embodiment, the output decoder is generated when the computer code is run on an external processor. In one embodiment, the STO and the output decoder include version information. The STO may be in XML or some other format. The output decoder may be in XML schema or some other format.

Abstract: A uniform resource locator (URL) is embedded in computerized or digital documentation for a physical and/or a software process control element existing within a process control environment to thereby provide an automatic link to documentation or other applications that exist in other processing or data environments, such as in a word processing environment or in a data manipulation environment.

Abstract: An integrated development environment for using a mark-up language (JMSML) to access JMS/JMX interfaces. The invention comprises a JMSML Integrated Development Environment in which a Graphical User Interface (GUI) is provided to enable the user to develop JMSML application. Using this IDE, the user can Edit, Manage and Execute and see the execution results of the JMSML program all within this IDE. The IDE provides the user two ways to write the JMSML program. One way is to type in the JMSML XML code using the Source Editor and another way is to visually assemble the JMSML components from the GUI toolbars provides in the Design Editor that in turn will generate the JMSML XML source code.

Abstract: Source code is compiled using a multi-stage compiler that includes a tokenizer, a type checker, and a composer. The tokenizer segments source code into a sequence of tagged segments. The source code includes at least one instruction that composes a first abstraction and a second abstraction with a selected composition operator. The parser builds a tree using the sequence of tagged segments. The type checker performs a first pass of the tree to determine whether abstractions on the tree are well typed. The composer reduces the at least one instruction composing the first and the second abstractions on the tree to a third abstraction. The composer substitutes the first and the second abstractions on the tree with the third abstraction, wherein the type checker performs a second pass of the tree to determine whether the third abstraction is well typed.

Abstract: In an information processing apparatus capable of receiving data and displaying objects, the convenience of display operation is improved. More specifically, an information processing apparatus for receiving data described in a markup language and including first hierarchical level elements delimited by predetermined tags and second hierarchical level elements which belong to a range delimited by the predetermined tags, and displaying the received data on a display device, includes a receiving unit for receiving key-input first and second signals, a switching unit for switching selection between the first hierarchical level elements or between the second hierarchical level elements when the first signal is received, and switching selection between the first and second hierarchical level elements when the second signal is received, and a selected element display unit for displaying the selected element on the display device. A desired display object can be selected by a few key input operations.

Abstract: A network-based computing system that automates, simplifies, and optimizes the compilation, deployment, and execution of an application by any type of a client machine connected to a server via any type of a network connection. The system includes a client runtime environment, a server runtime environment and an object-oriented markup-business logic binding mechanism. The client runtime environment manages client side code and screen definitions. The server runtime environment dynamical compiles code to ensure client platform compatibility. The system delivers network applications on demand, by separating them into lightweight modules and delivering these modules.

Abstract: Verification of a software program may be automated by receiving a program source file comprising program source code and at least one formal specification annotation, extracting the at least one formal specification annotation from the program source file, compiling the program source code and linking the compiled program and the at least one extracted formal specification annotation to create an executable program that includes at least one reference to an executable formal specification module. According to one aspect, a virtual machine includes a target virtual machine for executing one or more program implementation instructions, and a formal virtual machine for executing one or more formal specification modules corresponding to one or more program implementation instructions and configured to call a formal specification module, and to compare a first result obtained by executing the program implementation instructions with a second result obtained by the call to the formal specification module.

Abstract: Programming abstractions with at least one expression are composed to a single abstraction using a composition operator. Expressions from the abstractions are unfolded by removing the prefix of each abstraction and substituting formal parameter names in each expression with a common parameter name to define open variables. The unfolded expressions are transformed to a reduced expression using a composition pattern that tunes semantics of the composition operators. The reduced expression is nested in the single abstraction by: appending a selected prefix of the composed abstraction to the reduced expression, binding the open variables of the reduced expression to the formal parameter of the selected prefix, and computing the type of the formal parameter of the selected prefix.

Abstract: An outline-processor that surrounds each program constituted from a plurality of programs by a respective frame having diagram-displays that connect the frames by a line, such that if the inside of the frame is clicked by a mouse, a source of the program therein is outline-displayed. Diagram-displays display respective arguments of the programs in the vicinity of the frames of the programs and display frame lines of the program thick before expansion and thin after expansion to change the thicknesses of the frame lines of the program before and after expansion. Further, when the plurality of programs are outline-displayed in a plural number, a newest outline-display is displayed in front.

Abstract: A method is described for providing required values as needed in a class of computer-program compilers, which transform a first computer-program (source program) into a second computer-program (target program), such that the target program has modified or augmented functionality. The source and target programs may be written in the same or different programming languages. As an example, the compiler may perform automatic differentiation (AD), where the source program evaluates a function and the target program evaluates both the function and its derivative, and both programs are written in a high level programming language such as Fortran. In this example, required values are needed in the target program to evaluate its control flow, index expressions, or local derivative information. Providing required values in an efficient way is essential in AD but constitutes a major complexity for various modes of AD. For typical applications, our method is significantly more efficient than standard approaches.

Abstract: An arrangement is provided for estimating type-cast sets of a program. Type-cast sets of a program are computed with respect to the declared types contained in the program.

Abstract: There is provided a method for generating a software module based upon elements from multiple software modules. The method includes the step of extracting a plurality of sets of elements from the multiple software modules based upon at least one extraction criterion. Any elements in the sets that violate at least one correctness and completeness criterion are identified. The violating elements are automatically brought into compliance with the at least one correctness and completeness criterion. A plurality of single software modules is generated, wherein each of the single software modules contains one of the sets of elements. The plurality of single software modules are composed to form a final, single software module.

Abstract: The present invention provides a system and method for automatically tagging documents with a given set of user-defined tags. The present invention takes as input the document to be tagged, and also a list of tags along with keywords belonging to these tags. The present invention then selects a tag, and scans the document for sentences that have keywords corresponding to the selected tag. Sentences that match the keywords are tagged with the selected tag. Once the whole document has been scanned, the present invention selects the next tag and repeats the whole process. This process is repeated until all tags have been seen.

Abstract: Provided are a method of creating multimedia content using a Synchronized Multimedia Integration Language (SMIL) and multimedia content created by the method. The multimedia content includes a first element and a second element. The first element has an attribute that initializes variables. The second element has an attribute that implements a memory function by expressing operations on the variables.

Abstract: A Linux kernel and an application software package are integrally installed at a target computer by using a CML2. Setup options of the application S/W package to be installed at the target computer are described in an option information file. The option information file of the application S/W package is converted into a CML2 rule file and the CML2 rule file of the application S/W package is then integrated with a CML2 rule file of the Linux kernel, thereby realizing integrated configuration of the Linux kernel and the application S/W package and preparing an environment where dependency rules between the Linux kernel and the application S/W package can be described. Since every option in the option information file has a file list and these file lists are stored in a file list table, an installation file list that describes files finally installed at the target computer can be easily generated.

Abstract: A method of parsing XML creates type-specific objects for object-oriented applications. The method includes acquiring the XML, associating the XML with a call, calling a code, and creating a type-specific object from the XML because of the code. The association may be implicit or explicit. The type-specific object is an object-oriented object, for example, a Java™ object, a C++ object, or some other object-oriented programming language class.

Abstract: The invention relates to a method of visualizing or graphically printing an automatism application programmed on a programming station (51) with the aid of graphic automatism languages (LD, SFC, FBD) on a computer terminal (54). Said method comprises a stage in which a source program (50) associated with an application program formulated in one of the graphic automatism languages is stored on the terminal (54), said source program being translated into a single, hierarchical object oriented language (XML); a stage in which at least one style sheet (52) associated with a graphic language is stored on the computer (54) in order to generate a graphic vector file (53) containing drawing instructions enabling the automatism application to be displayed graphically on the terminal (54).

Abstract: A method of automatically virtualizing core native libraries of a virtual machine is disclosed. In an embodiment, the virtual machine is a java virtual machine (JVM). In this technique, the interface between the virtual machine and the core native libraries is controlled, since multiple instances of a core native library are loaded into the same process based on the number of co-located applications. Moreover, the interactions between the core native libraries and the underlying operating system (OS) are controlled so that a single point of contact is presented to the OS. Also, the dependencies the core native libraries may have on the virtual machine are handled.

Abstract: This invention is related to a method for design and implementation of wide-area data sharing applications in the Internet and World Wide Web environment. The kernel of the invention is a middle tier that facilitates data integration over the Web. For each specific data sharing application, the middle tier is composed of an XML-based standard and an in-memory data structure. While the XML-based standard defines the syntax and semantics for the data to be shared and integrated, the in-memory data structure accommodates the data elements in a source-independent, relational format for manipulation in disconnected mode. The equivalency between the XML-based standard and the in-memory lays a solid basis for data integration over the Web. Data exchange in this distributed environment is realized by using Web services. Furthermore, the XML-based standard and in-memory data structure may also be extended to support distributed query processing and distributed transaction management in this environment.

Abstract: Programming language constructs called pronouns and referents, and a method, system, and apparatus for translating computer source code that contains the pronouns and referents. A referent is any semantic or syntactic construct in the source code (e.g., a statement, a portion of a statement, an expression, or a value) to which a pronoun refers. A pronoun is a programming-language defined source-code symbol or a sequence of symbols that refers to the referent. As a result, pronouns eliminate the need to define new names or macros for repeated program segments. When a translator encounters the pronoun in the source code, the translator searches the source code for the referent and substitutes the referent for the pronoun. Thus, by using pronouns and referents, the programmer can write programs faster and easier and eliminate program redundancy without losing readability.

Abstract: A method, apparatus, and software are disclosed for assisting a software developer in managing tasks to be completed by providing a task list as a unified location for developers to locate errors and warnings in code, as well as specify user-defined tasks. The task list is updated in “real time” as the developer completes tasks and generates new tasks.

Abstract: An automation tool for formulating an automation task to be solved, enabling the representation of automation functions in the form of objects on a display unit. These objects can be produced from a template and include at least one template-specific part and/or at least one object-specific part. The software tool is configured in such a way that a modification of template-specific parts (V1, V2, V3, Lv1, Lv2) in objects (Ob1—01, Ob2—01) is simplified, without any locally made adaptations being lost. The software tool modifies the template-specific parts (V1, V2, V3, Lv1, Lv2) in the objects (Ob1—01, Ob2—01) corresponding to the parts (Lv2, V5, Lv4, Lv5) modified in the template (Vo1) while preserving object specific parts (O1, O2, O3, O4, O5) that are specific to the objects (Ob1—01, Ob2—01), thereby producing modified objects (Obl_02, Ob2_02).

Abstract: A system and a method for automatic verification of complex enterprise software systems, which improves the testing process by producing test scenarios using business process specifications.

Abstract: According to some embodiments, an embedded programming language is provided to facilitate programming of an information packet processing unit.

Abstract: A mechanism for automatically generating code, in particular high level source code for remotely accessing functionality running in a remote process is provided. Given a specified set of functionality, which may be defined via an interface, for providing functionality to a local process, the mechanism generates, in source code form, software for remotely accessing the functionality by an application running in another process, that is, for accessing the functionality by an application running a second process. The code may be generated at build time but before the actual build of a software product implementing the functionality.

Abstract: A method of translating computer source code into optimized object code. The computer source code contains a first label statement defining a first label, a second label statement defining a second label, a third label statement defining a third label, and a computed goto statement for instructing a computer to branch to the first label or to the second label, but not to the third label. The method includes generating a list of labels contained within at least a portion of the computer source code. The list of labels includes the first label and the second label, but not the third label. The method also includes translating the computer source code into an intermediate language. The translation of the computer source code includes translating the computed goto statement into an indirect goto statement within the intermediate language. The method also includes generating object code that includes the first label and the second label but does not include the third label.