Abstract: An operation synthesis system includes a pipeline structure creating section for automatically creating, based on a state number assigned to a skip statement described in a high-level language in a transition to a pipeline operation and the number of cycles required to supply a pipeline with one loop designated by a user or automatically set by the system, a state transition including a loop controller and a loop leaving controller which are capable of conducting pipeline operation. It is therefore possible to transform a loop description described in a high-level language into a description of a circuit in a practical size for pipeline operation.

Abstract: A method for generating test cases for a program is disclosed. The method combines features of path-oriented and goal-oriented software testing. The illustrative embodiment constructs a control-flow graph with nodes that correspond to invocations of subroutines, and constructs control-flow graphs for the source code of such nodes as well. A metric that is based on the topology of the control-flow graph is evaluated recursively for nodes of the graph and for control-flow graphs that correspond to invoked subroutines. In the illustrative embodiment, the metric employed is the length of a shortest path from the starting node to a particular node. A node n with the highest metric value is then selected as a goal, and a path from the starting node to the ending node that passes through node n is generated via backtracking.

Abstract: Declarations from an input source code or tokenized source code are serialized into a stream of tokens produced by following each branch of a preprocessor conditional directive statement that interrupts a declaration. Tokens are labeled with a parsing path indicator corresponding to a parsing path induced by branches of a preprocessor conditional directive. The declarations that are formed along the different parsing paths are serialized by fetching the tokens that belong to the first parsing path in a first pass, and passing the tokens on to a next phase of a compiler. The pointer that marks the next token is repositioned to return to the start of the declaration. The declaration may be serialized again through the second parsing path in a second pass. The operation may be repeated until each of the parsing paths induced by the presence of branches of the preprocessor conditional directives in the source code is exhausted.

Abstract: A network device to determine the presence of one or more of the pre-defined strings in a message based on searching for a suffix and a reverse prefix in response to receiving a key search data indicating possible presence of any of the plurality of pre-defined strings. The network device indicates the presence or absence of one or more of the pre-defined strings in the message based on the suffix and prefix search results.

Abstract: A method and a system for template-based code generation. The method easily renders executable code using reusable customizable templates. The method further checks the templates for syntax errors prior to use. The system provides a memory and a processor for implementing template-based code generation.

Abstract: In an embodiment of the present invention, event handlers are used to trigger actions based on events occurring on a data stream. A process of the present invention involves creating the event handler, which may be embodied in, for example, software. The creation of the event handler involves parsing all of the rules in a manner that allows events themselves to trigger actions that will ultimately involve evaluation of rule and, if necessary, firing of those rules.

Abstract: Mechanisms for selective code generation optimization for an advanced dual-representation polyhedral loop transformation framework are provided. The mechanisms of the illustrative embodiments address the weaknesses of the known polyhedral loop transformation based approaches by providing mechanisms for performing code generation transformations on individual statement instances in an intermediate representation generated by the polyhedral loop transformation optimization of the source code. These code generation transformations have the important property that they do not change program order of the statements in the intermediate representation. This property allows the result of the code generation transformations to be provided back to the polyhedral loop transformation mechanisms in a program statement view, via a new re-entrance path of the illustrative embodiments, for additional optimization.

Abstract: A parser parses an application that comprises two or more different modules; the modules are bytecodes, object codes, and/or modules compiled using different programming languages. The parser identifies code statements in the modules or source code for the modules that correspond to common AST node types. A common AST node type is an abstraction of common elements in programming languages/bytecodes/object codes. Examples of code statements that are common in programming languages/bytecodes/object codes are branching, returns from functions, assignments, and the like. The use of common AST node types allows a user to generate different diagrams of the structure of the application. For example, a code flow diagram can be generated that allows a user to view the flow of code between the different modules implemented in different languages.

