Abstract: Message translation systems and methods are provided. In one embodiment, a method for translating messages comprises reading a first sequence of one or more message elements from a first interface, wherein the message elements are structured based on a first protocol; converging on a message mapping node based on the first sequence of one or more message elements, wherein the message mapping node is defined by a protocol metadata schema; performing one or more conversion operations on the first sequence of one or more message elements to construct a second sequence of one or more message elements, wherein the one or more conversion operations are based on the message mapping node; and writing the second sequence of one or more message elements to a second interface.

Abstract: A system including an input compiler that receives a unified input description containing syntax rules for both regular and context-free expressions and interspersed code, the first compiler configured to translate the unified input description into a common internal representation is disclosed. The system also includes a regular expression checker, a context-free expression checker, a code checker and a second compiler coupled to the code checker.

Abstract: Systems and methods for the creation and deployment of services on a converged network are described herein. These services can be initially created from visual constructs and have their life cycle performed and monitored by a multimedia service composition factory. Functions for design, implementation, installation, verification and coordination can be provided to compose services after pre-compiled code segments are received from a user interface.

Abstract: A system and method for parsing XML is provided. The method includes associating an input stream with a pull model parser, accepting requests to selectively parse out XML items from the input stream and retrieving metadata information associated with the parsed out XML items. The method further includes checking the pulled XML item to determine whether it conforms to XML syntax and/or semantic standards and validating the pulled XML item to determine whether it conforms to a selected DTD.

Abstract: The subject disclosure pertains to layering of a plurality of type systems. A development environment and language compilers can support multiple data models and their type systems in the same program. Elements of a program such as expressions can then be associated with several types from the multiple type systems. Compilers can employ the information provided by additional type systems to improve static type checking. Furthermore, the information can be bubbled up to a user in a plurality of forms including but not limited to intelligent assistance, auto-completion, tool tips, error information, and return types to enhance the program development experience.

Abstract: A system and method for compiling and matching regular expressions is disclosed. The regular expression compiling system includes a syntax analyzing module and at least two types of compiling modules. The syntax analyzing module is configured to analyze syntactic characteristics of a regular expression and send the regular expression to an appropriate compiling module according to preset syntactic rules and the syntactic characteristics of the regular expression; and the appropriate compiling module is configured to receive the regular expression and compile the regular expression into a data structure of a specific form.

Abstract: A Managed Add-in Framework (MAF) proxy generation tool comprises a library analyzer module operable for taking as input either a type library or managed software code assembly of the existing host application, and a proxy code generation module. Also, an additional input XML file that describes changes that a user would like to be made may be received by the tool and data acquired form the inspection of the additional input XML file and the inspection of the other inputs is merged and used to create the code of the proxy to the host object model. The proxy to the host's object model conforms to requirements of the MAF.

Abstract: A parser is generated for parsing a marked up document. A template of a sample marked up document chosen by a user is extracted. The template comprises elements of the structural markup of the sample document with their data contents removed. The parser for parsing a marked up document is generated. The parser is generated in the form of code based on the extracted template in such a manner that the parser is adapted to extract any elements and associated data content of the marked up document to be parsed corresponding to the elements of the extracted template.

Abstract: The present invention is directed to a method and system for compiling a markup language file into an executable application or library dll. The system may also compile a code-behind file associated with the markup language file. The compiling system may include a parser for parsing the markup language file and providing the compiling system with detailed token information to the compiling system. This token information could be user code snippets or non-code token information such as tags, properties or events in the markup. The compiling system may also include a binary file generator for generating a binary file from the non-code token information, wherein the binary file contains one record for each non-code token. Additionally, the system may include a code generator for generating a language-independent tree of code expressions based on the token information, wherein the code expressions represent the markup language file as a class.

