764 results about "Intermediate language" patented technology

An automated analysis system identifies the presence of malicious P-code or N-code programs in a manner that limits the possibility of the malicious code infecting a target computer. The target computer system initializes an analytical virtual P-code engine (AVPE). As initialized, the AVPE comprises software simulating the functionality of a P-code or intermediate language engine as well as machine language facilities simulating the P-code library routines that allow the execution of N-code programs. The AVPE executes a target program so that the target program does not interact with the target computer. The AVPE analyzes the behavior of the target program to identify occurrence of malicious code behavior and to indicate in a behavior pattern the occurrence of malicious code behavior. The AVPE is terminated at the end of the analysis process, thereby removing from the computer system the copy of the target program that was contained within the AVPE.

A method and apparatus to create an intermediate language or source code file from a server-side resource or dynamic web page file. The source code can then be compiled into an executable class allowing for rapid generation of web page control objects that perform server-side functions, including the rendering of client responses. The code generation scheme of the present invention is capable of creating control objects connected in a hierarchy to handle event processing and the setting of attributes to the specific objects.

A verification module evaluates intermediate language code to verify that the code is type safe before passing the code for execution. Code that is not deemed type safe can cause execution errors, corrupt the runtime environment in which the code is executing, or cause unauthorized access to protected system resources. As such, the verification module protects a computer system from intentional or inadvertent breaches of the computer system's defenses. The verification module verifies the type safety of intermediate language code that supports significant high-level language constructs prohibited by verification modules in the prior art. One exemplary verification module verifies intermediate language code that includes one or more reference-based parameter, such as a pointer (or reference), a value class containing pointers, a RefAny parameter, or a nested pointer.

Systems and methods to process and correct spelling errors for non-Roman based words such as in Chinese, Japanese, and Korean languages using a rule-based classifier and a hidden Markov model are disclosed. The method generally includes converting an input entry in a first language such as Chinese to at least one intermediate entry in an intermediate representation, such as pinyin, different from the first language, converting the intermediate entry to at least one possible alternative spelling or form of the input in the first language, and determining that the input entry is either a correct or questionable input entry when a match between the input entry and all possible alternative spellings to the input entry is or is not located, respectively. The questionable input entry may be classified using, for example, a transformation rule based classifier based on transformation rules generated by a transformation rules generator.

A scalable graphical user interface architecture for scaling a device platform independent application graphical user interface to the display screen of any of a plurality of heterogeneous device platforms is disclosed. The scalable graphical user interface architecture comprises a scalable graphical user interface library module, a customizing module and a render manager module. The device platform independent application graphical user interface is operable to initiate the creation of an instance of an intermediate representation of the application graphical user interface. The scalable graphical user interface library module is utilized by the device platform independent application graphical user interface during creation of the instance of the intermediate representation. The customizing module is operable to customize the intermediate representation as a function of one of the heterogeneous device platforms. The render manager module is operable to traverse the intermediate representation to produce a device platform dependent application graphical user interface on a display screen of said one of the heterogeneous device platforms.

A method and a system for transformation-based program generation using two separate specifications as input: An implementation neutral specification of the desired computation and a specification of the execution platform. The generated implementation incorporates execution platform opportunities such as parallelism. Operationally, the invention has two broad stages. First, it designs the abstract implementation in the problem domain in terms of an Intermediate Language (IL) that is unfettered by programming language restrictions and requirements. Concurrently, the design is evolved by specializing the IL to encapsulate a plurality of desired design features in the implementation such as partitioning for multicore and / or instruction level parallelism. Concurrently, constraints that stand in for implied implementation structures are added to the design and coordinated with other constraints. Second, the IL is refined into implementation code. With this invention, porting an implementation neutral computation to an arbitrary architecture can be automated.

An analyzer for maintaining and analyzing source code is disclosed. The analyzer includes a software translator for converting conventional source code into an intermediate language, slicing capability based upon weakest precondition determination, dual direction flow analysis and incorporation of a computational model to facilitate iterative code.

