Abstract: An improved method and process for array shape inferencing for high-level array-based languages such as MATLAB and APL. The process is based on a framework that algebraically describes the shape of an expression at compile time. The method leverages on algebraic properties that underlie MATLAB's shape semantics and exactly captures the shape that the expression assumes at run time. Other highlights of this method are its generality and the uniformity of its approach. Compared with the traditional shadow variable scheme, the algebraic view permits powerful shape-related assertions and optimizations not possible in the conventional approach.

Abstract: A method of generating language specific code comprising the steps of extracting neutral code from a knowledge base, preprocessing the neutral code, providing a code generator with the preprocessed neutral code and a target language in to which the preprocessed neutral code is to be translated, and processing the preprocessed neutral code by translating the neutral code into a target language code.

Abstract: A translator-compiler for converting legacy architecture. In the area of management software or distributed management software, a standard architecture is evolving from legacy or proprietary architecture, and the standard embraces CIM/XML (Common Information Model/eXtensible Markup Language) computer language. Many vendors have developed proprietary languages for their respective management products that are incompatible with such standard. To accomplish compatibility between standard architecture and various different proprietary architectures, a substantial amount of code must be written at great effort and expense, unless an automatic, easily-applied and universal solution can be achieved. A translator-compiler is disclosed which meets these solution criteria and therefore solves this incompatibility problem. Flowcharts depicting algorithms along with sample input and output code in C++, as well as an example of the final XML result are also disclosed.

Abstract: An embodiment of the present invention is a consolidated package for diverse platforms to interoperate and transfer data. It allows otherwise incompatible systems to communicate with each other, exchange information, and otherwise interact. An embodiment of the present invention translates requests for information into a predetermined format that can be transmitted from a first platform to a second platform. One embodiment may transfer the information in an XML format over the Internet using HTTP or HTTPS. The receiving computer translates the XML stream into a properly formatted request and finds the requested information. The requested information is translated into an XML stream and transmitted over the Internet using HTTPS. The information is then translated into a format that the requesting computer can use. The system and method described herein can be used to exchange data between two computing systems.

Abstract: A compiler comprises a lexical scanner with a dynamic character identification table that accommodates different standards for encoding characters in source and target characters. The scanner is associated with data files that enable conversion of the character identification table and also source code to conform to different standard character set representations. The scanner compares the character sets associated with the source and target codes. The source code is loaded into a buffer, and if a discrepancy in character sets exists, the buffered source code is converted to the target character set. The scanner also compares the character sets associated with the target code and the character identification table. If a mismatch exists, the scanner converts the character identification table to conform to the target character set. The lexical scanner provides greater flexibility in reading and generating program code.

Abstract: A software package, comprising a receiving module determining a format of each of a plurality of original files and a converter module applying a converter function corresponding to the file format of each of the original files to create new files in a converted file format.

Abstract: A method, system, and program for generating scripts in a networked environment are disclosed. A shell script is written in a programming language in which the shell script is used in a networked environment. The shell script is programmingly converted to a script executable under a specific platform. The script is executed under the specific platform. A script generating command its defined in the shell script. Parameters for the script generating command are defined. The script generating command is executed with the parameters to generate the script. Prefix names having associated prefix variables that are passed to the script generating command are also defined. The prefix names and the prefix variables are obtained for the script generating command. Values for the prefix variables are retrieved from a table.

Abstract: Balancing logic is automatically generated from conversion logic in a data conversion system. The balancing logic balances source data from a source system with the corresponding converted data in a target system. The balancing logic determines whether the conversion was properly performed so as to balance the two varieties of data. The balancing logic is automatically generated by a computer system or other electronic device in response to examining conversion logic that is encoded in a script or other representation.

Abstract: An optimization information attaching apparatus 100 stores a source program including class definitions and a class instruction. The class definitions each include a class, a virtual function and a base class, and the call instruction calls one of the virtual functions. The optimization information attaching apparatus detects a class that is not inherited by another class, and attaches optimization information to the class definition including the detected class. A compiling apparatus 110 reads the call instruction from the source program, judges whether the virtual function belongs to a class that is not inherited by another class by referring to the optimization information in the source program, and generates an executable instruction group for calling the virtual function directly.

Abstract: A system for providing access to an application running on a computer simulation. The system has a first computing device that has a simulation program for simulating a second computing device. On top of the simulation program, the first computing device runs a software application that normally executes on the hardware of the second computing device. The first computing device also grants access to multiple users simultaneously to separate instantiations of the simulation software program and the software application.