Abstract: A method for copy propagations of a processor including two clusters, each cluster comprising a first function unit and a second function unit, a first local register file and a second local register file being respectively accessible by the first and second function unit only, and a global register file having a ping-pong structure to access the first and second local register files, the method comprising the steps of: (a) listing possible copy propagation paths between two nodes of a data flow graph; (b) calculating a profit of machine cycles for each of the copy propagation paths according to constraints of the processor; and (c) performing a copy propagation through the copy propagation path if the profit thereof is greater than a threshold value.

Abstract: A method of dynamically analyzing source code to generate usage hints for a user performing program editing is disclosed. The functions in a collection of source code being edited by a user are processed so as to generate a parse tree data structure for each function called. The incoming and outgoing arguments in the parse tree are identified. Subsequently, a user editing code calls the function and either completely or incompletely enters the arguments as part of the function called. Input arguments are identified and associated with the corresponding argument in the parse tree for the function. Relevant preconditions and post-conditions of the surrounding nodes corresponding to the current location are analyzed. Usage hints are provided for the completion of the function call. Arguments for a completed function call argument entered by the user are validated. Error messages are delivered in the event of an invalid call.

Abstract: A control flow graph may be generated from a model. The control flow graph may be restructured by converting at least one unstructured region of a control flow graph into a structured region. The restructuring may include locating at least one block between two merge nodes in the control flow graph, moving the located block to a different section of the control flow graph, and creating the structured region by surrounding the moved code block with a test of a guard variable.

Abstract: Techniques for composition of model transformations from a predetermined set of model transformations. A state machine is provided in memory. The states are defined in the state machine in terms of predetermined model attributes. In response to specification of a target state for an input model to be transformed, an execution sequence in the state machine, between a start state corresponding to the input model and an end state corresponding to the specified target state, is selected. Each transformation in the selected sequence is then successively executed on the input model. After executing each transformation in the selected sequence, the transformed input model state is compared to the model state defined in the state machine to determine if the selected sequence is inoperable for the input model. If so, an alternative execution sequence in the state machine, between the input model state and the specified target state, is selected.

Abstract: A method for reviewing data dependencies in a document that includes requesting an explanation of a dependent data container in a plurality of data containers, in which the dependent data container resides within a document, and receiving the explanation of the dependent data container, in which the explanation that includes information about the dependent data container and information about a precedent data container of the plurality of data containers, and in which the information describes the dependency between the precedent data container and the dependent data container.

Abstract: An emulator allows subject code written for a subject processor having subject processor registers and condition code flags to run in a non-compatible computing environment. The emulator identifies and records parameters of instructions in the subject code that affect status of the subject condition code flags. Then, when an instruction in the subject code is encountered, such as a branch or jump, that uses the flag status to make a decision, the flag status is resolved from the recorded instruction parameters. Advantageously, emulation overhead is substantially reduced.

Abstract: A computer-implemented method for generating code based on a graphical model may include: translating the graphical model into a graphical model code, the graphical model code including a first graphical model code function; performing a lookup of the first graphical model code function in a hardware specific library, the hardware specific library comprising a plurality of relationships between graphical model code functions and hardware specific functions, where the first graphical model code function is one of the graphical model code functions; obtaining a matched hardware specific function based on the lookup, wherein the matched hardware specific function is one of the hardware specific functions from the hardware specific library; and modifying the graphical model code based on the matched hardware specific function.

Abstract: A method, system and computer program product for maintaining object referential integrity for abstract objects. In a method of the invention, the method can include extracting a reference to an abstract object hierarchy from an address disposed in markup, locating branches of nodes in the abstract object hierarchy which define a concrete object, and translating each located branch of nodes to an address for the concrete object. Notably, extracting a reference to an abstract object hierarchy from an address disposed in markup, can include extracting a reference to an abstract object hierarchy from a URL disposed in a Web page. Finally, the method can include changing a property of each node in the abstract object hierarchy that matches a specified class identifier.