An automated analysis system identifies the presence of malicious P-code or N-code programs in a manner that limits the possibility of the malicious code infecting a target computer. The target computer system initializes an analytical virtual P-code engine (AVPE). As initialized, the AVPE comprises software simulating the functionality of a P-code or intermediate language engine as well as machine language facilities simulating the P-code library routines that allow the execution of N-code programs. The AVPE executes a target program so that the target program does not interact with the target computer. The AVPE analyzes the behavior of the target program to identify occurrence of malicious code behavior and to indicate in a behavior pattern the occurrence of malicious code behavior. The AVPE is terminated at the end of the analysis process, thereby removing from the computer system the copy of the target program that was contained within the AVPE.

A data import system enables access to data of multiple types from multiple data sources of different formats and provides an interface for importing data into a data analysis system. The interface enables a user to customize the formatting of the data as the data is being imported into a data analysis system. A user may select first user defined options for operating on a first data set received during a data importation process. An intermediate representation of the data set is generated based on the user first defined options. A user may specify second user defined options based on the intermediate representation during the data importation process. The second user defined options are processed to produce a final data representation of the data set to be used for analysis of the data. The intermediate representation may be a data table. The processing of a data set may include merging a first and second data set to produce the final data representation. The second user defined options may enable a user to select a basic operation for merging the data sets or to select a non-basic operation for merging the data sets. The basic operation may combine data sets in response to a user's selection of a first graphical interface control, and the non-basic operation may combine the data sets based on user selection of at least two graphical interface controls from a group of graphical interface controls.

A computer system and method generate a semantic representation of one or more XML language inquiries across relational and non-relational data sources. A semantic intermediate language representation explicitly describes the meaning of the one or more XML language inquiries. The semantic intermediate language may be a graph structure with nodes which describe the operations of the original query. Operators assigned to the nodes in the semantic graph allow an unambiguous definition of the original XML query. The semantic intermediate language may be used to perform XML queries over single or multiple data sources. A method includes receiving at least one inquiry, defining at least one node object for every operation within the received inquiry, translating each node object using operators, and generating a semantic representation from the operators.

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.

A method for publishing relational data as XML by translating XML queries into queries against an relational database. Conversion of the relational database into an XML database is not required. Each relational table is mapped to a virtual XML document, and XML queries are issued over these virtual documents. An XML query is parsed and transformed into a language-neutral intermediate representation, which is a sequence of operations describing how the output document is derived from the underlying relational tables. The intermediate representation is then translated into an SQL query over the underlying relational tables and into instructions for a tagger. The SQL query is executed, and the SQL query results are then fed into the tagger, which follows tagger instructions to generate the marked up output.

A query runtime architecture and an exemplary application programming interface suitable for the architecture are presented. The architecture inputs one or more XML queries and views and enables the queries to be translated wherein the queries and views may be run over multiple data sources of different data models. The architecture incorporates front-end compilers which convert input queries and views into an intermediate language representation which represents the meaning of the respective query or view. The architecture may then allow the back-end compiling of the intermediate language representation to target languages compatible with the data sources desired to be queried. The architecture also allows the execution of those target compilations to extract the data requested of the queries. The invention also discloses an example application programming interface for the query runtime system.

An optimizer / normalizer is used to generate optimized intermediate language representation of an input query, such as an XML input query. A method of optimization of an input query in intermediate language form includes receiving the input query, examining the nodes in a left-depth first manner to identify code patterns and node types which are subjects for optimization, tagging the identified code patterns until the intermediate language representation of the input query has been examined in its entirety, searching from the top of the intermediate language representation for tagged code patterns, and adjusting the tagged code patterns with improved code patterns to form an optimal representation for an input query. The input to the optimizer / normalizer is assumed to be an input query transformed into an intermediate language representation containing code patterns and nodes, each node having a respective node type.

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. A software development environment through a source code search engine is able to present source code construct elements, outlines, and symbol references from software packages over a plurality of distributed servers in a network such as the Internet.