Abstract: Configuring software for a target comprises preparing a command file which specifies a subset of components selected from a group of components, and parameters for tuning at least some of the selected subset of components. The command file is written using a single object-oriented programming language, capable of managing tree structures of objects, preferably an XML type language, having a Document Type Definition enabling it to work as a programming language. An image file is prepared from the command file, to be loaded on the target.

Abstract: The present disclosure relates to determining and setting an appropriate localized language (and telecommunications settings when appropriate) on a multi-function device that includes a scanner and a printer. Rather than configuring the language setting for such multi-function devices during manufacturing, the language setting can be configured by the end user after a device is delivered. Advantages of the disclosed system and methods include a decreased variation in the types of devices being manufactured and an associated reduction in inventory tracking and storage costs.

Abstract: Communicating local information, such as a user interface language, between a host application and a software component. In response to a user's request, the host application invokes the software component to perform a task addressing the user's request, such as generating user interface message. In order to determine the appropriate language for the user interface message, the software component queries the host application to identify the user and to return the user interface language requirements for the user. In the case where the host application is an end-user application, the host returns the current user interface language as the user interface language requirement. When the host application is a server application using a multi-threaded environment, the host application returns the user interface language of the currently running thread at the time of the query.

Abstract: In accordance with methods and systems consistent with the present invention, a system that automatically generates Fortran 90 interfaces to Fortran 77 code is provided. These interfaces provide for the use of optional parameters and, because they are written in Fortran 90, also allow for parameter checking. These interfaces are automatically generated to allow a programmer to reap the benefits of Fortran 90 calling without having to rewrite the Fortran 77 underlying code. When generating the interfaces, the method performs an optimization that saves a significant amount of processing time as well as a significant amount of memory. This optimization involves generating the interfaces in such a way as to prevent the compiler from performing a gather and a scatter.

Abstract: A computer system/program (10) for converting at least keywords in a program source code. The system/program (10) has a program source code conversion means (12) for converting C/C++ source codes including C/C++ keywords written in a non-English language such as French or Spanish into a form that can be compiled by a standard compiler, storage means (20) storing English keywords of C/C++ and words in at least one other natural language corresponding to said keywords, and program code conversion for converting keywords and other words written in one natural language into a target code in another natural language. The system/program (10) can be in the form of a compiler or incorporated into a computer operating system so that the natural language for the system interface can be selected.

Abstract: A mechanism for reformatting a simple source code statement into a compound source code statement is provided. Tokens are identified in unformatted source code, which contains simple statements. A syntax tree is created from the identified tokens. The syntax tree is used to identify one or more simple statements. In processing a particular simple statement, potential statements are identified in the particular simple statement. A tree of blocks, which identifies block levels, is created from the potential statements. An intermediate textual representation is created where each of the potential statements is on a different line. Indentation levels, which correspond to the block levels in the tree of blocks, are associated with each of the potential statements. Formatted source code is created by inserting begin and end block indicators into the intermediate textual representation.

Abstract: An exchange servicing development support system automatically replaces definition contents and creates generation codes to new specifications, even if interfacing is changed, by reading servicing definition result files stored in accordance with old specifications. By providing a unit for re-constructing service tree structure data in a format in accordance with information about compatibility description in a menu describing file, the service tree structure data is automatically created. Since information about compatibility is allocated to the menu describing a file stored in the storage device, each unit in the data processing device is adapted to be used for a general purpose. The description of replacement of various patterns can be made by descriptions of information about compatibility in the menu describing file.

Abstract: The inventive emulator dynamically translates instructions in code written for a first architecture into code for a second architecture. The emulator designates various checkpoints in the original code, and speculatively reorders the placement of the translated code instructions according to optimization procedures. If during the execution of the reordered code, a trap should occur, then the emulator resets the original code to the most recent checkpoint and begins executing the original code sequentially in a line-by-line manner until the section is completed or branched out of. The original code is reset by changing the program counter to the checkpoint, and reversing the effects of each instruction which has been executed subsequent to the checkpoint.

Abstract: Systems and methods that enable a source code file containing in-line database access statements to be compiled into object code for an application without the use of a pre-compiler are disclosed. In one aspect of the system, the source code contains delimiters that enclose an attribute section comprising in-line database access statements. The compiler of the system communicates the attribute section to an attribute provider, which translates the attribute section into statements that can be processed by the compiler. A further aspect of the system is that the attribute provider is a software component. The software component can be a COM (Component Object Model) component. A still further aspect of the system is that the attribute provider can communicate with a database management system in order to assist in validating the attributes against the tables and columns of the database.

