Abstract: A set of managed application programming interfaces (APIs) are presented to allow management of a user's name and identity within a peer to peer networking environment. These managed APIs enable a user to successfully create and manage their peer names and identities within this environment. The creation of peer names for the purpose of resolving to a third party is also provided through the managed APIs of the invention. Importing and exporting of peer identities is also provided, as is the ability to delete a peer identity.

Abstract: The invention is a computer programming method that includes inputting a drawing shape or drawing figure into a computer via a user interface of the computer. In response to a prompt that is generated related to the input drawing shape or drawing figure, data is input into the computer via the user interface. Computer program code is then synthesized that is related to the input drawing shape or drawing figure and the input data. The foregoing steps can be repeated for at least one other drawing shape or drawing figure that has an entry point connected to a previously entered drawing shape or drawing figure.

Abstract: An architecture that extends conventional computer programming languages that compile into an instance of an extensible markup language (XML) document object model (DOM) to provide support for XML literals in the underlying programming language. This architecture facilitates a convenient short cut by replacing the complex explicit construction required by conventional systems to create an instance of a DOM with a concise XML literal for which conventional compilers can translate into the appropriate code. The architecture allows these XML literals to be embedded with expressions, statement blocks or namespaces to further enrich the power and versatility. In accordance therewith, context information describing the position and data types that an XML DOM can accept can be provided to the programmer via, for example, an integrated development environment.

Abstract: A system receives a design document, parses the design document into voice extensible markup language (VXML) elements, and creates a VXML document from the parsed VXML elements.

Abstract: Techniques and tools are described for flattening nested streams. For example, a stream flattening tool processes nested streams on a stack to traverse the nested streams. The tool produces a flattened stream that enumerates the elements of the nested streams. In one embodiment, the tool initially pushes a stack frame onto the stack for a stream representing all of the nested streams. As the tool iterates across the “active” stream having the frame on the top of the stack, the tool may encounter and produce elements in the “active” stream. Or, the tool may encounter a nested stream and push a stack frame for the nested stream onto the stack, then continuing by iterating across the new active stream. The tool pops the stack frame for the active stream from the stack when the end of the stream is reached, or potentially earlier if handling a nested tail stream.

Abstract: Various embodiments herein include one or more of systems, methods, software, and/or data structures to implement a multi-way branch statement in a computer programming language. The multi-way branch statement may include a plurality of case labels each having a non-primitive data type (e.g., strings) and being associated with a block of code to be executed dependent upon a control variable that also has a non-primitive data type. The implementation may include encoding the case labels for the multi-way branch statement as a binary decision diagram (BDD), such as a zero-suppressed binary decision diagram (ZDD), wherein the control variable for the multi-way branch statement may be compared with the case labels by stepping through the BDD. The BDD may include identifiers that provide information regarding which of the case labels is matched by the control variable, such that an appropriate code block may be executed.

Abstract: Systems and methods that integrate data type conversion(s) into a programming language, and describe external formats within a syntax thereof. A mapping component defines a declarative mapping from an external data format to one or more of its internal data types (e.g., expressing external data types in terms of source languages.) Moreover, a rule establishing component can define value-based rules, such as invariants to the external data format, wherein the schema declaration further defines data fields that make up the schema. Accordingly, by expressing rules in form of predicate logic (instead of imperative program logic) the subject innovation increase a likelihood that compilers can reason about the data.

Abstract: XML Schema Designs for environment-specific types based on XML base types are disclosed. The invention provides a series of “base types” in the XML Schema. Each base type is in an environment-specific XML Schema namespace that disambiguates the environment's types from all other types defined by any other environment. The XML Schema Design then defines the final type as an anonymous type, derived from the environment-specific base type. The base type is defined with any XML Schema type facets that apply to all derivatives of the base type, and the anonymous final type is defined with additional XML Schema type facets to fully describe the type.