Systems, methods, and computer program products are provided for identifying software files, flaws in code, and program fragments by obtaining a software file, determining a plurality of artifacts, accessing a database which stores a plurality of reference artifacts for reference software files, comparing at least one of the artifacts to at least one of the reference artifacts stored in the database, and identifying the software file by identifying the reference software file having the reference artifacts that correspond to the plurality of artifacts. Certain embodiments can also automatically provide updated versions of files, patches to be applied, or repaired blocks of code to replace flawed blocks. Example embodiments can accept a wide variety of file types, including source code and binary files and can analyze source code or convert files to an intermediate representation (IR) and analyze the IR.

Compiler and software product for compiling intermediate language (IL) bytecodes, such as Microsoft IL (MSIL) instructions into Java bytecodes, are provided. The provided compiler decodes the IL instructions, generates the stack content, and produces Java bytecodes based on the stack content. Furthermore, the compiler is specially designed to allow a programmer to develop software applications using the .Net framework that could be easily executed using a Java runtime environment.

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.

A system and method of providing edit and continue support in a software program debugging environment. “Edit and continue” support allows a user (e.g., programmer and / or developer) to update the code and / or data structure(s) of an executing program while it is running. After the user has finished editing their code and resumes execution, an integrated development environment (IDE) propagates the edit(s) into a common language runtime (CLR) environment before continuing. Therefore, from the CLR environment's perspective, an edit is a block of intermediate language code (IL) and / or metadata that is inserted into a running process. The IDE can facilitate: determining “legality” of an edit; building the edit; sending the edit to the CLR environment; and / or, facilitating the CLR environment switch execution to the edited code.

Method for enabling the simultaneous use of a first and a second programming language within a computer program, and apparatus to practice the method. To enable this sharing of languages, the present invention first provides for a common runtime representation of the data between the several languages in a program as a shared object model. The shared object model includes the layout of complex data structures (e.g., classes), the creation of data, the calling conventions, the destruction of data, the runtime representation of type information, dynamic function call dispatch, and dynamic type conversions. The use of a shared object model enables the sharing of the several compilers' internal representation of data between the different languages as a persistent shared symbol table. This shared internal data representation enables the several compilers to define their respective internal data representations in terms common to each of the compilers.

The present invention provides a comprehensive method for automatically and unobtrusively analyzing the in-store behavior of people visiting a physical space using a multi-modal fusion based on multiple types of sensors. The types of sensors employed may include cameras for capturing a plurality of images and mobile signal sensors for capturing a plurality of Wi-Fi signals. The present invention integrates the plurality of input sensor measurements to reliably and persistently track the people's physical attributes and detect the people's interactions with retail elements. The physical and contextual attributes collected from the processed shopper tracks includes the motion dynamics changes triggered by an implicit and explicit interaction to a retail element, comprising the behavior information for the trip of the people. The present invention integrates point-of-sale transaction data with the shopper behavior by finding and associating the transaction data that corresponds to a shopper trajectory and fusing them to generate a complete an intermediate representation of a shopper trip data, called a TripVector. The shopper behavior analyses are carried out based on the extracted TripVector. The analyzed behavior information for the shopper trips yields exemplary behavior analysis comprising map generation as visualization of the behavior, quantitative shopper metric derivation in multiple scales (e.g., store-wide and category-level) including path-to-purchase shopper metrics (e.g., traffic distribution, shopping action distribution, buying action distribution, conversion funnel), category dynamics (e.g., dominant path, category correlation, category sequence). The present invention includes a set of derived methods for different sensor configurations.

Provided are two types of translation engines. One of the translation engines translates a text written in a source language X into an intermediate language C, and the other translates the intermediate language C into a target language Y. The X-C translation engine translates an original text written in the source language X into a text in a predetermined intermediate language C as well as acquires and adds annotations obtained by this translation to the translated text written in the intermediate language C. The C-Y translation engine references annotations, which are obtained by the X-C translation engine and added to the text in the intermediate language C, and translates the text in the intermediate language into a text in the target language Y sentence.