Abstract: There is provided a method for enhancing source code for execution on a computer platform that has a capability to employ a memory file. The method includes the steps of recognizing an occurrence of a first instruction in the source code that does not utilize the capability, and supplementing the source code with a second instruction that utilizes the capability.

Abstract: Models destined for verification are described at the level of synthesizable description (for example VHDL). The synthesizable description (200) is automatically converted (300) into a C++ model (200′). This allows verification of the correctness of the synthesizable description by comparing the results of a verification carried out on the original description from the cell in C++ with the results of a similar verification of the C++ model obtained by automatic conversion of the synthesizable description. It is also possible to make the C++ model obtained by automatic conversion (200′) to interact with a system model including blocks (201, 202, 203) of a system model at C++ level, in particular with the possibility of producing concurrent events that occur in correspondence with a main timing signal source.

Abstract: A geometric model comparator is provided, which includes processing circuitry, memory, and comparison circuitry. The processing circuitry is configured to generate a target model from a source model. The memory is configured to store the source model and the target model. The comparison circuitry is configured to identify selected points from the source model, create corresponding selected points in a target model, and compare the selected points from the source model with the selected points from the target model to identify one or more selected points from the target model that fall outside of a predetermined tolerance range with the respective one or more points from the source model. A method is also provided.

Abstract: Methods, systems, and articles of manufacture provide a single multi-language source code file and effects single-language executable files from the multi-language source code file. A program extracts text elements in the first language from the source code. The extracted text elements include context information that identifies a location of the text element in the first language in the source code. Translations of the extracted text elements in a second language are obtained. The translations of the text elements in the second language are merged into the source code at merge locations based on the context information. Versions of the source code in the first language and the second language are then generated.

Abstract: A method of producing a caching dynamic translator with portable run-time code synthesis includes programming hardware independent replacement functions in a high level programming language for the caching dynamic translator, and compiling the hardware independent replacement functions to produce hardware dependent computer executable replacement functions.

Abstract: This invention is about a method of digital circuit design using programming language. It can solve problems raised by describing hardware using programming language, e.g. difficulties in describing changes within the same time step, and limitations in designing by sequential process. Separate variables are used to indicate registers and input of the registers. After the process of module section, the secondary variables are assigned to primary variables in a non-blocking assignment section. Combination circuits, which are used by more than one modules in module section, are defined in a assignment section and before module execution. Several clocks and gated clocks are described in non-blocking assignment section and loop section.

Abstract: This invention provides for the implementation of dynamic “event to method” adapter class generation. Event to method adapter classes and objects are automatically and dynamically generated and wired to source and target objects as required using a runtime environments language such as the Beans Markup Language (BML). Adapter classes and objects are automatically and dynamically generated as required while the application program loads and runs. Dynamically generated classes and objects need to exist only at the time that a running application calls for the adapters use, and can be dynamically modified or exchanged in order to optimize the running application or modify application functionality.

Abstract: A method and device are provided to define functional structures for an application based on first input in a first language; to identify relationships between the functional structures; to organize the functional structures in a hierarchical framework based on the relationships; to change a functional structure based on second input, while limiting an effect of the change on other related functional structures in the hierarchical framework; and to transform the functional structures into code in a second language.

Abstract: A computer-implemented method is disclosed for automatically converting text-based screen applications of a legacy computer system into a graphical-based representation thereof. The method includes the steps of transforming a terminal-based screen application into an application specification; converting the application specification into a modeling language-based representation; and, displaying the modeling language-based representation with a graphical user interface. The method of this invention also includes the capability of generating document type definitions of the modeling language-based representation, which enables transmission of the representation among modeling tools.

Abstract: A process for transforming an original source code containing a description of a stub method employed in an object interaction into another source code corresponding to an environment on which a program is executed. The original source code is described with a predetermined programming language and contains information concerning the stub method to be used in the object interaction. The information is described in a format which is common to a plurality of different program execution environments. The transformation is conducted with reference to a registered information corresponding to the program execution environment on which stub method is to be executed into another source code described with the same programming language as the original source code in a predetermined format corresponding to the program execution environment on which the stub method is to be executed.

Abstract: In an embodiment, a method includes receiving a first source code having a number of global storage objects, wherein the number of global storage objects are to be accessed by a number of threads during execution. The method also includes translating the first source code into a second source code. The translating includes adding initialization logic for each of the number of global storage objects. The initialization logic includes generating private copies of each of the number of global storage objects during execution of the second source code. The initialization logic also includes generating at least one cache object during the execution of the second source code, wherein the private copies of each of the number of global storage objects are accessed through the at least one cache object during execution of the second source code.