Abstract: A system and method for translating character strings into another national language and displaying the translated character strings without updating any source code. The character strings are displayed on GUI environment upon the execution of the object computer program. The method for displaying character strings on GUI environment provided by a computer program comprises the steps of; (a) providing an executable program; (b) providing a text file including the character strings and being openable with the executable program; (c) executing the executable program (301); (d) retrieving the text file from the executable program (307); and (e) displaying the character strings included in the opened text file (315).

Abstract: A method and apparatus for accelerating processing of a structured document. A hardware XML accelerator includes one or more processors (e.g., CMT processors), one or more hardware XML parser units, one or more cryptographic units and various interfaces (e.g., to memory, a network, a communication bus). An XML document may be processed in its entirety or may be parsed in segments (e.g., as it is received). A parser unit parses a document or segment character by character, validates characters, assembles tokens from the document, extracts data, generates token headers (to describe tokens and data) and forwards the token headers and data for consumption by an application. A cryptographic unit may enforce web security, XML security or some other security scheme, by providing encryption/decryption functionality, computing digital signatures, etc. Software processing, bus utilization and latencies (e.g.

Abstract: A method, system and computer program product for enabling automated analysis of an extracted eScript to identify one or more problems within a configuration and script. The eScript is extracted from a Siebel repository and received in a DAVID (Development Application Verification Information on Demand for Siebel application where the VB.NET application, called SiebelParser, is utilized to conduct the analysis of the eScript. Occurrences of issues within an eScript are detected by SiebelParser. Issues within the eScript may include one or more of: empty event handlers, explicit object release, setting field values utilizing hard coded values, unnecessarily activated fields, call to next record after a call to delete record, and functions containing unnecessary code. Results from the analysis are reported to one log file document. The results of SiebelParser's log file are later incorporated to a spreadsheet by DAVID, to provide a more readable output format.

Abstract: A method of generating commands for a database server includes accessing a script having parser-specific commands, a first set of database-specific commands and optional shell commands. A componentized batch parser splits out the different command types and converts the parser-specific commands into a second set of database-specific commands. The first set and second set of database-specific commands may be sent to a target database for execution. The optional shell commands may be executed by a user tool at a local console. The batch parser offers features including separation of parsing functions using batch separators, performing automatic substitution of tokens in the script with defined values or substitution of tokens by requesting token values via a client tool, stripping off comments and blanks spaces from processed commands, referencing and editing files outside the script, and the ability to connect to different servers.

Abstract: The present invention provides methods and systems for integrating a procedural computational model with a declarative computational model. For example, in one aspect, the present invention provides a method for integrating a plurality of procedural instructions in a procedural computational system with a plurality of declarative rules in a declarative computational system. In such a method, for each of the procedural instructions operating on one or more variables, a hash table indexed by variable names is utilized to determine whether any of these variables participate in at least one of the declarative rules. Upon execution of a procedural instruction that changes a variable participating in a declarative rule, other variables associated with the rule are updated so as to maintain a relationship imposed by the rule among the variables. The updating of the other variables is performed prior to execution of other procedural instructions.

Abstract: An apparatus, system, and method are disclosed for converting data into source code such that the data can be translated and become part of a load module suitable for accessing from a load library. The apparatus includes a parser module, a format module, and an output module. The parsing module analyzes a data file having one or more data lines. The format module automatically formats the data file so that it can be translated by a translator. The formatted data file includes one or more computer language instructions containing the appropriate syntax corresponding to the particular translator. The output module outputs the formatted data file as an output file that can be renamed to preserve the original data file. A verification module allows the formatting of the data file to be verified.

Abstract: A computer system and computer program product executing a method for consistent and efficient management of program configuration and customizing data for a business application program. According to one method, an existing or newly created version of a global switch configuration is provided in a cache shared by one or more other programs. The cached switch configuration provides a configuration for a switch framework that governs access to one or more program functions of a business application. The cached switch configuration is then attached to the business application to provide an attached version of the switch configuration. Compatibility between the attached version of the switch configuration and the business application is determined. If compatibility exists, the business application program is executed in accordance with the attached version of the switch configuration.

Abstract: A method that allows the context of an SMI task to be saved between SMIs. Upon entering an SMI handler for a task that needs to be split up into shorter SMIs, a new task context stack is created in memory. From that point forward, the SMI handler uses the task context, leaving the original stack unchanged. When the time limit for a single SMI is about to be reached, the CPU is directed back to the original stack, and the task context stack persists in memory and retains the context of the task in hand. The soft SMI exits with a return code or other indication to signify that a new SMI should be invoked to continue processing. The driver or other software that caused the first soft SMI then invokes another, passing in a code or other indication to signify that this is a continuation of a previously started task. On entering the SMI handler for the second time, the handler notes the request for continuation, switches back to the saved task context stack and continues processing where it left off.

Abstract: The present invention is directed to a computerized method for identifying at least one pattern in source code. The method includes the step of parsing the source code to obtain data corresponding to at least one source code class. A plurality of search units are provided, each search unit being configured to evaluate a single verifiable property of the at least one source code class to a TRUE state or a FALSE state. At least a portion of the plurality of search units are arranged in at least one predetermined search sequence. The at least one source code class is evaluated by each search unit included in the at least one predetermined sequence.

Abstract: Methods and systems of transforming an AND/OR command tree into a command data model are described. An unsimplified command data model is generated from the AND/OR command tree by expressing the AND/OR command tree as a command tree using elements of EBNF (Extended Backus-Naur-Form) notation. Selected structures within the unsimplified command data model are simplified to create a simplified command data model. The simplified command data model is refined into a refined command data model by allowing renaming of selected elements of the command data model. The renaming is based on user-specified instructions.

Abstract: The subject disclosure relates to an extensible syntax for a scripting language that allows data intensive applications to be written in a compact, human friendly, textual format, and also according to self-defined syntax within the data intensive applications so that a single compilation unit of a program can support multiple syntaxes. An extensible syntax is provided for M that allows alternate syntaxes to be defined in line and then used in the program so as to accommodate user-defined syntaxes and other pre-existing domain specific languages. In one embodiment, the alternate syntaxes can be defined at pre-designated functional points in the program.

Abstract: Methods, techniques, and systems for providing project scopes as super-ordinate instances of computer applications projects are provided. Example embodiments provide a method wherein the computer applications are developed based on configuration files of a domain specific language pertaining to calculation tasks. In one embodiment, a “Scope of Resources” class is provided at design phase time. The class defines instances of resources that can be assigned in specific projects. Each project is associated with at least one scope. A project scope is automatically generated when a project is created. The association of resources to scopes and projects is performed during execution of the configured application. In addition to providing pre-configured values and attributes for projects, a scope also provides an aggregation level that is higher than the project level.

Abstract: 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.

Abstract: An apparatus for detecting base-register usage conflicts in computer code includes a parsing module configured to parse source code, an identification module configured to identify statements in the source code that reference a base register for address resolution according to base-displacement form, and a determination module configured to determine whether a base register referenced by one statement matches the base register referenced by another. If two statements do reference the same register, an apparatus and method in accordance with the invention may notify a user such that corrective action may be taken.

Abstract: The concept of “renderers” and “translators” is introduced in connection with bidirectional conversion between object models and XML. A renderer embodies the logic responsible for mediating the parser specific APIs for reading and writing XML. It utilizes a plurality of translator objects, which embody the mapping information needed to convert the XML into object model instances. The translator objects themselves do not contain “knowledge” of parser implementations; thus, the translators are common and can be shared and reused by any and all renderer implementations. Since each translator embodies the knowledge and rules regarding how to convert an XML model to an object model, and how to convert object models to XML, it is thus independent of the particular renderer that is being used, whether it be SAX, DOM, or some other renderer.

Abstract: A method and code generator system for integrating different enterprise business applications is disclosed. In one embodiment, a method for integrating a local business system with an external business system, comprises using a code generator to generate integration source code, wherein using a code generator comprises; interrogating a repository containing integration data by an introspector; and using the integration data with a code filter, wherein the filter generates the integration source code.

Abstract: Trees are a common semantic denominator of XML data types and process calculi. This indicates a potential tight intertwining of the syntax and semantics of data and processes. The invention provides this intertwining via a process calculus wherein the data language syntax is a fragment of the programming language syntax.

Abstract: Methods, apparatus and computer software product for source code optimization are provided. In an exemplary embodiment, a first custom computing apparatus is used to optimize the execution of source code on a second computing apparatus. In this embodiment, the first custom computing apparatus contains a memory, a storage medium and at least one processor with at least one mufti-stage execution unit. The second computing apparatus contains at least two multi-stage execution units that avow for parallel execution of tasks. The first custom computing apparatus optimizes the code for both parallelism and locality of operations on the second computing apparatus. This Abstract is provided for the sole purpose of complying with the Abstract requirement rules. This Abstract is submitted with the explicit understanding that it will not be used to interpret or to limit the scope or the meaning of the claims.

Abstract: A system for automation of processes in a working environment to achieve targeted deliverables, said system comprising: mapping means adapted to map discrete processes in a working environment; reader means adapted to read human instructions in relation to targeted deliverables at mapped discrete processes; interpreter means adapted to interpret said read instructions into a machine readable instruction format; compiler means adapted to compile said machine readable instruction format into a pre-defined operating system executable instruction format; packager means adapted to classify and package said operating system executable instruction format in a pre-defined format; and installer means adapted to install and deploy said packaged format in said working environment to complete the automation process and achieve targeted deliverables.

Abstract: A system for developing natural language enabled software applications is described. Resolvable types define abstract representations of linguistic elements and interrelationships between linguistic elements of a natural language input. Resolution semantics define procedural rules for resolving validity of the resolvable types in a natural language enabled software application.

Abstract: The present invention provides methods and systems for integrating a procedural computational model with a declarative computational model. For example, in one aspect, the present invention provides a method for integrating a plurality of procedural instructions in a procedural computational system with a plurality of declarative rules in a declarative computational system. In such a method, for each of the procedural instructions operating on one or more variables, a hash table indexed by variable names is utilized to determine whether any of these variables participate in at least one of the declarative rules. Upon execution of a procedural instruction that changes a variable participating in a declarative rule, other variables associated with the rule are updated so as to maintain a relationship imposed by the rule among the variables. The updating of the other variables is performed prior to execution of other procedural instructions.

Abstract: The techniques and mechanisms described herein are directed at converting text into objects based on a template that describes the format of the text, where the format of the text is not in a standardized format. The objects then being available for further processing. The conversion mechanism converts the text into a dead object. The template comprises an object header indicator and a corresponding object header pattern. A new object is created based on the object header pattern identified within the text. In addition, the template comprises one or more field indicators each having a corresponding field pattern. The field pattern may be in a format of a regular expression. A field type and associated value are created from a string associated with the field pattern.

Abstract: Immutable structures are employed to effect immutable parsing. In particular, an immutable parsing configuration, comprising a stack and lookahead buffer, is utilized by a parser to perform lexical and syntactical analysis of an input stream and optionally output an immutable parse tree or the like. Performance with respect to the immutable structures can be optimized utilizing sharing and lazy computation. In turn, immutability benefits are afforded with respect to parsing including safe sharing amongst services and/or across multiple threads as well as history preservation, among other things.

Abstract: Methods and systems are provided for analyzing a source code. The method includes collecting function entry information during the execution of tests on the source codes. The function entry information is then converted into symbolic codes. The function calls are replaced by the elements of the symbolic codes in the source codes. The elements can be in the form of functions. Subsequently, static analysis is performed on the source code by using the mapping between the function calls and the functions in the source code.

Abstract: Methods and systems to generate derivative information sources, from original information sources, use an ontology that provides a logic-based representation formalism of each of a number of original information sources, the original information sources having heterogeneous representation formalisms. The original information sources are transformed to the ontology. A number of derivative information sources, corresponding to the original information sources, may be automatically generated from the ontology.

Abstract: A compiler includes: a syntax analyzer analyzing whether or not an operation described in a source program conforms to grammatical rules, and analyzing whether or not a combination of the operations defines an intrinsic function and details of processing operations of the intrinsic function; an intrinsic function definition database storing a definition of the intrinsic function and the details of the processing operations of the intrinsic function, as analyzed by the syntax analyzer; a code generator generating machine instructions from the source program based on a result of the processing of the syntax analyzer; and a code optimizer optimizing the machine instructions to machine instructions corresponding to the details of the processing operations of the intrinsic function, if a string of the machine instructions generated by the code generator are in agreement with the details of the processing operations of the intrinsic function stored in the intrinsic function definition database.

Abstract: A method to automatically replace computationally intensive functions with optimized functions in managed code is disclosed. If the underlying processor has associated optimized functions, managed application code is disassembled and parsed to find computationally intensive functions. The computationally intensive functions are then replaced with optimized functions, and the application code is re-compiled if necessary.

Abstract: The present invention provides a reconfigurable circuit that comprises a plurality of reconfiguration cells and changes a configuration of a computation processing unit included in each of the reconfiguration cells. Here, each of the reconfiguration cells further includes: a computation storage unit operable to store a result of a computation performed by the computation processing unit; a flag holding unit operable to hold an initialization flag indicating whether an initialization of the computation storage unit is required; and an initialization control unit operable to, during the configuration change of the computation processing unit, control the initialization of the computation storage unit based on the initialization flag held by the flag holding unit.

Abstract: Creating an explicit feature used for construction of a computer-aided design model includes recognizing that model features form an implicit feature, presenting variations of the implicit feature, selecting one of the variations of the implicit feature, and creating the explicit feature. The explicit feature produces geometry that gives rise to the selected variation of the implicit feature. The computer-aided design model is constructed by generating the explicit feature after generating the model features that form the implicit feature.

Abstract: Expression tree versatility and applicability are enhanced to facilitate programming across various program languages and execution contexts. An expression tree can represent programmatic code as data in a representation common to multiple process mechanisms. As a result, entire programs or portions thereof can be captured and processed by a numerous common language components. Further, language specific concepts can be reduced to the common representation to enable language independent employment.

Abstract: A method and system of handling a call received at a call center is disclosed. The method includes determining that the call is a repeat call, determining whether the repeat call is to receive a first treatment type and servicing the repeat call with the first treatment type when the repeat call is determined to receive the first treatment type. The system includes an automated call processing system, a first computer readable memory including a repeat caller definition table, a second computer readable memory including a repeat caller action-object table, and a third computer readable memory including a special treatment resolution table. The automated call processing system has access to the repeat call definition table to identify a repeat call request and has access to the action-object table and the special treatment resolution table to determine whether the identified repeat call is to receive a first treatment type.

Abstract: A parser for parsing a text-coded protocol includes: a parsing rule storage module, configured to store a parsing rule for parsing a packet of the text-coded protocol; and a packet parsing module, implemented by a logic chip, configured to parse the packet according to the parsing rule stored in the parsing rule storage module, and output a parsing result. Compared with software-based parsers, the hardware-based parser provided by embodiments of the present invention improves parsing efficiency and reduces cost of the parser. In addition, the parser provided by embodiments of the present invention has a better generality.

Abstract: A method of operator overloading that enables a user of a program development environment to view both the structure of the operands of the operation being overloaded, and also the context in which the operator is being used is disclosed. The present invention utilizes a parse tree created by a language processor. The use of the parse tree, which may be represented as a class, allows the context information to be made available to a class designer. Objects of the parse tree class include methods designed to identify the operator at a root and to retrieve left and right trees. An assignment function is defined which uses two parse tree objects as arguments and performs an indicated mathematical operation based upon the context revealed by the parse tree objects. The assignment function may exist in more than one class and be overloaded. The overloading of the assignment function enables the context within which the mathematical operation is occurring to become visible and be acted upon.

Abstract: To provide for multi-language compilation, a protocol is established for compilers. Each of at least two compilers implements the protocol. A framework is developed which discovers compilers which have implemented the protocol. The framework allows multi-language compilation using and coordinating the compliant compilers. The framework is extensible. When a new protocol-compliant compiler is discovered, the language compiled by the new compiler can be compiled using the framework and the capabilities of the protocol-compliant compilers. Similarly, a multi-language extensible design tool may be created using protocol-compliant design tools.

Abstract: In a wireless communications device, methods and systems for processing a plurality of AT commands are disclosed. Aspects of the method may comprise generating AT command codes for the plurality of AT commands. The generated AT command codes for the plurality of AT commands may be compiled and linked with operating code. The linked AT commands and operating code may be executed. At least one command definition corresponding to at least one of the plurality of AT commands may be generated. The plurality of AT commands may be arranged according to the generated command definition. At least one pattern within at least a portion of the arranged plurality of AT commands may be selected and at least one command expression may be matched with the selected at least one pattern. The AT command codes for the plurality of AT commands may be generated utilizing the matched at least one command expression.

Abstract: In one embodiment of this invention, a computer system performs a method for colorizing concept keywords within program identifiers in source code. A computer system decomposes each identifier in the source code into one or more concept keywords The computer system determines a numerical value for each concept keyword based on the sequence of characters included in each concept keyword. The computer system assigns a color to each concept keyword based on the numerical value determined for each concept keyword.

Abstract: Methods, software media, compilers and programming techniques are described for creating copyable stack-based closures, such as a block, for languages which allocate automatic or local variables on a stack memory structure. In one exemplary method, a data structure of the block is first written to the stack memory structure, and this may be the automatic default operation, at run-time, for the block; then, a block copy instruction, added explicitly (in one embodiment) by a programmer during creation of the block, is executed to copy the block to a heap memory structure. The block includes a function pointer that references a function which uses data in the block.

Abstract: Systems and methods for compressing markup language data, such as XML data, are provided that utilize a finite state machine (FSM), which is representative of an XML schema, and a rule file. Information defined in an XML schema is abstracted into a finite state machine (FSM). The rule file ensures that a compressor and de-compressor have consistent FSMs when the compressor and de-compressor for XML data are not in the same location, such as is generally the case for Web Services scenarios or other client/server scenarios. With the rule file, FSMs can thus be be easily stored, transmitted and updated.

Abstract: A system and method for validating arguments in a request to activate an application is provided. An application may include declarations with information for validating arguments provided with a request to activate the application. A compiler may then compile the source code of the application to generate an assembly with information for validating the arguments and may also generate an entry in a manifest with information identifying the assembly with the information for validating the arguments. The compiler may also generate an activation executable with executable code used for validating the arguments before the application may be executed. When a request may be received with arguments for activation of the application, activation code may validate the arguments and then execute the application code which may access the validated arguments.

Abstract: Customizing a binary content file without having to recompile source code associated with the binary content file. A variable initialization module receives a binary content file and a script file. Included in the binary content file are current values for one or more variables. Included in the script file are updated values for the one or more variables. The variable initialization module processes the script file to overwrite the current values for the one or more variables with the updated values for the one or more variables. Variables are updated directly in the binary content file. Variables included in a script file may be identified from associated map files or by a scanner module that scans binary content files. Script files may include conditional statements for updating values differently depending on the configuration of a destination computing device.

Abstract: Methods, systems, and computer program products for identifying computer source code constructs are disclosed. According to one method, computer source code is converted to a format suitable for an automated inference engine. The automated inference engine receives as inputs the converted source code, a set of elemental design patterns defining patterns to be identified, and a set of rules defining relationships between patterns. The automated inference engine outputs proofs indicative of patterns present in the source code. The proofs may be converted to a source code pattern report.