Abstract: Methods and apparatus for generating a report from hierarchically formatted data are disclosed. First, a data source including one or more files having a hierarchical file format is identified, where each of the files includes one or more data elements. A relational database model is obtained, where the relational database model includes one or more virtual tables, each of the virtual tables including one or more virtual columns. The relational database model is then mapped to the hierarchical file format. A query may be obtained using the virtual relational database. Data is then obtained from the virtual relational database corresponding to the query, thereby enabling a report including the data to be generated.

Abstract: Converting components for a first user interface (UI) technology into components for a second UI technology includes enabling the second UI technology to access first components of the first UI technology, modeling second components of the first UI technology as native components of the second UI technology, the first components being usable by the native components, and defining one or more navigational paths through the native components.

Abstract: A device for automated generation of program code of a user program which can be run on a run unit on a user side is provided. The device includes a editing unit configured for programming access by an operator, a code generator and/or code converter unit and a code memory unit. The code generator and/or code converter unit converts an output signal of the editing unit with respect to data and in automated fashion in such a way that input and/or output data types of the user program are converted to classes and/or methods of a C# programming environment and are stored by the code memory unit in a source code programming database of the code memory unit. A run code generating unit is configured for generating executable program code of the user program and converting contents of the source code program database to the program code of the user program.

Abstract: Embodiments of a system and method for facilitating the use of stack cutting to be used in programming languages in a safe fashion even when composed with constructs that require destructor operations are described. For stack-based operations that require resolution through destructor operations (such as transactions, synchronization operations, deallocations, unlock operations, and the like), the destructor objects are stored in a virtual stack that is associated with the system stack, for use when a stack cut operation is performed. A container data structure stores an instantiation of the execution state at the cut back point. A virtual stack head pointer stores the location of the last destructor in the virtual stack. During a stack cut operation, the virtual stack is first unwound to execute the destructor operations until the stack frame of the container is reached. Other embodiments are described and claimed.

Abstract: A method for implementing software breakpoints in a software program to be executed by a interpreter, comprising the steps of executing a look-up, in a main loop of the interpreter, the look-up function searching a list of breakpoint addresses to determine whether a breakpoint instruction is to be executed at the address referenced by the interpreter's current instruction pointer instead of the program instruction, and maintaining, in memory, the list of breakpoints addresses separately from the program code, such that the breakpoint list can be altered separately from the program code.

Abstract: A method is disclosed of associating a mapping function with a configuration construct of a digital design defined by one or more hardware description language (HDL) files. According to the method, in the HDL files, a configuration latch is specified within a design entity forming at least a portion of the digital design. In addition, a Dial is specified that defines a relationship between each of a plurality of input values and a respective one of a plurality of different output values. The HDL files also include a statement that instantiates an instance of the Dial in association with the configuration latch such that a one-to-one correspondence exists between a value contained within the configuration latch and an input value of the instance of the Dial. The HDL files further include a statement associating the Dial with a mapping function that applies a selected transformation to values read from or written to the instance of the Dial.

Abstract: This invention utilizes a concept called color, which implies a variation, and applies it to natural language attributes like verbs and nouns. The verb color is defined as a role or operation in which the field participates. The noun color is defined as a form of the field. The auxiliary verb color is defined as a path to the field from a known object reference. The noun color may be defined by the user or may be determined, based on the object state in which the field resides. Rules are defined by adorning the fields with one or more colors. Several types of rules are invented based on transformational properties of colors. Methods can be equated to rules, and invoked as rules. Thus, complex processes may be reduced to a set of rules, using the above mechanisms.