Abstract: When writing code, data structures that include inferred symbols are created based on usage of undefined symbols. As the user continues writing code, code model can be updated to represent updated information based on a learning model. Data structures including inferred symbols can be used by software development tools to provide developer help for symbols that are not yet created or are not yet bound. Inferred symbols can be visually distinguishable making the appearance of the inferred symbol information differ from actual symbol information. The appearance of information based on inferred symbols can be included within tools by activating a particular mode in a programming environment. Conversion of the inferred symbol to a real symbol may trigger the automatic compiler-generation of additional source code by a background compiler. Inferred symbols may be converted to actual symbols by activation of an option to make an inferred symbol a real symbol.

Abstract: A method is provided for managing, in a computer system, design of a database system having a set of schemata. The method includes, in a first computer process, extracting dependencies from the database system and identifying the set of schemata. The method further includes, for each specific schema in the set of schemata, creating in a second computer process a partition that, in turn, contains a further partition for each element of the specific schema, so as to establish a hierarchy of partitions in accordance with the structure of the set of schemata. The method also includes storing a representation of the database system including subsystems, dependency relationships among the subsystems, and the hierarchy of partitions.

Abstract: A method and system for transforming documents from different domains into a common representation for viewing and editing is provided. The system prepares the domain-specific document for visual representation by performing a series of transformations in a pipeline that convert the document from its domain-specific input state to a series of intermediate languages. The intermediate languages share the same syntax regardless of the domain of the document being transformed.

Abstract: A system is disclosed for compiling program code. The system provides a compiler that includes a static verifier and a runtime verifier. The static verifier performs static checks on the program code and produces object code corresponding to the program code. The runtime verifier receives the object code and performs dynamic checks on the object code in a platform dependent environment. The resulting object code can subsequently be executed.

Abstract: Graphic object data binding is described. In an embodiment, the display of a graphic object having a visual property is updated when a trigger is received. The graphic object is updated by accessing a record of dependency data to determine a dependency of the visual property on stored source data, and updating the visual property of the graphic object on the display device in accordance with the source data. In another embodiment, a compiler receives source code comprising a statement binding the visual property of the graphic object to the source data. A processor reads the source code, detects the statement, generates a record of dependency data linking the visual property of the graphic object to the source data, stores the record of dependency data, and generates executable code. The executable code is output from the compiler, and can be executed by a computing device to display the graphic object.

Abstract: A mechanism is provided for adaptively assigning of a plurality of data management application instances to a plurality of data objects. The mechanism determines a processing load for a plurality of data management application instances for performing a data management task based on history data being descriptive of the data objects which have been affected by previous data management tasks, each of the data management application instances being assigned to at least one sub-section of a tree being descriptive of a storage structure of the data objects by means of a set of separation points for each one of the data management application instances. The mechanism adapts the separation points in the tree for balancing the expected processing loads of the data management application instances for a future data management processing task.

Abstract: An improved architecture for a program code conversion apparatus and method for generating intermediate representations for program code conversion. The program code conversion apparatus determines which types of IR nodes to generate in an intermediate representation (IR) of subject code (10) to be translated. Depending upon the particular subject and target computing environments involved in the conversion, the program code conversion apparatus utilizes either base nodes, complex nodes, polymorphic nodes, and architecture specific nodes, or some combination thereof, in generating the intermediate representation.

Abstract: Systems and methods are provided for identifying and displaying dependencies. One aspect of the invention comprises a system having a dependency parser that parses components of a system with dependencies and generates a plurality of component dependency pairs associated with the components, and a component dependency graph generator that generates a dependency directed graph from the plurality of dependency pairs. The system further includes a component levels and cycles analyzer that traverses the dependency directed graph to identify dependencies, strong components and component dependency levels associated with the dependency directed graph, and a graphical user interface that provides a tree view illustrating a dependency tree of the identified dependencies over the identified component dependency levels.