Abstract: Methods and apparatus for using description information about a function to translate a call to the function into a call to a corresponding function in a second language. The methods include processing a definition of a function associated with a first language to create description information sufficient to enable translation of a call to the function into a call to a corresponding function in a second language without requiring processing of the definition of the function. In another aspect, the methods include providing a description file of items, each item including description information about a function associated with a first language, and using the file of description items to translate a first program file from the first language into a second language.

Abstract: A method for translating source code programs written in a procedural computer language in source code programs written in an Object Oriented language. The method of the invention provides a parser which adds to the lexicographic and syntactical analysis of the source code a semantic analysis: a parser is written for identifying the semantic patterns in the source code. At execution, the parser reads the instructions of the procedural language and classify the sequences of instructions identified as using a known pattern. According to the matched patterns, the parser creates different categories of classes containing both functional (linearly translated code) or references to other object instances. Each time an object is discovered in the code it is stored in an Object Dictionary with its description and reused when referred later in the code.

Abstract: A method for generating a list of desired elements of a first software code, the first code having a predefined command structure; extracting the desired elements from the first code; and performing an operation on the extracted elements. A system includes a first engine which receives a list of desired elements of a first software code, the first code having a predefined command structure; a second engine which extracts the desired elements from the first code; and a third engine which performs an operation on the extracted elements.

Abstract: A source code translating method includes the steps of representing a particular source code in the form of an abstract syntax tree without using nodes representing expression statements, and converting such abstract syntax tree into a character string, wherein as the type of the root node in the abstract syntax tree being processed is if-statement (T71), a branch is taken to invoke the “procedure for producing if-statement” where a character string “if (” is first produced, and then, to produce “x==0” contained in the first occurrence of the subtree, the “procedure for outputting the abstract syntax tree as an expression” is recursively invoked, then a character string “)” is produced; to produce “y=0;” contained in the second occurrence of the subtree, the “procedure for outputting the abstract syntax tree as a statement” is recursively invoked, then a character string “else” is produced; and

Abstract: The present invention comprises a National Language Support (NLS) system with Language Driver Identifiers (LDIDs) embedded as locale-specific descriptors within data objects. The Identifiers, which may be in the form of a system-comparable ID (e.g., ID byte), are employed by the system in several places to record the particular language (driver) which was used when a given data object was created or modified. The LDID methodology of the present invention allows the system to intelligently process data objects created or modified under one language driver with those created or modified by a different language driver. In the event of incompatibilities, the system provides error handling routines, including a preferred interface for warning users of incompatibilities and receiving user choices in response thereof.

Abstract: An apparatus and method for porting applications to different platforms are provided. The apparatus and method make use of a mapping table function that receives source filenames and directory structures and maps them to filenames and directory structures appropriate for a target platform. In a preferred embodiment, the apparatus and method map flexible filenames and directory structures, such as is found with the Unix filesystem, to more restrictive filenames and directory structures, such as is found with the OS/400 filesystem. In this way, an application developer can develop application files without being limited to the most restrictive filesystem conventions.

Abstract: A system, computer program product and method for converting a file in one format to another format. The first file written in a first format, e.g., .MAP file format generated by the IBM Visual Age C++ Linker, may comprise a list of segment portion/offset value pair(s) and a separate list of symbol name/address pair(s). Upon associating symbol name(s) with particular segment portion/offset value pair(s), the .MAP file written in a first format may be converted into a .MAP file written in a second format, e.g., .MAP file format generated by the Microsoft Visual C++ Linker, by writing a list of segment portion/offset pair(s) with their associated symbol name(s).

Abstract: The present invention comprises a National Language Support (NLS) system with Language Driver Identifiers (LDIDs) embedded as locale-specific descriptors within data objects. The Identifiers, which may be in the form of a system-comparable ID (e.g., ID byte), are employed by the system in several places to record the particular language (driver) which was used when a given data object was created or modified. The LDID methodology of the present invention allows the system to intelligently process data objects created or modified under one language driver with those created or modified by a different language driver. In the event of incompatibilities, the system provides error handling routines, including a preferred interface for warning users of incompatibilities and receiving user choices in response thereof.

Abstract: A system converts an application designed to run on one operating system so that it can run on a second operating system without recompiling. An application designed to run on Windows® 95, 98 or NT, for example, may be converted so that it will operate without recompiling on a Windows® CE operating system machine.