Abstract: A Toolbox and Instrument software design and runtime system which simulates real-world Tools by providing Instruments for the Tools' configuration, control, and state monitoring before, during, and after runtime. A Tool is a software function which may be used to modify an existing object or to create a new object. Tools with related functionality are grouped by their containment within appropriately named, static classes, or object references, their grouping which represents a Toolbox. Each Tool accepts one or more input (operand) objects to be changed or zero operands if a new object will be created, and each Tool also a Configuration Instrument, a State monitoring instrument, and optional Control Instrument. Alternatively, the Control and State Instrument's functionality can be consolidated into a single Instrument, or the Control and Configuration Instrument's functionality can be consolidated into a single Instrument.

Abstract: A structured INF source language that can coexist natively within higher level language source files is used to improve the consistency and quality of custom driver package components. A common source code file includes machine readable instructions in the structured inf source language for building various components of the custom driver packages for different target customer platforms. The number of errors introduced when changes are made for particular features, configuration, and customization keys is reduced by using a single source code file. The source code is parsed to automate the production of installation scripts, online internal documentation, and enabling per device, per platform, per operating system, and per customer control. An approval process with a security feature is used to ensure that the changes to the source code are authorized.

Abstract: A solution for developing XForms projects can bind an XForms template to a backend simulator, during a development or test stage of a software development. The XForms template can be developed by an interface designer, such as a business analyst. The XForms template can be conveyed to remotely located clients. Data instances associated with the XForms template can be received and routed to the backend simulator for processing. An integration code developer can later integrate the XForms templates to a backend server instead of to the backend simulator. Accordingly, the solution accelerates XForms based development projects by decoupling XForms interface development from XForms system integration development, which are typically handled by different people having different skill sets.

Abstract: A method includes combining functionality from a matrix language programming environment, a statechart programming environment and a block diagram programming environment into an integrated programming environment. The method can also include generating computer instructions from the integrated programming environment in a single user action. The integrated programming environment can support fixed-point arithmetic.

Abstract: An invention is provided for building configurable designs synthesizable to gates. The invention includes creating a configurable design using an HDL. The configurable design has a plurality of instantiated configurable constructs that can be optionally included in a design. Basically, the configurable design is an all-inclusive design having a large set of features, including varying interfaces, FIFO depths, and other features. Then, a derived design is generated by removing configurable constructs from the configurable design based on a specification, typically a customer specification received from a customer for a particular design. The specification indicates which configurable constructs are to be included in a derived design. Thereafter, the derived design is synthesizable in logic.

Abstract: BIOS field mapping includes generating basic input/output system (BIOS) information by defining property identifications using a visual form code language and determining that a proprietary set-up service is accessible. The BIOS field mapping then includes converting the visual form code language to a binary format and storing the property identifications in binary format on a setup database as data hidden from an operating system. A BIOS driver may then request the property identifications causing a transfer of the property identifications to the BIOS driver.

Abstract: A location to insert stack clearing code into a method to be executed in an execution environment of a computer system is determined. The stack clearing code is inserted into the location of the method. The stack clearing code is executed during execution of the method to clear a stack. Other embodiments are also described and claimed.

Abstract: Methods and apparatuses provide configuration inheritance. One configuration can be derived from another (target) configuration, and properties and all content of the target configuration are inherited by the derived configuration. The derived properties and all content may exist virtually at the derived configuration, and local settings can exist locally at the configuration. The configuration architecture may allow for overwriting the derived configuration with local content to allow for modifications of the derived content to adapt to the circumstance/environment of the derived configuration.

Abstract: According to one embodiment, a binary code modification system includes a code modifier configured to access a binary software code. The code modifier generates a modified software code by inserting one or more executable instructions into the binary software code. The one or more executable instructions is operable to expose at least a portion of the binary software code as a web service interface.

Abstract: Mechanisms for binding an event handler with an event in association with a component of a hierarchical structure are provided. The mechanisms receive a structure document specifying an event, an event handler, and a binding of the event handler with the event. The mechanisms further associate the event and event handler with one or more nodes of a hierarchical model of the hierarchical structure stored in a storage device of the data processing system. Moreover, the mechanisms bind the event handler with the event for the one or more nodes in accordance with the hierarchical model. In addition, the mechanisms generate one or more objects for implementing the hierarchical structure in a framework corresponding to the hierarchical model. The structure document specifies the event binding of the event handler with the event type in a declarative manner.