Abstract: Method and apparatus for translating a first program in a dynamically-typed language to a program in a hardware description language. From the dynamically-typed-language first program, a second program in single static assignment format is generated. For cases where a variable is assigned different data types at different places in the program, the assignments of the different data types are resolved for the variable. The second program is then translated to a program in the hardware description language.

Abstract: Comparison indices each for two components incorporated in a source program are used for easy and quantitative evaluation of functional redundancy in the program, effective and accurate extraction of redundant code segments from the program and also effective and accurate extraction of components to be modified simultaneously. A tree T is entered and an initial level of functional redundancy m(P) is set at 0 in a program P expressed by the tree T. The top node of the tree T is selected as a node N. A specific computation is performed for the top node selected as the node N with attribute information including the similarity and the number of children of the node N to obtain a level ?. The level ? is added to the functional redundancy m(P). The specific computation is performed for every node in the tree T, to obtain functional redundancy m(P) including the total of ? for all nodes.

Abstract: If a program is to be transmitted/received by message transmission/reception using SOAP, the program description part goes out of the framework of XML, and the message contents contain an uninterpretable part. A SOAP message (M1) includes a data part (D1), a virtual service part (R1) indicating specifications to process the data part (D1), and a program part (P1). A server (S1) processes the data part (D1) by the specifications indicated by the virtual service part (R1) if the virtual service part (R1) in the SOAP message (M1) indicates the specification of processing to be executed by the instruction executed when executing the instruction contained in the program part (P1) of the SOAP message (M1).

Abstract: A technique in accordance with one embodiment of the invention automatically generates class interfaces for regular expressions based on graphs that correspond to the regular expressions. According to one embodiment of the invention, a graph is automatically generated based on a regular expression. Strongly connected components within the graph are automatically identified. For each strongly connected component within the graph, a separate method is generated within a class interface for the regular expression. In one embodiment of the invention, if a strongly connected component contains a cycle, then the method corresponding to that strongly connected component is generated to return a List of “T,” where “T” is a type that is as specific as the contents of the strongly typed component permit.

Abstract: Provided are techniques for optimizing the processing of hierarchical data. A linear processing graph is received, wherein the linear processing graph includes a plurality of operators, wherein each operator in the plurality is connected to at least one other operator by an arc, wherein hierarchical data flows on arcs, wherein the operators read and replace identified subregions within the hierarchical data flowing into the operators on the arcs, and wherein the operators do not modify the hierarchical data outside of these identified subregions.

Abstract: A method for producing parallel computer programs by using a compilation method that produces executable computer programs having an undefined execution order. The execution order is defined during execution of the program depending on the execution architecture. This allows the best possible level of concurrent execution in different architectures. The compilation method includes producing data dependency and data flow graphs that are used for executable code generation.

Abstract: An application-specific client for object-oriented processing of markup includes a model object and a plurality of element objects. The model object is configured to respond to client requests including construct-element, accept-root-element, and accept-root-text. The element objects are configured to respond to client requests including accept-attribute, accept-element, and accept-text. Responses to requests contain application-specific processing as necessary. A driver generates client requests in response to processing of XML markup. An RSS client processes markup describing syndicated web content to HTML markup.

Abstract: Techniques for use in telecommunications products and services for processing XML-type (e.g., CCXML or VXML) documents in association with the operation of a telecommunications network include parsing a XML-type document a single time for all instruction execution relating to the XML-type document for generating an XML-type reference document. Compiling the XML reference document occurs next for generating a XML-type binary reference file comprising a plurality of binary data sets derived from the XML-type reference document. Then, the method and system convert the XML-type binary reference file to an object tree for use of the contents of the XML-type binary reference file at essentially execution speeds. The method and system provide for storing data in a cache memory, the data relating to the XML-type binary reference file at a point essentially approximating the execution point of the data in the processing of the XML-type document.

