Abstract: A method for handling preprocessing in source code transformation creates a semantically correct view of a program being transformed. This semantically correct view is called a transformed form and it is capable of being parsed with a regular grammar. The original use of preprocessing macros is determined, including their relationship to the transformed form and the preprocessing is reconstructed in the modified source code.

Abstract: Methods for representing and evaluating dependency systems are provided. In one implementation a method is provided. The method includes receiving a file. The file includes a node array having data entries corresponding to one or more nodes. The file also includes an edge array having data entries corresponding to one or more edges, the edge entries identifying an invertability state of an edge, a suppressed state of an edge, and one or more partner edge linking a first and a second edge in the edge array. The method also include processing the received file. In another implementations a method for evaluating dependencies in a cyclic system is provided as well as a method for evaluating an enhanced directed dependency graph.

Abstract: One embodiment of the present invention provides a system that supports parallelized generic reduction operations in a parallel programming language, wherein a reduction operation is an associative operation that can be divided into a group of sub-operations that can execute in parallel. During operation, the system detects generic reduction operations in source code. In doing so, the system identifies a set of reduction variables upon which the generic reduction operation will operate, along with a set of initial values for the variables. The system additionally identifies a merge operation that merges partial results from the parallel generic reduction operations into a final result. The system then compiles the program's source code into a form which facilitates executing the generic reduction operations in parallel.

Abstract: An extensible generic command line parser may receive a list of options associated with an application and a command line to parse. A new command line option may be added to the options that can be parsed by adding the new command line option to the list of options. By receiving a modifiable list of valid options from an application, the parser is extensible, that is, instead of having to modify or recode the parser when a new option is added to the application, the new option may be added to the option file. When the parser receives the option list with the new option or options, any option in the file (including any new ones) may be automatically parsable by the parser.

Abstract: Methods and systems of detecting vulnerabilities in source code using inter-procedural analysis of source code. Vulnerabilities in a pre-existing source code listing are detected. The variables in the source code listing are modeled in the context of at least one of the inherent control flow and inherent data flow. The variable models are used to create models of arguments to routine calls in the source code listing. The source code listing is modeled with a call graph to represent routine call interactions expressed in the source code listing. The arguments to routine calls are modeled to account for inter-procedural effects and dependencies on the arguments as expressed in the source code listing.

Abstract: An apparatus, system, and method for the improved validation of information across a communications network provide a common validation rules library that may be accessed and executed either by a client or server. The provision of a minimal amount of logic either to the client or the server is achieved by generating only a requisite amount of validation logic. Furthermore, developers are enabled to reuse and build upon validation logic by subsequent validation logic inheriting validation logic from a parent rule.

Abstract: A method and system assembles state transition tables (100) from a plurality of modular sub-tables (102). In one embodiment, each sub-table (102) defines an individual statement in a programming language. Combining multiple sub-tables (102) together into one large table (100) creates a dictionary for a programming language that can be used to, for example, compile code into the programming language or translate code from one language to another. Using sub-tables (102) simplifies construction of the larger table (100) and makes it easier to add, modify, or remove portions of the table (102).

Abstract: The invention relates to a method and an automated system for determining the processing sequence of function blocks of a technological function. According to said method, a first function block, whose outputs are respectively disconnected or form exclusively one or more output signals of the technological function, is determined. Starting from said first function block, a second function block is sought in the opposite direction to the signal flow direction, whereby the block inputs of said second block are respectively disconnected or receive one or more input signals of the technological function only.

Abstract: An implementation tool for generating an implementation of a first data structure, wherein the first data structure comprises a plurality of linked structural components, and wherein the first data structure represents meaningful components of a given system and a parent set of interrelationships between those meaningful components, the tool comprising: first-data-structure input means, operable to receive a said first data structure, or a description thereof; and processing means operable to generate an implementation of the received first data structure, the implementation comprising: a second data structure, or a description thereof, corresponding to said first data structure, wherein said second data structure is defined by a subset of the parent set of interrelationships; and implementation rules which allow the parent set of interrelationships to be enforced during a subsequent processing operation which utilises said implementation.

Abstract: File paths for a plurality of IC design files in a hardware description language are abstracted by parsing description files, or a directory of description file names, to identify file paths to each of the plurality of design files in a first environment. An index is generated correlating each design file and its respective file path. In use, a file path in a second environment of an application is defined for each design file, and the index is applied to the file paths in the second environment to define full file paths for each design file through the first and second environments. The design files are then applied to the application using the full file paths.

Abstract: Automated (e.g., compiler implemented) techniques provide safe secure software development. One exemplary illustrative implementation addresses undefined behavior in the C and C++ programming languages.