Abstract: Scripting core commands and aggregations of such commands are provided to script authors to enable them to generate scripts that can be parallel-processed without requiring the author to be aware of parallel-processing techniques. The scripting core commands and aggregations abstract mechanisms that can be executed in parallel, enabling the script author to focus on higher-level concepts. The scripting core commands provided include commands for applying a function in parallel and distributing and joining data in parallel. For added flexibility, one or more scripting core commands can utilize functions written in a different programming language and referenced appropriately in code blocks.

Abstract: The subject invention relates to systems and methods that generate modules profiles for industrial control modules (e.g., I/O, scanners, adapters . . . ). A module profile generally includes a set of components, interfaces and/or plug-ins that determine possible configurations for a module. Such entities are packaged in an XML based format to provide a dynamic module profile, wherein a definition type can be dynamically changed. Development and/or configuration of a module can be achieved through an industrial software development environment via a graphical hierarchical representation of configuration options defined in the module profile. In addition, the module profile provides for separately installable/release independent utilization via XML and COM based interfaces, wherein an end-user does not have to wait for a new software release in order to add a new module.

Abstract: A generated grouped representation of existing source code can define regions of the existing source code. A set of the regions that can run in parallel can be identified based on the grouped representation. The grouped representation can be converted into a modified representation, such as modified source code or a modified intermediate compiler representation, which can be configured to be resolved or executed to self-schedule the set of regions to run in parallel as a set of tasks. Additionally, the source code can include one or more exception handling routines, and user input can be received to identify in one or more lambda expressions one or more regions of the source code to be run in parallel as one or more tasks.

Abstract: A method, system and computer program product are provided for creating software that can be used when processing insurance claims. In particular, the software generated is capable of recognizing and flagging certain situations or sets of conditions when they arise in an insurance claim that is being processed. These situations or sets of conditions, as well as the type of flag, or “edit,” that should be posted when each occurs, are defined in a decision table from which the software is automatically generated. A method of processing an insurance claim using the automatically generated software is also provided.

Abstract: Provided are a method, system, and computer program product to generate references to reusable code in a schema. A program is coded in a first programming language having data structures, wherein at least one of the data structures includes a reference to reusable code. A model file is generated providing a source name identifying the reusable code, elements and attributes in a second programming language for the reference to the reusable code in the program. A generator is invoked with a reference to the model file. The invoked generator processes the data structure coded in the first programming language to generate a data structure schema in the computer readable medium in a second programming language describing elements and attributes of the data structure coded in the first programming language. A determination is made of instances of the source name indicated in the model file in the data structure.

Abstract: A method and system for generating programming code and/or configuration data for programmable controller and the networks on which they operate is disclosed. In one embodiment, programming code is generated on a centralized server having a web-enabled engineering tool. The engineering tool operates on client devices that are in communication with the server over a network, such as the Internet. Preferably, the engineering tool runs in a browser application (or other network-interfacing-application) on the client device and a user generates the programming code on the server with the aid of the client device. By centralizing the engineering tool, which may contain a configuration editor and a configuration management tool having version management functionality, a new business paradigm for providing engineering tool services to customers having programmable controllers. In addition, new methods and tools for collaborative engineering of programming code are enabled.

Abstract: Methods and apparatuses for extending a web-based application class by performing a compile-time extension that is communicated from a client device, having a compiler implemented thereon, to a server device via a remote procedure call.