Abstract: Instructions in an asynchronous transactional messaging language are transformed into instructions that are compatible with the web services. In one embodiment, the asynchronous transactional messaging language is XLANG/s, and the web service languages are the web services description language (WSDL) and the simple object access protocol (SOAP). A programmer simply writes high level declarative statements that pertain to the specific type of business transaction. During compilation, selected instructions are transformed into instructions that are compatible with web services. This transformation is transparent to the designer of the business application. The asynchronous transactional messaging language source files are compiled in an iterative compilation process. During each pass of this compilation process, different variables are parsed. The parsed results are logically organized in a tree structure. The tree structure is traversed in depth first traversal order.

Abstract: A system and method for facilitating analysis and modification of a computer program. A directed graph is generated from an intermediate language representation of a computer program function, with a node representing each instruction. Meta-edges or meta-nodes are inserted into the directed graph to facilitate location of instruction nodes. One type of meta-edge is a back edge that identifies branch instruction nodes. Some meta-nodes may identify instructions of a specific type. Some meta-nodes may identify exception blocks and corresponding handlers. Analysis of a program function may include insertion of new instructions prior to execution of the function.

Abstract: Systems for creating, generating, distributing and applying self-contained modifications (i.e., changes) to source code are described herein. At least some embodiments include a system including a client computer with processing logic, a storage device (including source code files), and a communication interface. The interface receives a container file including a transformation including a search pattern that identifies source code segments, and transformation instructions that modify the source code based at least partially on identified code segments. Processing logic software searches a representation of the source code for search pattern occurrences, and identifies the source code segments that include elements with structure and relationships that are matched by the corresponding elements represented by the search pattern.

Abstract: One aspect of the invention is a transaction processing system comprising a software service operable to receive a transaction request and to generate a first object associated with the transaction request. An object generator may convert the first object into a first document written in a self-describing language. A document generator may convert the first document into a first transaction message according to a schema associated with a first transaction type determinable from the first document.

Abstract: A front end component and a technique are provided. The front end component allows a transformation rule writer to specify syntax structure of interest, as well as what action to take when a syntax structure of interest is found. Example syntax structures include function call, variable declaration, math expression, etc. Typical actions include matching, replacement, or copying. The technique allows transformation tool writers to translate the specification into actual query and manipulation commands on the program representation. It is structured to be target language agnostic and, therefore, can be easily re-targeted to different programming languages.

Abstract: Those files accessed by tools during a build process are invisibly tracked in such a way that the information can then be used to drive an incremental build of just enough files to bring the build fully up to date. The tracking information includes the association between distinct tool processes. Each build tool has its own file activity tracked, each thread of operation within tools are tracked separately and a tracking log is associated with a chain of tool processes so that when the tracking logs are interpreted the context in which they were created is preserved.

Abstract: A method and system for providing help information for a computer program. The help system provides help information based on a schema that specifies the structure of a valid computer program. The schema provides definitions of program element types that are specific instances of a program element type derived from more general program element types. The help system identifies a “derivation” of program element types relating to the selected program element. The help system then displays the derivation to the user. The user can then select to display documentation associated with the displayed program element types.

Abstract: In some embodiments, a method and apparatus for automatically parallelizing a sequential network application through pipeline transformation are described. In one embodiment, the method includes the configuration of a network processor into a D-stage processor pipeline. Once configured, a sequential network application program is transformed into D-pipeline stages. Once transformed, the D-pipeline stages are executed in parallel within the D-stage processor pipeline. In one embodiment, transformation of a sequential application program is performed by modeling the sequential network program as a flow network model and selecting from the flow network model into a plurality of preliminary pipeline stages. Other embodiments are described and claimed.

Abstract: The present invention is directed to a method for processing, in a computer system, a computer program having a plurality of operations. The method features calling a dynamic programming routine to generate a schedule for executing a subgroup of the plurality of operations by modeling operations of a computational processor associated with the computer system to minimize a computational cost of placing the computer system in a final machine state (finMS).