Abstract: An event translator system for receiving input information, parsing event data on the input information to produce a result event data set and generating an event list based on an analysis of the event the result data set, performing an event listing and displaying event list to a user interface module. The event translation system translating event data also include receiving user feedback on the event listing and using the user feedback to improve subsequent operations of at least one harvesting algorithm. Translating event data also includes at least two harvesting algorithms for performing the input information to generate a plurality of result event data sets and creating an event listing for display to a user interface module based on an analysis of the plurality of result event data sets.

Abstract: In an embodiment of the invention, a method for lazy signal blocking, includes: when a program is going to enter a critical region of code where signals will be blocked, then setting an enabled flag and marking a signal mask with signals to be blocked, wherein the enabled flag and the signal mask are in a memory address space of the program; and when the program has left the critical region of code where signals will be blocked, then clearing the enabled flag.

Abstract: A special syntax is developed to differentiate between accesses to a primary and one or more secondary object protocols in a programming language. The syntax allows the compiler to differentiate between the primary and secondary object model based on syntax, rather than type. The syntax is created in such a way as to approximate the syntax of the secondary object model, and allows the user to dynamically generate member names.

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 display of the macro expansions in a graphical user interface of the tool, such as for source browsing or viewing static analysis.

Abstract: A method for analyzing a target system that includes obtaining a plurality of characteristics from the target system using a characteristics extractor and at least one selected from the group consisting of a software build project associated with the target system and a modified software build project associated with the target system, wherein the plurality of characteristics is associated with a characteristics model, storing each of the plurality of characteristics in a characteristics store, and analyzing the target system by issuing at least one query to the characteristics store to obtain an analysis result.

Abstract: A method for identifying a set of objects in a target application program includes: receiving a plurality of samples of one or more object reference graphs, wherein each object reference graph includes live objects and their references; deriving a set of candidate data structures from the samples; collecting a plurality of properties of each of the live objects in relation to data structures over time; and using a mixture model, combining the plurality of the properties of each live object in a non-linear manner for ranking leak root candidates within each set of candidate data structures The method also includes the identification of an initial set of highly-ranked candidate objects that are possible causes of at least one object leak, wherein the higher the ranking the smaller the identified set.

Abstract: A method and a system for selecting a desired language for text displays in a Java-Type language is provided. A localization class in the loadable Java program defines the text portions of the displays. At start of the application, the Java virtual machine loads this class and a determination is made, by user input or otherwise, of which of a group of languages available should be used for the text. Based on the determination, the static initializer Java-type code is invoked, and it loads the appropriate language text from a markup language document, preferably an XML document. The appropriate text segments from the markup language document are then used to initialize the variables. The application then can proceed to run as usual. Preferably, after the static initialization, the fields of the localization class are checked to confirm that all fields contain text.

Abstract: In order to facilitate automated operations with software, semantic meaning of data values is bound to the syntactic type of the data values. In a described implementation, a piece of software accepts inputs and produces outputs. The inputs have a specified syntactic type (e.g., runtime type) and an expected semantic meaning. The semantic meaning corresponds to a real-world description of relevant data for the input. Providing a data set that matches the specified syntactic type and the expected semantic meaning as input to the software enables a relevant operation with the software to be performed. An example automated operation is the testing of a piece of software. In another described implementation, a synmantic data object is created and/or utilized that includes a syntactic type attribute and a semantic meaning attribute for the contained data value(s). Other optional attributes include locale indication and a validity flag.

Abstract: A behavioral synthesis system which synthesizes behavior without inline expansion of a callee function, even one which has a pointer as an argument during the synthesis of a caller function. There is also a language analyzer that analyzes the behavior level description for conversion into an internal representation for behavioral synthesis and one which represents a correspondence relationship between a pointer variable and a circuit entity. There is also a pointer-terminal converter that converts a pointer into a set of a terminal and condition in the internal representation generated by the language analyzer. Further, there is a behavioral synthesizer that processes the internal representation from which the pointer variable has been removed by the pointer terminal converter to generate a circuit description at low abstractness.

Abstract: A method and system for incrementally processing program annotations is provided. A source model, a doclet model and a semantic model are used to represent and transform annotations incrementally. The source model represents actual types, fields, and methods that contain annotations. The doclet model includes doclet objects representing tags and attributes for a type, field, and method for a given namespace. Tag handlers registered for the given namespace detect changes in annotations and create or update doclet objects based on the changes. Changes in the doclet model are then transformed into the semantic model and may be persisted for restoration.

