Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees


Analysis of code form

Subclass of:

717 - Data processing: software development, installation, and management

717100000 - SOFTWARE PROGRAM DEVELOPMENT TOOL (E.G., INTEGRATED CASE TOOL OR STAND-ALONE DEVELOPMENT TOOL)

717136000 - Translation of code

717140000 - Compiling code

Patent class list (only not empty are listed)

Deeper subclasses:

Class / Patent application numberDescriptionNumber of patent applications / Date published
717143000 Parsing, syntax analysis, and semantic analysis 55
717144000 Including graph or tree representation (e.g., abstract syntax tree or AST) 14
717142000 Scanning and lexical analysis 10
Entries
DocumentTitleDate
20110202906COMPILING METHOD AND COMPILING PROGRAM - A compiling method for translating an input program to an object program enables a user to easily ascertain how the input program and the object program are affected by designation of a plurality of extended language specifications. The compiling method includes: analyzing, in the case where the plurality of extended language specifications are designated in the input program, the designated plurality of extended language specifications, to determine which part of the input program is affected by the designated plurality of extended language specifications; and outputting information about the part, together with the object program.08-18-2011
20080256523Computerized Data Warehousing - A system and method for transforming data from a first format to a second format. A pre-existing set of software instructions may be used to transform the data from the first format to the second format. A user may document a set of format parameters for the first format of data, which can be used to determine which portion of the pre-existing software instructions are used to transform the data from the first format to the second format.10-16-2008
20080307399GENE EXPRESSION PROGRAMMING BASED ON HIDDEN MARKOV MODELS - Computer programs (12-11-2008
20120192162Optimizing Handlers for Application-Specific Operations for Validating C++ Programs Using Symbolic Execution - Particular embodiments discover a relationship between a plurality of methods of a C++ object; define one or more rules to represent the relationship; verify the rules by symbolically executing the methods; and if the rules are verified, then use the rules when symbolically executing the methods so that bytecode of the methods is not executed.07-26-2012
20090094588METHOD AND SYSTEM FOR PROGRAM TRANSFORMATION USING FLOW-SENSITIVE TYPE CONSTRAINT ANALYSIS - A method for analyzing a program is provided. The method includes, determining an object type that may exist at an execution point of the program, wherein this enables determination of possible virtual functions that may be called; creating a call graph at a main entry point of the program; and recording an outgoing function call within a main function. The method also includes analyzing possible object types that may occur at any given instruction from any call path for virtual calls, wherein possible object types are determined by tracking object types as they pass through plural constructs; and calling into functions generically for handling specialized native runtime type information.04-09-2009
20110029960ENCAPSULATING AND MANAGING DIAGNOSTIC INFORMATION - The disclosed embodiments provide a system that encapsulates and manages diagnostic information. During operation, the system detects an event that generates diagnostic information, and stores this diagnostic information in a format that preserves semantic information associated with the event. The system also determines an output context (e.g., the intended target environment) for the diagnostic information, and then uses the preserved semantic information to output the diagnostic information in a context-sensitive format suited for the output context. Note that outputting customized diagnostic information that is adapted to a specific target environment facilitates improving the quality of diagnostic information presented to a user.02-03-2011
20100070955ALIAS ANALYSIS FOR CONCURRENT SOFTWARE PROGRAMS - A computer-implemented pointer alias-analysis for concurrent software programs utilizing a divide-and-conquer approach, transaction level summarization and parallelization.03-18-2010
20090094587INFORMATION PROCESSING TERMINAL AND PROGRAM - An information processing terminal capable of specifying function information of a Jar file not to read the function information from a Jad file in which the function information of the Jar file are described, and a program used to specify the function information of the Jar file are provided.04-09-2009
20090288073Edit Time Analyzer in a Loosely Typed Textual Language - Analyzing code written in a loosely typed language. User input specifying code for a script may be received. The specified code may be analyzed. More specifically, one or more code portions referenced by the specified code may be determined. Properties of symbols of the specified code and the one or more code portions may also be determined. Additionally, the specified code may be analyzed using the determined properties to determine errors in the specified code. Accordingly, one or more errors may be graphically indicated based on said analyzing. Receiving the user input, analyzing the specified code, and graphically indicating the one or more errors may be performed at edit time.11-19-2009
20080271000Predicting Conflicts in a Pervasive System - A method of predicting conflicts in a system is described which uses a process calculus to describe programs and actions within the system. The source code for programs is transformed into an expression in the process calculus and then the reduction rules for the process calculus can be applied to the expressions for the various programs and actions. Analysis of the resultant reduced expression(s) enables potential conflicts to be identified.10-30-2008
20110173594Selective Loading of Code Elements for Code Analysis - Systems and methods are described herein for selectively loading code elements included in a plurality of software entities comprising a target software entity and one or more reference software entities to facilitate analysis of the target software entity by a code analysis tool, such as a static code analysis tool. In one embodiment, all of the code elements in the target software entity are loaded while only those code elements included in the reference software entities that are determined to be most important from a dependency standpoint are loaded. The loaded code elements may be used to obtain suitable definitions of the code elements included in the target software entity for the purpose of code analysis.07-14-2011
20100005456COMPILING METHOD, COMPILING APPARATUS AND COMPUTER SYSTEM FOR A LOOP IN A PROGRAM - A method for compiling a program including a loop is provided. In the program, the loop includes K instructions (K>2) and repeats for M times (M>2). The compiling method comprises following steps: performing resource conflict analysis to the K instructions in the loop; dividing the K instructions in the loop into a first combined instruction section, a connection instruction section and a second combined instruction section, wherein there is no resource conflict between the instructions in the first combined instruction section and the instructions in the second combined instruction section respectively; and compiling the program, wherein the instructions in the first combined instruction section in the cycle N (N=2, 3, . . . M) and the instructions in the second combined instruction section in the cycle N−1 are combined to be compiled respectively. A compiling apparatus and a computer system for realizing the above-mentioned compiling method are further provided.01-07-2010
20080229292Validator-Driven Architecture of an XML Parsing and Validating Solution - A method for parsing a document in an Extensible Markup Language (XML) format includes identifying data via the XML format, defining a tag set including a plurality of tags, defining a tokenizer that produces one token at a time, parsing the XML document via a parser, validating the XML document via a validation engine, the validation engine driving the tokenizer, the validating being an integral part of the parsing, and permitting the validation engine to be written in a recursive-descent code-driven manner.09-18-2008
20080235674COMPILER METHOD OF EXPLOITING DATA VALUE LOCALITY FOR COMPUTATION REUSE - A compiler method for exploiting data value locality for computation reuse. When a code region having single entry and exit points and in which a potential computation reuse opportunity exists is identified during runtime, a helper thread is created separate from the master thread. One of the helper thread and master thread performs a computation specified in the code region, and the other of the helper thread and master thread looks up a value of the computation previously executed and stored in a lookup table. If the value of the computation previously executed is located in the lookup table, the other thread retrieves the value from the table, and ignores the computation performed by the thread. If the value of the computation is not located, the other thread obtains a result of the computation performed by the thread and stores the result in the lookup table for future computation reuse.09-25-2008
20080235673Method and System for Measuring Database Programming Productivity - A method for measuring database programming productivity is disclosed. The method quantifies the database programming effort, which can then be used to calculate the software productivity for database development.09-25-2008
20100281471METHODS AND APPARATUSES FOR COMPILER-CREATING HELPER THREADS FOR MULTI-THREADING - Methods and apparatuses for compiler-created helper thread for multi-threading are described herein. In one embodiment, exemplary process includes identifying a region of a main thread that likely has one or more delinquent loads, the one or more delinquent loads representing loads which likely suffer cache misses during an execution of the main thread, analyzing the region for one or more helper threads with respect to the main thread, and generating code for the one or more helper threads, the one or more helper threads being speculatively executed in parallel with the main thread to perform one or more tasks for the region of the main thread. Other methods and apparatuses are also described.11-04-2010
20100138815IMPLEMENTING ASPECTS WITH CALLBACKS IN VIRTUAL MACHINES - Implementing aspects via callback in a virtual machine, where an aspect weaver weaves the aspect with a module to provide primary and crosscutting functionality in the runtime execution of the module. The virtual machine has multiple modules that are part of an application implementing separation of concerns. Each of the multiple modules has a distinct functionality portion and a common functionality portion, common to all modules. The common functionality is referenced by the virtual machine via callback for the multiple modules. Aspect code is loaded as a callback that is applied to the multiple modules by the virtual machine. Loading the aspect code as a callback can implement the aspect at any point in the modules, including conditional statements, calls to methods of objects or classes, loops, any point in an exception handler, or to monitor changes in variables.06-03-2010
20090172648BYTE CODE ANALYSIS LIBRARY - A method to obtain offline source code is described. The system implementing the method extracts metadata from offline source code an constructs a logical model of the extracted metadata.07-02-2009
20090024987METHOD AND SYSTEM FOR FACILITATING THE UTILIZATION OF COMPLEX DATA OBJECTS - Computer implemented method, system and computer usable program code for facilitating utilization of data. A computer implemented method for facilitating utilization of data includes receiving data, wherein the received data is in a first representation. The received data is converted from the first representation to a common representation that is mapped to the first representation using an external configuration file. The common representation of the data is output to facilitate utilization of the data.01-22-2009
20100169870System and Method for Reducing Transactional Abort Rates Using Compiler Optimization Techniques - In transactional memory systems, transactional aborts due to conflicts between concurrent threads may cause system performance degradation. A compiler may attempt to minimize runtime abort rates by performing one or more code transformations and/or other optimizations on a transactional memory program in an attempt to minimize one or more store-commit intervals. The compiler may employ store deferral, hoisting of long-latency operations from within a transaction body and/or store-commit interval, speculative hoisting of long-latency operations, and/or redundant store squashing optimizations. The compiler may perform optimizing transformations on source code and/or on any intermediate representation of the source code (e.g., parse trees, un-optimized assembly code, etc.). In some embodiments, the compiler may preemptively avoid naïve target code constructions. The compiler may perform static and/or dynamic analysis of a program in order to determine which, if any, transformations should be applied and/or may dynamically recompile code sections at runtime, based on execution analysis.07-01-2010
20100162218RELAXED AND EXTENDED DELEGATES - Systems and methods that enhance expressibility in a programming language (e.g., Visual Basic) via relaxation of artificial restrictions and extension of delegates associated therewith, without changing the runtime infrastructure. A stub is employed that can replace an impermissible expression in the programming language, to leverage the existing permissible expressions.06-24-2010
20100211938SCHEMA-BASED DYNAMIC PARSE/BUILD ENGINE FOR PARSING MULTI-FORMAT MESSAGES - A parse/build engine that can handle multi-format financial messages. The engine converts the different format messages into a common format, and the common format message is then processed by the business service application. A parser examines the message and determines an appropriate schema for the particular format of message received. The schema is a data structure in a schema registry that includes a grammar structure for the received format as well as pointers to handlers for converting the different fields of the message into the internal message format using the grammar structure (the “grammar” can include field sequence, field type, length, character encoding, optional and required fields, etc.). The handlers are individually compiled. As formats change, new formats or changes to old formats can be dynamically added to the parse/build engine by loading new schema and handlers.08-19-2010
20090019430METHODS AND ARRANGEMENTS FOR UNIFIED PROGRAM ANALYSIS - A unified program analysis framework that facilitates the analysis of complex multi-language software systems, analysis reuse, and analysis comparison, by employing techniques such as program translation and automatic results mapping, is presented. The feasibility and effectiveness of such a framework are demonstrated using a sample application of the framework. The comparison yields new insights into the effectiveness of the techniques employed in both analysis tools. These encouraging results yield the observation that such a unified program analysis framework will prove to be valuable both as a testbed for examining different language analysis techniques, and as a unified toolset for broad program analysis.01-15-2009
20100223604MODULE SYSTEM FOR POLYMORPHIC PI-CALCULUS - A method and apparatus is disclosed herein for using a module system for polymorphic π-calculus. In one embodiment, the method comprises receiving a formal specification of a software program; and performing automatic analysis on the formal specification using a module system fitted with processes of the polymorphic π-calculus processes.09-02-2010
20090070751Methods and apparatus for generating branchless code for select statements - In one embodiment, the present invention includes a method for determining whether a select statement can be transformed, and if so selecting a first or second transformation operation based on compiler-evaluated values for certain variables of the select statement, performing the selected transformation operation to obtain at least one new statement, and replacing the select statement with the at least one new statement. Other embodiments are described and claimed.03-12-2009
20110154306Methods And Apparatuses For Endian Conversion - An embodiment of the invention includes code, such as a compiler, that enables byte order dependent code to execute on opposite byte order dependent architectures or systems. The compiler analyzes source code and produces diagnostic reports that indicate where source code changes are desirable to produce “endian neutral” source code versions that are compatible with opposite byte order dependent architectures or systems. Such source code changes may be desirable for code portions that will produce implicit byte order changes or byte order border crossings. The modified source code that is generated may include the semantics of the desired endian conversion, as opposed to generated executable code that includes proper endian formats but which may limit the architectures to which the code is applicable.06-23-2011
20100306749Software Analysis Framework - Presently described is a decompilation method of operation and system for parsing executable code, identifying and recursively modeling data flows, identifying and recursively modeling control flow, and iteratively refining these models to provide a complete model at the nanocode level. The nanocode decompiler may be used to determine if flaws, security vulnerabilities, or general quality issues exist in the code. The nanocode decompiler outputs in a standardized, human-readable intermediate representation (IR) designed for automated or scripted analysis and reporting. Reports may take the form of a computer annotated and/or partially human annotated nanocode listing in the above-described IR. Annotations may include plain English statements regarding flaws and pointers to badly constructed data structures, unchecked buffers, malicious embedded code or “trap doors,” and the like. Annotations may be generated through a scripted analysis process or by means of an expert-enhanced, quasi-autonomous system.12-02-2010
20110179403SYSTEM AND METHOD FOR ANNOTATION-DRIVEN FUNCTION INLINING - Disclosed herein are systems, methods, and computer-readable storage media for obfuscating using inlined functions. A system configured to practice the method receives a program listing including annotated functions for obfuscation, identifies an annotated function called more than once in the program listing, and creates an inline control flow structure in the program listing for the identified annotated function, the control flow structure being computationally equivalent to inlining the identified annotated function into the program listing for each occurrence of the identified annotated function. The program listing can include tiers of annotated functions. The system can identify annotated functions called more than once based on an optionally generated callgraph. The system can create inline control flow structures in the program listing in order of annotation importance. The system can identify how many times each annotated function is called in the program listing.07-21-2011
20120072890UNIFIED DATA TYPE SYSTEM AND METHOD - A type system includes a dual representation for basic data types. One representation is the basic data type representation common to such basic built-in data types, known as an unboxed value type or simply as a value type. Each of the basic data types also has a boxed representation that can be stored in the object hierarchy of the type system. This dual representation can also be extended to user-defined types, so that user-defined types may exist both as an unboxed value type and as an object within the object hierarchy of the type system. This dual representation allows the compiler and/or runtime environment to select the most effective and efficient representation for the data type depending on the particular need at the moment.03-22-2012
20110191756Code string search apparatus, search method, and program - A code ID range table holding code ID ranges for each code and a next code ID table holding next code IDs, which are the code ID located next to each code ID, are created. Code ID ranges of codes configuring a search code string are read out from the code ID range table for the search target code string, and the stored next code ID corresponding to a code ID included in the code ID range of the head code in the search code string is read out from the next code ID table while the stored next code IDs corresponding to the next codes are successively read out from the next code ID table, and the next code ID read out from the next code ID table is verified whether it is included in the code ID range read out from the code ID range table.08-04-2011
20120096446PARSING OF DECLARATIONS IN ALL BRANCHES OF PREPROCESSOR CONDITIONALS - 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.04-19-2012
20130125101HOSTABLE COMPILER UTILIZING TYPE INFORMATION FROM A HOST APPLCIATION - A hostable compiler interacts with a host application to enable the host application to execute program code supported by the hostable compiler. The host application and the hostable compiler exchange data through an interface that allows the hostable compiler to receive type information pertaining to data elements used applications executing within the host application process. This type information may then be used by the hostable compiler in the compilation of source code to infer a type for data elements used in the source code that are not declared yet associated with a value of an expression used in an application executed within the host application process.05-16-2013
20130152060DUAL MODE EVALUATION FOR PROGRAMS CONTAINING RECURSIVE COMPUTATION - A dual evaluation mode method for use with computer software that includes the acts of determining, for certain functions and expressions within input computer code, whether each function and expression may have any recursive dependencies, generating eager evaluation mode executable code for one or more elements of the input computer code based on the act of determining and providing both eager evaluation mode executable code and non-eager evaluation mode executable code to runtime software that supports both eager and non-eager evaluation modes.06-13-2013
20100318976METHOD AND SYSTEM FOR CONSTRUCTING A CUSTOMIZED WEB ANALYTICS APPLICATION - A method for constructing a customized web analytics application comprises providing a base analytics code, including a base data mining code and a plurality of tokens corresponding to unincorporated code snippets, and incorporating code snippets as selected to create the application where each code snippet is configured to track a different custom web analytic. The system displays a selection of at least one web analytic to track and receives user selection of at least one displayed web analytic to track over a wide area network. Once selected, an unincorporated code snippet corresponding to each selected displayed web analytic is retrieved from a library of such code snippets. The code snippet is then substituted in place of its corresponding token within the base analytics code to create a customized analytics code. The customized code is finalized by removing the remaining tokens and the finalized code transmitted to the user for incorporation into their web pages.12-16-2010
20130205283Any-To-Any System For Doing Computing - Methods for constructing an Any-to-Any data machine (consisting of Any-to-Any data components and their environmental requirements) and an Any-to-Any code machine (consisting of Any-to-Any code components and their environmental requirements) and relating them together so that they harmoniously interact and so that the data Any-to-Any machine controls and is also acted upon by the code Any-to-Any machine so as to produce an Any-to-Any system that transforms data in a manner that is useful and which is analogous to the harmonious interaction of the Any-Any binary code and Any-to-Any transistor systems, and which handles data and transforms it in a sufficiently similar manner to the manner in which the human handles and transforms data that the human finds it easy and intuitive to operate, all supported by methods that enable data to be stored in a single logical grid structure that can accept and correctly relate, transmit and receive any data, together examples of methods to derive benefits from these inventions.08-08-2013

Patent applications in class Analysis of code form

Patent applications in all subclasses Analysis of code form