Abstract: A method, apparatus, and computer program product are provided by the present invention for a programming framework for easy pattern matching and transformation of intermediate language expression trees. With expression matching and transformation framework (EMTF) of the present invention, pattern matchers may be defined and embedded in a C++ program code in a manner that resembles their intermediate representation. EMTF also provides capabilities for unification, unbinding, transformation, intra-pattern referencing, common operators, creation of pattern objects in a storage pool. Recursive sub-expression matching and recursive transformation are also included.

Abstract: Methods and systems for manipulating information represented by computer code are described. Macroinstructions that are used to analyze an input are accessed. The macroinstructions are written according to a first computer system language. The macroinstructions are rewritten as strings according to a second computer system language. The strings are included in an exportable representation.

Abstract: A method and apparatus for use in compiling data for a program shader identifies within data representing control flow information an area operator definition instruction statement located outside the data dependent control flow structures. The method identifies within one of the data dependent branches at least one area operator use instruction statement that has the resultant of the area operator definition instruction statement as an operand. After identifying the area operator use instruction statement, the area operator definition instruction statement is placed within the data dependent branch.

Abstract: Systems and methods are provided that service a JavaServer Page (“JSP”), including receiving a request for a JSP page, parsing source code for the JSP page, creating a tree of the parsed source code. executing the tree in memory, and returning the requested JSP page. Accordingly, JSP pages do not require repeated recompilation, and JSP pages with customized content may be quickly regenerated with a low performance overhead.

Abstract: A method for automatic code generation that includes obtaining a parse tree, wherein the parse tree represents at least one instruction and wherein the instruction is in a natural language, and wherein the at least one instruction is free-form, determining a plurality of sentence subparts from the parse tree, creating at least one instantiated concept for each of the plurality of sentence subparts, inserting the instantiated concept in an instantiated concept map, traversing the instantiated concept map, wherein traversing the instantiated concept map includes for each instantiated concept in the instantiated concept map obtaining a code output rule according to the instantiated concept, and outputting code according to the code output rule be completed upon finalization of claims.

Abstract: A compiling program with cache utilization optimizations employs an inter-procedural global analysis of the data access patterns of compile units to be processed. The global analysis determines sufficient information to allow intelligent application of optimization techniques to be employed to enhance the operation and utilization of the available cache systems on target hardware.

Abstract: Architecture allows a programmer to answer questions about the source code the programmer is authoring, questions that cannot be answered by other means. A searching mechanism is provided over a much more structured presentation of the source code. The architecture utilizes components that provide an intimate knowledge about the structure of the text, namely, the source code of some particular programming language. The search mechanism employs an abstract syntax tree representation of the code over which the search is conducted. The program source code (as edited by the programmer) is transformed into the abstract syntax tree to embody the structure of the program. If the syntax tree is provided in XML, for example, an XML search mechanism such as Xpath can be utilized to perform the actual searching. This tree is then queried, allowing richer searching criteria to be expressed (by virtue of the structured format of the tree).

Abstract: The subject matter disclosed herein provides methods and apparatus, including computer program products, for navigating abstract syntax trees. In one aspect there is provided a method. The method may include receiving a plurality of nodes, the nodes configured as an abstract syntax tree representing program code. The method may also include identifying at least one node from the plurality of nodes by navigating the plurality of nodes using a path expression. Related systems, apparatus, methods, and/or articles are also described.

Abstract: Tools and methods are described herein that allows for measuring and using the relationship between artifacts of a software design, such as requirements, test plans, and so on. The relationship can be quantified by determining a relationship quotient for quantifying a similarity between components of software design artifacts and presenting the quantified relationships to a user, such as a software designer, so that he or she can account for the relationship between such components during design changes and so on. The relationship quotient is made more representative of substantive similarity by selecting the key terms that are to be submitted to a similarity analysis such that words that are too common in the English language, such as conjunctions, articles, etc., are not used. Ubiquity of certain key terms in an enterprise is accounted for by adding a term significance weight to the similarity analysis.