Abstract: The present invention provides a method and system for producing intermediate representation of source code listings with possibly mixed syntaxes to assist software development applications in presenting and analyzing the source code listings through reading the intermediate representation. A source code processor calls Application Programming Interfaces (APIs) to preserve source code information, which includes intermediate representation data sets and is preferably stored in a file-based repository. The source code processor is of a compiler, a preprocessor, a parser, or a comment document processor. The data sets capture lexical, syntax and semantic information of source code construct elements, and comprise of location, processor identification, construct category, and attribute data.

Abstract: A method, system, and computer program product are disclosed for automatic test generation for a compiler. In one approach, the method, system and computer program product represent a test case for the compiler in a structure with one or more elements of a programming language, associate at least one syntactic rule and semantic rule with the one or more elements in the structure, create a test with the structure compiling the test with the compiler, and display results of the test.

Abstract: Methods of developing an application program to manage a distributed system or network are provided. In one embodiment, the method includes: a) defining managed objects in a resource definition language and storing the definition in resource definition language files, b) parsing the resource definition language files to ensure conformity with the resource definition language and creating an intermediate representation of the distributed system, c) processing the intermediate representation to form programming language classes, database definition files, and script files, d) developing a reusable asset center framework to facilitate development of the application program, the reusable asset center including an SNMP agent framework that provides SNMP interface functionality to the application program, and e) building the application program from the programming language classes, database definition files, script files, and the reusable asset framework.

Abstract: In processing an external function for which source code is not available, such as an application program interface (API), a model is used to evaluate whether the external function is properly invoked. An error potentially resulting from improper invocation of the external function and at least one condition that will result in the potential error are identified. The model is created to test for the condition that will result in the potential error. When the condition is found, generation of an error message is triggered. The model is associated with a source code analyzer such that when the source code is analyzed by the source code analyzer, the model is applied to evaluate invocation of the external function. The potential error and conditions that result in the error, such as input/output parameter errors and dependency errors, may be derived from documentation describing the operation of the external function or API.

Abstract: The present invention uses annotations and SQL to retrieve and/or persist POJO data from/to a database, respectively. Using SQL will enable developers to unleash the full querying power of their chosen Database Management Systems (DBMS) and will remove the requirement that they learn a new query language. A minimal amount of annotations will be associated in the same Java® source file where each class of POJO to be persisted to the database is defined. An enhanced compiler is capable of analyzing the annotated source file and automatically generate the bytecode required to create, deploy, and manage the persistence of POJOs without requiring knowledge of specific details of the persistence to corresponding data entities in the underlining database. Therefore, such an approach decreases the time, knowledge, skill and ultimately cost required to persist POJOs to an underlying database. This description is not intended to be a complete description of, or limit the scope of, the invention.

Abstract: A system and method for a desk checker includes a partial state representation, a simulator controller to access the partial state representation and to continue a simulation without state information, and a desk checking component controlled by the simulator controller. The desk checking component includes any of a user interface, a static analysis engine, a partial execution component, and an analyzer. The system and method for desk checking includes simulating code execution on a computing device with partial state information and requesting user input to supplement the partial state information.

Abstract: A method, system and computer program product for handling errors in trace logs is presented. In an exemplary manner, the method includes detecting, in an error log, an error line entry for an error that is associated with a software execution. The error line entry includes a variable component and a static component. The variable component is associated with a real-time description of the software execution that changes every time the software execution occurs, and the static component is a fixed error descriptor of the error. The fixed error descriptor is parsed out from the error line entry to create a parsed static component, which is correlated with a resource that can be used to correct the error.

Abstract: Various embodiments of a method, apparatus, and article of manufacture for processing an extensible markup language (XML) script using an XML based scripting language are provided. The XML script is parsed. The XML script comprises element nodes. Each element node comprises a component name. A first element node comprises a first component name referencing a first user-defined component. An argument is passed to the first user-defined component. The argument is evaluated when an element node associated with the first user-defined component comprises an evaluate-component name that explicitly specifies that the argument be evaluated.

Abstract: In an implementation of an XML-based preprocessor, a programmed source file is parsed to generate a syntactic representation of the programmed source file. An XML (Extensible Markup Language) document is generated from the syntactic representation of the programmed source file, and a transform is applied to the XML document to generate a modified XML document from which an output file is generated in a format of the programmed source file.

Abstract: A method of validating binary code transformation in one aspect includes analyzing original program and transform program. Control flow graphs are generated for both programs. The two graphs are traversed to create respective linear invariant representations. The linear representations are compared to identify incorrect transformations.