Abstract: An apparatus and method are provided for performing event processing in a mixed-language simulator in a manner that minimizes context switching between at least one model written in a source code language and at least one model written in a hardware description language (HDL). The present invention comprises logic for generating a list of actions to be performed for a given trigger event occurrence and, once the list has been generated, for processing at least some of the listed actions in an source-code-to-HDL-interface domain before performing a context switch from the source-code-to-HDL-interface domain to a source code model domain. The HDL model domain corresponds to execution of the model written in the HDL and the source code model doma in corresponds to execution of the model written in the source code language, and the source-code-to-HDL-interface domain corresponding to execution of source-code-to-HDL-interface code.

Abstract: A system for and method of automating the execution of a data stream transformation project. The various embodiments described employ a trainable user interface translator application to record and manipulate data streams between a prospect's terminal emulation software and one or more prospect applications to be transformed. A remote user in communication with the prospect may observe prospect terminal screen displays, and optionally insert data, such as synchronization data into the recorded data streams. The user inserts the recorded data streams information into a targeted procedures model, which may be reviewed for approval by the prospect.

Abstract: A computer-implemented method in which report program language is converted to object-oriented source code, such as Java, using the report program language compiler. The object-oriented source code emulates the behaviour of the report program language, such as VARPG. Applications written in RPG are converted to Java and therefore can run on every platform for which a Java virtual machine exists. RPG programmers now have the ability to write internet applications. Java applications and applets can be written in RPG and existing RPG applications can be converted to Java applets.

Abstract: An initialization module for a device driver, the module being operable to:

Abstract: The present invention relates to a method for translating computer programs from a language having the attributes of computer programming language COBOL to a language having the attributes of the computer programming language Java. In particular, source language primitive functions are represented by archetypal templates having code that is selectable based upon the applicable case. In one implementation, the source language is translated to target language code which is, in turn, compiled by a target language compiler, thereby providing a two-step source language compiler.

Abstract: Various modes and embodiment of a method, apparatus, user interface, article of manufacture including a computer readable medium, computer data signals embodied on a carrier wave, and computer system for a GUI-based ground truth tool and insertion of user algorithms written in multiple programming languages. One embodiment comprises user interface for inserting a custom algorithm in a data-mining application. Another embodiment comprises a ground truth tool in a data-mining-application. A third embodiment comprises seamless insertion of custom algorithms in a data-mining application using tap points.

Abstract: A computational geometry server is provided that includes a server, a communication link, at least one client, and an interrupt interface. The server has processing circuitry and an operation manager. The operation manager is configured to compare source geometric data in a source geometric model with target geometric data in a target geometric model. Furthermore, the operation manager is operative to identify discrepancies in the geometric data between the source geometric data and the target geometric data. The at least one client communicates with the server over the communication link. The interrupt interface is operative to notify a user of the presence of an inability to automatically generate an accurate representation of the source geometric model in the target geometric model. A method is also provided.

Abstract: A program conversion apparatus includes: a library call instruction detecting unit for detecting each library call instruction included in an inputted object program, the library call instruction calling a source library that is an external program module; a library correspondence table that gives various information, such as correspondence between arguments of source libraries and arguments of target libraries that have the same feature as the source libraries and are called by an outputted object program; a library call instruction generating unit for converting the detected library call instruction into an instruction that calls a target library corresponding to the source library and converting instructions for setting the arguments of the source library into instructions for setting arguments of the target library by referring to the library correspondence table.

Abstract: The dynamic mapping from an ActiveX component model to a JavaBean model is disclosed. In one embodiment, an ActiveX compatible object is created at run-time for those JavaBean components that an ActiveX client application wishes to utilize. In another embodiment, upon a call to CoGetClassObject or related methods using class identifiers, a COM-callable wrapper is generated and a mapping table containing COM dispatch identifiers is scanned to ensure the dispatch identifiers are unique. If they are not, the dispatch identifiers associated with JavaBean component interfaces are adjusted to make them unique.

Abstract: A computer-readable medium is encoded with a method of externalizing legacy data from a legacy database on a data resource into an Extensible Markup Language (“XML”)-compliant format where the format is specified by an automatically generated XML meta-description, thus enabling access and processing of legacy data by XML-compliant applications.

Abstract: One aspect of the invention includes a method of address expression optimization of source-level code. The source-level code describes the functionality of an application to be executed on a digital device. The method comprises first inputting first source-level code that describes the functionality of the application into optimization system. The optimization system then transforms the first source-level into a second source level that has fewer nonlinear operations than the first source-level code.