Abstract: A language-based model to support asynchronous operations set forth in a synchronous syntax is provided. The asynchronous operations are transformed in a compiler into an asynchronous pattern, such as an APM-based pattern (or asynchronous programming model based pattern). The ability to compose asynchronous operations comes from the ability to efficiently call asynchronous methods from other asynchronous methods, pause them and later resume them, and effectively implementing a single-linked stack. One example includes support for ordered and unordered compositions of asynchronous operations. In an ordered composition, each asynchronous operation is started and finished before another operation in the composition is started. In an unordered composition, each asynchronous operation is started and completed independently of the operations in the unordered composition.

Abstract: Maintaining Multiple Valid Concurrent Serialized Object Versions Techniques are disclosed for concurrently maintaining serialized objects that were created from more than one version of a class definition. According to preferred embodiments, a component maps and enforces multiple valid stream-unique version identifiers (“SUIDs”) for a collection of class definitions (such as the classes of a software product that is undergoing change from one version to another). This component programmatically detects when an object's SUID value does not match the code attempting to deserialize the object, and then programmatically determines whether the object is compatible with the code even though the SUID values do not match. Preferably, this determination is made by consulting a stored mapping, in which the SUIDs of compatible versions have been recorded.

Abstract: The present invention generally relates to a method for describing network events in a service aware network (“SAN”). In addition, the present invention relates to software that performs the method and has a programming model containing protocol libraries, abstract protocol messages declarations, and network events. The method and software enable a user to define basic as well as complex network events in the application, presentation, session, transport and/or network layers of a communication model, which result in internet protocol (“IP”) level triggers or other triggers. Such triggers will result in actions which may be applicable in all layers of a communication model up to the highest layer. As a result, the method and software allow a user to describe a hierarchy of high level network events through a hierarchy of lower level events. In addition, a development system and an apparatus which utilizes the method and software are also provided.

Abstract: An example embodiment of a includes a Home Page, a Web Presence Tool Page, and a Product and Community Forum which is created and maintained by a Hosting Provider. The Home Page may be made accessible to Hosting Customers and Partners and is an ideal location for placement of ads since all members of the Web Hosting Community are funneled through this Web page. The Web Presence Tool Page may display information generated by a Partner regarding the Partner's application which may be viewed by the Hosting Customers. The Product and Community Forum may allow the Hosting Customers to share information regarding all the applications with other Hosting Customers.

Abstract: A system and method for generating metadata for processing by various processing components is provided. A metadata compiler component is operable to generate metadata including one or more constraints which correspond to evaluation criteria and one or more anchor points from source data. A metadata optimizer and arbitrator is operable to normalize the metadata. Various processing components are operable to perform operations on a string using the metadata.

Abstract: Computer method and apparatus implements redefinition of features in a programming model. The invention method includes (i) providing a model element having a feature with a redefinition such that the feature is a redefined feature; (ii) storing indications of the redefinition; and (iii) interpreting the stored indications and generating therefrom a model that implements the redefined feature. Redefined features include redefined property names, redefined property type and redefined multiplicity of a property.

Abstract: Editing operations are monitored for operations for which information must be stored in order to properly apply an undo or undo/redo sequence to plurality of files. A snapshot is taken and persisted before such an operation is performed. Upon the execution of an undo or redo command, the persisted snapshot is retrieved and applied to the newly generated editing element.

Abstract: The present invention relates to a system and method for managing connection between web services. The system includes an external web service connection setup server for determining an external web service to which connection is to be made, and establishing and verifying connection rules, and an external web service connection management server for conducting tests on connection to the external web service and storing the results of the tests. The system may further include a component for searching a connection target DB in which connection results are stored, and transmitting connection results to a main web service server, a component for removing a hyperlink to a failure page, and a component for sensing a sudden increase in a connection failure ratio. Accordingly, external web services belonging to all fields desired by a network manager can be easily, rapidly and efficiently connected.

Abstract: A method, and corresponding software and system, for translating an expression are described. The method includes accepting a first expression in a first syntax, the expression including a first character sequence representing a string value using the first syntax; identifying a second syntax for representing the expression; and generating a second expression in the second syntax representing the first expression, including generating a second character sequence using the first character sequence such that the second character sequence represents the string value using the second syntax.