Abstract: The automatic generation of schemas for XML documents is provided. In an illustrative implementation, a computer readable medium having computer readable instructions to instruct a computing environment to execute one or more inference algorithms is provided. In operation, an XML document is processed according to the computer readable instructions such that the content and tags of the XML document are identified. The XML document is processed according to an inference algorithm, which executes one or more processing rule, and uses the XML document information in conjunction with the rules and operations of the XML schema definition language, to automatically produce a schema for the XML document.

Abstract: A method for specifying equivalence of language grammars and automatically translating sentences in one language to sentences in another language in a computer environment. The method uses a unified grammar specification of grammars of different languages in a single unified representation of all the individual grammars where equivalent production rules of each of the grammars are merged into a single unified production rule. This method can be used to represent the equivalence of computer languages like high level language, assembly language and machine language and for translating sentences in any of these languages to another language.

Abstract: Status estimation is determined for an entity having a plurality of components. An original disjunction of diagnostic expressions indicating at least one of a fault-free or at least one fault mode for at least one of the components is determined, which is then investigated against a set of diagnostic test results, and expressions that do not imply the test result are discarded. Further, for each statement in the test result, a joint diagnostic expression is generated representing a conjunction of the statement and the currently investigated diagnostic expression. Joint diagnostic expressions that imply one of the original diagnosis expressions are discarded. Otherwise, they are added to an updated disjunction of diagnostic expressions. All remaining diagnostic expressions in the temporary disjunction of diagnostic expressions are then added to the updated disjunction of diagnostic expressions, and a status report is produced.

Abstract: A concept for providing a process for parsing at least one code object comprising determining when a page associated with the at least one code object has been previously processed; parsing the page when the page is determined not to have been previously processed; and evaluating a value for a compilation attribute for the page, is described.

Abstract: A method for implementing virtual method invocation when a compiled code of an invoked method is shared between class types that share a runtime representation is provided. In this method, an entry of an inline cache is set to a reference to an object. Subsequently, instructions for calling code are modified and the inline cache is set to be in one of an unresolved state, a monomorphic state, a shared monomorphic state, or a megamorphic state. A computer readable medium and a system for implementing virtual method invocation are also described.

Abstract: A method for parsing and verifying the contents of a command script containing a token and written in a scripting language. A first, relatively rapidly accessible data store and a second, less rapidly accessible data store are provided. Each data store contains function signature definitions which include a function name and an associated parameter list of zero or more parameter specifications. The first data store contains function names associated with commands that do not require data retrieval for completion. The second data store contains function names associated with commands that, unlike those in the first data store, do require data retrieval for completion. A potential function name and its associated arguments, if any, are recognized within the token. The first data store is searched for a matching function signature, having a function name matching the potential function name, and a parameter list matching the parsed potential function arguments.

Abstract: Described is a system and method for creating a runtime connection interface for attributes and element tags defined declaratively in a subclass within a markup document. These subclass attributes may define an event, and the element tags scoped inside a subclass may define a resource, and the like, associated with the subclass being defined within the markup document. During runtime, the runtime connection interface allows a parser to make direct calls to connect the subclass attribute with an associated instance of the subclass. The system and method include identifying an attribute or element tag defined within a markup document. The attribute or element tag is associated with a target element being declaratively defined within the markup document. The attribute may define an event, and an element tag resource, and the like, associated with a target element that is also declared within the subclass in the markup. An identifier for the target element is determined.

Abstract: Where a process in a computing system comprises mixed code, having different sections of code managed by different runtimes, the call stack used to coordinate function invocations may comprise call stack frames created according to multiple calling conventions. In order to analyze this call stack in a stack walk or unwinding, a debugger may be configured to request the runtimes managing the process to claim a particular call stack frame, and to request the runtime that claims it to parse the contents of the frame, or to utilize call stack analysis techniques if the call stack frame was created by unmanaged code.

Abstract: A loader section (102) for converting a program from a class file to a runtime execution format, a runtime saving section (103) for performing a runtime saving process by which a runtime execution format is converted to a temporary runtime execution format, a temporary runtime execution format storing section (302) for storing a temporary runtime execution format, and a post-loader section (105) for performing a post-loader process by which a temporary runtime execution format is converted to a runtime execution format are included, and determination is made whether or not there is a temporary runtime execution format in the temporary runtime execution format storing section when a start-up of a program is instructed, the loader section is requested to perform conversion to a runtime execution format if there is none, and the post-loader section is requested to perform conversion to a runtime execution format if there is any.

Abstract: A design supporting apparatus is disclosed, including: an inputting part; a syntactic analyzing part; and a scanning and searching part. The inputting part inputs functional description data of a register transfer level. The syntactic analyzing part conducts a syntactic analysis for the functional description data and develops a parse tree. The scanning and searching part scans and searches for the parse tree being developed by the syntactic analyzing part and searches for a description representing a comparison operator having multiple bits, the comparison operator being difficult to detect a fault by test data formed by pseudo-random numbers, which are applied from a pseudo-random number generator of a logic built-in self-test.