Described is an application program interface (API) that enables dynamic modification to applications executing in a heterogeneous distributed computing environment. The application program interface includes a navigation function, a query function, a thread management function, and a modifier function. The navigation function returns program information for a local or remote computer (i.e., specified computing device). The query function returns information about a program on the specified computing device. The thread management function controls execution of other programs on the specified computing device. The modifier function modifies a system memory on the specified computing device that stores the heterogeneous program. The API works in conjunction with a hierarchical intermediate representation of the heterogeneous program such that pre-defined program tools can modify the intermediate representation and write these modifications to the specified computing device while the heterogeneous program remains operational.

An optimizer / normalizer is used to generate optimized intermediate language representation of an input query, such as an XML input query. A method of optimization of an input query in intermediate language form includes receiving the input query, examining the nodes in a left-depth first manner to identify code patterns and node types which are subjects for optimization, tagging the identified code patterns until the intermediate language representation of the input query has been examined in its entirety, searching from the top of the intermediate language representation for tagged code patterns, and adjusting the tagged code patterns with improved code patterns to form an optimal representation for an input query. The input to the optimizer / normalizer is assumed to be an input query transformed into an intermediate language representation containing code patterns and nodes, each node having a respective node type.

A method, apparatus, and computer instructions are provided for transforming Java Native Interface function calls to constants, internal just-in-time compiler operations or simpler intermediate representation. A compiler generates a plurality of intermediate representations for a plurality of native interface function calls. During inlining of native code, matching is performed on each native function call (against this list) and a list of native interface function calls is generated. For each native interface function call, a JIT call transformer attempts to replace the native interface function call with a constant, internal just-in-time compiler operation or a simpler intermediate representation depending on the type of native interface function call.

A method and apparatus, including a computer program apparatus, implementing techniques for generating a report from a technical computing environment provided by a mathematical computer program. A report generator defines a set of reporting components that can be assembled to form a report template and processes the reporting components of the report template in order to extract data from the mathematical computing environment and generate the report. The report generator includes a user interface by which a designer can hierarchically assemble the reporting elements, which are defined according to an object-oriented programming language. The report generator bi-directionally communicates with the mathematical computing environment such that the report generator can evaluate expressions defined within the mathematical computing environment, change initial conditions and parameters of a mathematical model, and issue commands to advance the simulation time of the model. The report generator includes a generation engine that generates an intermediate representation of the report and a transformation engine that transforms the intermediate representation into an electronic document according to a user-selected format.

A method, apparatus, and computer instructions are provided for inlining native functions into compiled Java code. A conversion engine is provided by the present invention for converting the intermediate representation of native functions to the just-in-time (JIT) compiler's intermediate representation. With the converted intermediate representation, an inliner recursively inlines the converted JIT compiler's intermediate representation into the native callsite to remove the need of invoking the native function and subsequent native calls made by the function. The inlining process continues until either a call to an opaque function is encountered or until a JIT compiler intermediate representation growth limits are reached. The inliner also replaces calls to most native functions that are non-inlineable or opaque with calls to synthesized native functions that provide access to native libraries containing implementations of the original non-inlineable calls.

The method for efficient target detection from images robust to occlusion disclosed by the present invention detects the presence and spatial location of a number of objects in images. It consists in (i) an off-line method to compile an intermediate representation of detection probability maps that are then used by (ii) an on-line method to construct a detection probability map suitable for detecting and localizing objects in a set of input images efficiently. The method explicitly handles occlusions among the objects to be detected and localized, and objects whose shape and configuration is provided externally, for example from an object tracker. The method according to the present invention can be applied to a variety of objects and applications by customizing the method's input functions, namely the object representation, the geometric object model, its image projection method, and the feature matching function.

An embodiment provides (a) a method and system for representing natural languages in a common machine-readable form, including the thorough design of the lexicon and grammar, the resulting representation called interlingua, (b) a method and system for using a computer to convert a text of a natural language into and out of a coded text of said interlingua representation, including a programming framework which is independent of other languages, said system is called interlingua engine, and (c) a method and system of machine translation using said interlingua engine, said system called interlingua machine translation system. Alternative embodiments are described.