Abstract: A computer implemented method and system exit to an assembler exit while executing an application on the computer. A REXX exec is initiated with an address pointer to assembler variables on the computer. A first function executing on the computer is called to unload the variables to a REXX format using a seed. REXX statements are executed to modify at least one variable. A second function is then called to reload the REXX variable to the address as per the seed.

Abstract: A system and method for generating a service interface definition for a data source from an application definition is provided. The system and method includes: a component processor for examining components forming a component based application, which include a screen component having screen definitions, to identify a screen control mapping identifying a transition between a source screen and a target screen. The system and method includes a service interface generation engine for generating a Web service definition for a Web service interface of a backend server of a data source, based on an operation definition describing an action supported by the data source. The operation definition is constructed based on the identified transition.

Abstract: A text completion system is described herein that completes text at a tag and/or attribute level based on a syntactic understanding of software program code. The system includes sets of elements and associated attribute-value pairs that represent interesting, common, and repeated patterns. As a user is editing a web page or other document in an editing tool that implements the system, the user can retrieve, select, and insert these patterns using simple commands. The system receives a selected pattern from the user, and inserts target text associated with the pattern. In addition, users can fill in instance-specific data within the larger pattern to allow a single pattern to cover several common and closely related scenarios. Thus, the text completion system increases user productivity by providing more intelligent text completion through a syntactic understanding of the language in which a document is written.

Abstract: Process is integrated into a business application framework on which the process is built. The same programming model used by the framework is used for managing data operated on by the process and for interacting with and controlling the process.

Abstract: Syntax for creating object instances utilizing expressions instead of statements. A syntax component facilitates extension of conventional object-creation-expression syntax. An initializer component provides for initialization of a newly-created entity via object and collection initializers. The initializer component provides initialization of the newly-created entity utilizing an object initializer where the object initializer specifies values for one or more fields or properties of the newly-created entity which is an object, and consists of a sequence of member initializers enclosed by tokens and separated by commas. The initializer component can also provides initialization of the newly-created entity utilizing a collection initializer when the underlying object implements a certain interface or implements a certain pattern. An overloading constructor can be called as part of the initialization process.

Abstract: The auditing of authorization decisions is facilitated by integrating or coupling an audit policy to access control decisions. In an example implementation, an audit policy of an auditing scheme is coupled to a semantic framework of an access control scheme such that the audit policy is specified using at least a portion of the semantic framework. In another example implementation, audit policy rules include audit content rules that specify what audit information from any of the inputs, the outputs, or the internal data of authorization decisions is to be included in an audit record. In yet another example implementation, a semantic of an audit trigger rule comports with a semantic framework of an access request and of a logical evaluation for an authorization decision.

Abstract: Interface code is produced to use services of an enterprise information system. An application specific information schema is provided that defines the format and shape of application specific information usable in a business object schema defining the business object and the application specific information for the enterprise information system. An enterprise metadata discovery schema is also provided for anchoring the application specific information schema to complex type, element, attribute and the business object schema. The business object schema is generated using a metatdata editor. The interface code is produced using the business object schema.

Abstract: An application object for a supervisory process control and manufacturing information system application distributable to a plurality of networked computer devices and having a layered architecture, the application object comprising a set of text entries listed in a first language, a dictionary within each object drafted to enable the set of text entries to be translated into a plurality of multiple languages, and a set of one or more translation fields for storing text in each of the plurality of languages corresponding to the set of text entries listed in the first language.

Abstract: As to an object-oriented programming, reuse of softwares is enhanced and running speed is improved. There are made up a data element list in which pointers to data storage areas of object A are arranged and a pointer element list in which pointers to pointer storage areas of object B are arranged. A combination of the data element list and the pointer element list makes it possible to directly refer to data of the object A from the object B.