Abstract: The present comparison technique operates on objects having the same type, similar types, or different types. Multiple comparison objects may be compared against one or more reference objects. The comparison objects may be obtained from a prior cmdlet in a pipeline of cmdlets operating in an object-based environment. The reference object and comparison object may be compared in an order-based manner or in a key-based manner. In addition, specific properties may be specified which will identify which properties of the reference object and the comparison object to compare during the comparison. The comparison may generate an output that identifies the difference and/or similarities. The output may be pipelined to another cmdlet for further processing.

Abstract: A method and computer program product for detecting and diagnosing errors in a generic function call and then presenting them in an error message is disclosed. A generic function call is provided for evaluation. A corresponding generic function definition containing sets of dummy arguments that define arguments signatures for associated specific functions is also provided. In a first sorting the generic function call is compared with the argument signatures to determine whether the generic function call contains errors. A second sorting is then used to determine the nature of the errors. An error message describing the nature of the errors is then generated.

Abstract: The present invention generates state machines that can be used in a scanner and/or a parser for software program compilation. The state machines are not table-driven, but rather are encoded directly by creating jumps and branches in bytecodes, which are machine-independent codes generated by a Java compiler and can be executed on any Java-enabled device. Such state machines can be much faster than those based on tables, and much smaller in code size than those implemented in executable codes. In addition, such state machines can be optimized to reduce the number of states and the amount of codes required to encode each state in it. This can allow these state machines to meet strict code size restrictions specified by certain virtual machines, such as the Java virtual machine.

Abstract: The present invention provides a method and a compiler of compiling a source program. According to an aspect of the present invention, there is provided a method of compiling a source program comprising: identifying a hint related to vector aligning when syntax analyzing said source program; and generating a simplified code based on said identified hint related to vector aligning when generating a code.

Abstract: A system and method for providing a user interface system to develop an application having a first component with descriptors expressed in a structured definition language and a second component expressed as a series of instructions. The individual components interact for processing messages on a runtime environment of a device that are received from a data source over a network. The component applications comprise data components, presentation components, and message components, which are written in XML code. The component applications further comprise workflow components which are written in a subset of ECMAScript, and are augmented with the XML code. The user interface system comprises a first module, such as a viewer or and editor, for developing the definitions of the first component through interaction with a data model that provides a persistent state of the application.

Abstract: A method and system for Extensible Markup Language (XML) schema validation, includes: loading an XML document into a runtime validation engine, where the runtime validation engine includes an XML schema validation parser; loading an annotated automaton encoding (AAE) for an XML schema definition into the XML schema validation parser; and validating the XML document against the XML schema definition by the XML schema validation parser utilizing the annotated automaton encoding. Each XML schema definition is compiled once into the AAE format, rather than being compiled each time an XML document is validated, and thus significant time is saved. The code for the runtime validation engine is fixed and does not vary depending on the XML schema definition, rather than varying for each XML schema definition, and thus space overhead is minimized. Flexibility in the validation process is provided without compromising performance.

Abstract: An apparatus and program product generate difference data representative of modifications made to one release of a standard code base to facilitate the adaptation of later releases of the standard code base. The difference data is generated at least in part in connection with canonical parsing of a modified version of a release of a standard code base such that the difference data is representative of semantic changes made in the modified version.

Abstract: A graphical shader and a method of distributing graphical data to shader pipelines in a graphical shader are disclosed. In accordance with the method, a shader pipeline input delay is set. Further, a group of the graphical data is distributed to a shader pipeline of the graphical shader to be processed. The method includes waiting for the shader pipeline input delay to elapse. After the shader pipeline input delay has elapsed, another group of the graphical data is distributed to another shader pipeline of the graphical shader to be processed. In another embodiment, a graphical shader includes a plurality of shader pipelines for processing graphical data. Further, the graphical shader includes a shader distributor for distributing a group of the graphical data to one of the shader pipelines and for distributing another group of the graphical data to another one of the shader pipelines after a shader pipeline input delay has elapsed.

Abstract: A system to provide an extensible type repository environment can include one or more type repositories, each of which is capable of representing a type system and maintaining one or more type definitions, each representing a type in the type system. Each type repository can also define a type repository interface, which is capable of providing a standard set of services for use by the system in interacting with the type repository. In addition, a compiler is capable of translating types defined in one or more language modules into types defined in one or more type repositories, performing name resolution, maintaining and resolving dependencies among types during recompilation of the types. 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.