Inventors list

Assignees list

Classification tree browser

Top 100 Inventors

Top 100 Assignees


Programming language

Subclass of:

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

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

Patent class list (only not empty are listed)

Deeper subclasses:

Class / Patent application numberDescriptionNumber of patent applications / Date published
717115000 Script 55
717116000 Object oriented 53
717118000 Bytecode (e.g., Java) 18
717117000 Declarative (e.g., rule based) 10
717119000 Parallel 6
Entries
DocumentTitleDate
20130031529DOMAIN SPECIFIC LANGUAGE DESIGN - A method for domain specific language design includes, with a physical computing system, receiving from a user, a number of annotations for at least one of a set of statements within a problem domain, the annotations identifying a set of elements within the statement. The method further includes forming a set of grammar rules for the problem domain based on the annotations, and parsing the set of statements using the set of grammar rules.01-31-2013
20120180025DYNAMICALLY GENERATING STATICALLY-TYPED PROXIES FOR DYNAMICALLY-TYPED FUNCTIONS - Embodiments of the present application may simplify an integration of statically typed and dynamically typed languages by automatically generating an implementation of a statically typed native interface for a given set of dynamically typed functions. In an embodiment, functions in a dynamically typed language are automatically interconnected with functions in a statically typed language. Code that bridges and/or connects a statically typed interface and a dynamically typed interface embodied in the dynamically typed source code may be automatically generated. The statically typed interface may be provided by a user. Further, an extensible set of runtime rules that determine how to convert between statically typed and dynamically typed data may be provided.07-12-2012
20100107138FLASH PRESENTATION MARKUP LANGUAGE (FLML) FOR TEXTUALLY EXPRESSING FLASH PRESENTATIONS - A document written in a specialized FLASH presentation markup language (FLML) stored in a storage medium. Such a document can textually represent a FLASH presentation. The text can correspond to a FLAPRE markup language (FLML) that can be interpreted at run-time. The structure and syntax of the FLML can conform to a standardized markup language. The FLML document can include FLML tags having FLML attributes and FLML attribute values.04-29-2010
20090319989MODIFICATION OF SOFTWARE AT RUNTIME - Disclosed are techniques for injecting one or more additional modules into a starting Windows process and ensuring that these modules are loaded and initialized at the earliest possible time by the Windows loader. The technique reuses the Windows loader by intercepting the normal loading of initial and subsequent module loads by the process at a single well-defined point in the loader. Methods for identifying and locating binary constructs using binary construct signatures are also disclosed.12-24-2009
20090307660TICC-PARADIGM TO BUILD VERIFIED PARALLEL SOFTWARE FOR MULTI-CORE CHIPS - This invention teaches a way of implementing formally verified massively parallel programs, which run efficiently in distributed and shared-memory multi-core chips. It allows programs to be developed from an initial abstract statement of interactions among parallel software components, called cells, and progressively refine them to their final implementation. At each stage of refinement a formal description of patterns of events in computations is derived automatically from implementations. This formal description is used for two purposes: One is to prove correctness, timings, progress, mutual exclusion, and freedom from deadlocks/livelocks, etc. The second is to automatically incorporate into each application a Self-Monitoring System (SMS) that constantly monitors the application in parallel, with no interference with its timings, to identify and report errors in performance, pending errors, and patterns of critical behavior. This invention also teaches a way of organizing shared-memory for multi-processors that minimizes memory interference, protects data and increases execution efficiency.12-10-2009
20090307659MODULAR ASL COMPONENT - A system for source language module interaction using an event mechanism includes one or more subsystems to detect a producer event, detect a consumer event, generate a new source language method for the producer event and a new source language method for the consumer event, and link the producer event and the consumer event using the new source language method. In an embodiment, the source language may be ASL.12-10-2009
20090271763METHOD FOR PROTECTING USER-MANAGED MEMORY USING AN EXCEPTION - Techniques for providing safe user-managed memory are provided The techniques include performing memory allocation in constant time, performing memory de-allocation in constant time, performing memory access overhead for safety checking in constant time, and using the memory allocation, memory de-allocation and memory access overhead to protect at least one memory access, user-specified allocation and de-allocation with at least one exception for said user-managed memory.10-29-2009
20080295073PROGRAM PRODUCT PROVIDING A CONFIGURATION SPECIFICATION LANGUAGE HAVING CLONE LATCH SUPPORT - Methods, data processing systems, and program products supporting the insertion of clone latches within a digital design are disclosed. According to one method, a parent latch within the digital design is specified in an HDL statement in one of the HDL files representing a digital design. In addition, a clone latch is specified within the digital design utilizing an HDL clone latch declaration. An HDL attribute-value pair is associated with the HDL clone latch declaration to indicate a relationship between the clone latch and the parent latch according to which the clone latch is automatically set to a same value as the parent latch when the parent latch is set. Thereafter, when a configuration compiler receives one or more design intermediate files containing the clone latch declaration, the configuration compiler creates at least one data structure in a configuration database representing the clone latch and the relationship between the clone latch and the parent latch.11-27-2008
20090106735AMBIENT EXPERIENCE INSTRUCTION GENERATION - A method for generating a sequence of instructions comprises determining one or more time values, accessing a pool of markup language fragments, and processing the markup language fragments according to the or each time value. The output of the processed fragments is then combined into a sequence of time-stamped instructions either as a single file or as a number of device-specific files. A system implementing the method is also described.04-23-2009
20100122237Systems and Methods For Improved Parallel ILU Factorization in Distributed Sparse Linear Systems - Systems and methods for parallel ILU factorization in distributed sparse linear systems, which utilize a method for ordering nodes underlying the equations in the system(s) and reducing processing time.05-13-2010
20080288920APPARATUS FOR GENERATING JOB NETWORK FLOW FROM JOB CONTROL STATEMENT DESCRIBED IN JOB CONTROL LANGUAGE AND ITS METHOD - An object of the present invention is to convert JCL files into a job network without manual labour.11-20-2008
20100088674SYSTEM AND METHOD FOR RECOGNIZING STRUCTURE IN TEXT - A method, system, and computer product for processing information embedded in a text file with a grammar programming language is provided. A text file is parsed according to a set of rules and candidate textual shapes corresponding to potential interpretations of the text file are provided by compiling a script. An output is provided, which may include either a processed value corresponding to a particular textual shape, or a textual representation of the text file that includes generic data structures that facilitate providing any of the candidate textual shapes, where the generic data structures are a function of the set of rules.04-08-2010
20080209394Generic interface for numeric types - Various technologies and techniques are disclosed for providing a common generic interface for numeric types in statically typed languages. The common generic interface defines basic arithmetic operations, thereby allowing basic arithmetic operations to be performed on the numeric types. The common generic interface provides support for overflow detection when a result of an operation being performed on a particular numeric type will result in an overflow situation when the operation does not fit within a range supported by the particular numeric types. The common generic interface provides support for one or more mathematical properties to be retrieved for a particular one of the numeric types being used in a particular circumstance.08-28-2008
20090288067Augmenting Programming Languages with a Type System - Described is a technology by which metadata augments a programming language such as JavaScript. Software components such as application programming interfaces are associated with metadata. When a software component is selected for use, such as when putting together a computer program in a graphical programming environment, its corresponding metadata is accessed. The metadata may be used to validate the usage of the software component, such as to validate a constraint associated with a value, provide a default value, validate a value's type, and/or determine whether a value is required. Validation may also determine whether data output by one software component is of a type that is appropriate for input by another software component. In addition to validation via type metadata, the metadata may provide descriptive information about the selected software component, such as to assist the programmer and/or provide further information to the programming environment.11-19-2009
20100005446METHOD, SYSTEM AND PROGRAM PRODUCT FOR DETECTING DEVIATION FROM SOFTWARE DEVELOPMENT BEST PRACTICE RESOURCE IN A CODE SHARING SYSTEM - Under the present invention, a best practice violation (BPV) engine resource is first built. This typically occurs by: receiving sets of source code from a plurality of sources; detecting a programming language of each of the sets of source code; extracting code patterns from the sets of source code; defining meta data for each code pattern that indicates a quality thereof, classifying each code pattern; and assigning a rank to each of the code pattern based on it's corresponding meta data as well as a skill level and an experience level of the developer thereof. Once the BPV engine resource is built, it will be used to detect best practice violations in other sets of source code.01-07-2010
20080250390METHOD FOR DECLARATIVE SEMANTIC EXPRESSION OF USER INTENT TO ENABLE GOAL-DRIVEN STREAM PROCESSING - A method for constructing a stream processing requests so that a stream processing application satisfying the stream processing request can be assembled, includes: inputting a stream processing request, wherein the stream processing request includes a goal that is represented by a graph pattern that semantically describes a desired stream processing outcome; and assembling a stream processing graph, wherein the stream processing graph is assembled to include at least one processing element that satisfies the desired processing outcome by associating the graph pattern that semantically describes the desired processing outcome with a graph pattern that semantically describes an input of the at least one processing element and a graph pattern that semantically describes an output of the at least one processing element, or to include at least one data source by associating the graph pattern that semantically describes the desired processing outcome with a graph pattern that semantically describes an output of the at least one data source.10-09-2008
20090119641PROGRAMMING LANGUAGE EXTENSIONS IN STRUCTURED QUERIES - The insertion and processing of programming language code (e.g., C#) in SQL statements, and the dynamic compiling of the code to detect errors prior to statement execution. The SQL statement with arbitrary programming language code can then be executed concurrently as a query on a computer cluster. External libraries can be imported and the associated functionality leveraged from within a SQL statement. The programming language compiler performs checking at build time, rather than retuning an error during the statement execution against the cluster, a potentially costly proposition in both computing time and human resources.05-07-2009
20080295072Assets and Effects - A method of operating a set of devices comprises receiving a real-world description in the form of an instruction set of a markup language (11-27-2008
20090064104Method and apparatus for supporting multiple business process languages in BPM - A method and apparatus for supporting multiple business process languages in business process management (BPM). The method may include receiving user input identifying a definition of a business process, and determining which business process language was used for the definition of the business process. The method further includes invoking a runtime environment associated with the used business process language, and executing the business process in the invoked runtime environment.03-05-2009
20090055800Modular Integration of Distinct Type Systems for the Compilation of Programs - A method for extending functionality of a compiler includes: receiving a first source file written in a language that supports multiple system types, wherein the first source file includes a plurality of source constructs associated with parameter types of the multiple type systems; annotating each of the plurality of source constructs with the type system from one of the multiple type systems and precise parameter type to which its associated type system belongs; retrieving type system rules corresponding to each type system referred to in the first source file from a type system loader; verifying, using the type system rules, that instances of use of variables, expressions, and methods in the first source file are appropriate with respect to the type system of annotated types associated with the source constructs; and compiling the first source file to produce a second source file including type information retained from the first source file.02-26-2009
20110225565OPTIMAL INCREMENTAL WORKFLOW EXECUTION ALLOWING META-PROGRAMMING - A workflow is described and subsequently constructed by a general-purpose program. Among other things, such construction enables meta-programming to be employed. Further, workflow item and task dependencies can be explicitly expressed in the workflow and utilized to, among other things, optimize workflow execution for one or more factors. For instance, dependency information can be employed with respect to scheduling concurrent execution of tasks as well as to confine re-execution, upon workflow or item changes, to tasks affected by the changes. In addition, messages pertaining to workflow processing can be typed to facilitate logging in a structured and easily comprehensible manner.09-15-2011
20090199159DECLARATIVE EXECUTION CONTEXT SPLITTING - Various technologies and techniques are disclosed for enabling code to be executed on one or more execution contexts based upon declarative annotations contained in the code or other locations. An annotation associated with a region of code is located. The annotation specifies information about an execution context where the region of code should be executed. A caller proxy is generated that is responsible for calling a callee adapter to execute the region of code. The callee adapter is generated that is responsible for receiving a call from the caller proxy and for dispatching a call to the region of code at the execution context. At runtime, the caller proxy receives a request to call the region of code and sends an execution request to the callee adapter. The callee adapter receives the execution request and dispatches a call to an executable version of the region of code.08-06-2009
20110231816REFLECTION CAPABILITY IN STATIC PROGRAMMING LANGUAGES - Methods and computer program products for enabling reflection capability in the C programming language are provided. One method includes generating a database for a program written in the C programming language when compiling the program, wherein the database is based on structures included within the program. The method further includes storing the database in memory and utilizing the database during run-time to enable the program to observe and modify its own structure and behavior. One computer program product includes executable portions for performing the above method. Another method includes creating a database for a program written in the C programming language, wherein the type database is based on structures included within the program and is created prior to the program being compiled. This method further comprises storing the database in memory and utilizing the database during run-time to enable the program to observe and modify its own structure and behavior.09-22-2011
20090204943Customization creation and update for multi-layer XML customization - Embodiments of the present invention provide techniques for customizing aspects of a metadata-driven software application. In particular, embodiments of the present invention provide (1) a self-contained metadata engine for generating customized metadata documents from base metadata documents and customizations; (2) a customization syntax for defining customizations; (3) a customization creation/update component for creating and updating customizations; (4) a customization restriction mechanism for restricting the creation of new customizations by specific users or groups of users; and (5) memory and caching optimizations for optimizing the storage and lookup of customized metadata documents.08-13-2009
20090249292Processing strings based on whether the strings are short strings or long strings - The specification of a string within source code written in a programming language is received. The source code is processed for ultimate execution of a computer program encompassing the source code, by at least performing the following. It is determined whether the string specified is a short string or a long string. The string is processed in accordance with a first manner where the string is a short string. The string is processed in accordance with a second manner where the string is a long string.10-01-2009
20090222793Virtual Machine and Programming Language for Event Processing - A virtual machine supports execution of compiler-generated code and provides an execution environment for code that may correspond to any of several different event-driven or message-driven programming models (such as state machines, rules for complex event processing and event correlation, monitoring contexts, processes, and mediations). The programming models may be used in business monitoring and/or business integration environments. A programming language is defined for execution using the virtual machine, which contains a relatively small number of instructions and which is preferably generated by a compiler from a higher-level, event-driven or message-driven model.09-03-2009
20080313609CORE OBJECT-ORIENTED TYPE SYSTEM FOR SEMI-STRUCTURED DATA - A type system employing structural subtyping is disclosed herein. A core type system supports several structural types, such as stream, choice, intersection and sequence. Also part of the core type system is a new invariant type, which denotes values whose dynamic type is the same as its static type, and type restrictions for limiting a range of a base type. Furthermore, a streamlined structural version of delegates, called structural delegates and a validation method thereof are introduce into the type system. To further facilitate type safety, strict statically checked interface casts are introduced.12-18-2008
20100162211PROVIDING ACCESS TO A DATASET IN A TYPE-SAFE MANNER - A method of providing access to a dataset in a type-safe manner includes storing a dataset including a plurality of data elements and a corresponding plurality of order keys for indicating an ordering of the data elements. Each order key is associated with one of the data elements. An interface to the dataset is generated that is parameterized by an element type parameter and a key type parameter. The interface is configured to provide access to the data elements and the order keys in the dataset in a type-safe manner.06-24-2010
20100269098System and Method For Generating A Web Service Definition And Database Schema From Wireless Application Definition - 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.10-21-2010
20100269097SCRIPTING LANGUAGE ASSEMBLER EXIT - 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.10-21-2010
20090037877METHOD FOR PROVIDING DATA TO A DIGITAL PROCESSING MEANS - A method for providing generic formatted data to at least one digital data processor, configured to translate generic formatted data into specific formatted data. The generic formatted data includes data relative to logical blocks, at least one of the logical blocks corresponding to an object to be processed directly or indirectly according to specific formatted data by at least one processing platform with processor(s) and memory(ies), located upstream from the processor or integrated into the processor, the object being made up of elementary information of same type, all information being represented by at least one numerical value.02-05-2009
20090031284System and Method of Creating and Communicating with Component Based Wireless Applications - A system and method of creating and communicating with wireless component applications is provided. Mobile communication devices communicate with a web service via a wireless network, the Internet, and optionally a message-map service. Each wireless component application is executed by a component framework on one of the mobile communication devices, and comprises data components, presentation components, message components, and workflow components. The component framework executes the component application in an application container which provides access to framework services which include a communication service, a screen service, a persistence service, an access service, a provisioning service, and a utility service. Messages can be sent from the component application to the message-map service, which converts each of the messages to a format required by the web service using an application message-map, and then sends the message to the web service. The web service sends a response to the message-map service, which converts the response to the format required by the wireless component application, and sends the response to the wireless component application.01-29-2009
20090217241GRACEFUL TERMINATION OF A WEB ENABLED CLIENT - In an embodiment, a client-server based project schedule management system comprises a task editor accessible through a web browser to perform various scheduling tasks by members of a project. A web enabled client receives browser executable code from a web server. The executable code includes an exception handler coded in JavaScript. A portion of the received code is executed within the exception handler to determine whether an abnormal condition has been encountered. If an abnormal condition has been encountered, the exception handler calls one or more global functions to gracefully terminate execution of the client-side browser executable code, clears the currently displayed browser window and displays an error message in the browser window. The exception handler includes one or more JavaScript try and catch block statements. The displayed error message may be used to provide notice to a user of the client that the task editor session has failed and/or output diagnostic information associated with the abnormal condition.08-27-2009
20090217240SCRIPT GENERATION FOR GRACEFUL TERMINATION OF A WEB ENABLED CLIENT BY A WEB SERVER - A client-server based project schedule management system comprises a task editor accessible through a web browser to perform various scheduling tasks by members of a project. A web server executes a code which is tested for abnormal conditions using an exception handler coded in PHP. If an abnormal condition has been encountered, the exception handler calls one or more global functions to generate and send a JavaScript to the client for gracefully terminating execution of the client-side browser executable code. The exception handler also contemporaneously terminates execution of executable code on the web server which encountered the abnormal condition.08-27-2009
20110161927GENERATING VOICE EXTENSIBLE MARKUP LANGUAGE (VXML) DOCUMENTS - 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.06-30-2011
20090241091Language-Level Integration of Programming Models - To enable language-level integration of multiple programming languages into a single programming framework, one or more domain specific languages (DSLs) are specified as incremental extensions to a host programming language. An application created in this framework may include program code written in the host language as well as DSL inset code that is written in any of the DSLs. The extensions to the host language are described in DSL specifications, which define how the DSL inset code is processed. At runtime, DSL inset code in the source code is detected and passed to a DSL inset processor for execution according to an appropriate DSL specification, whereas source code in the host language is executed by a host language processor.09-24-2009
20090241090Extending the functionality of a host programming language - To enable language-level integration of multiple programming languages into a single programming framework, one or more domain specific languages (DSLs) are specified as incremental extensions to a host programming language. An application created in this framework may include program code written in the host language as well as DSL inset code that is written in any of the DSLs. The extensions to the host language are described in DSL specifications, which define how the DSL inset code is processed. At runtime, DSL inset code in the source code is detected and passed to a DSL inset processor for execution according to an appropriate DSL specification, whereas source code in the host language is executed by a host language processor.09-24-2009
20090187885CALLING FUNCTIONS AS METHODS - A method and apparatus for converting a method call to a function call. In one embodiment, the method comprises receiving an argument list from a function that has been called by a subroutine call. The method further comprises determining whether the subroutine call is a method call from the argument list. In response to a determination that the subroutine call is the method call, the method comprises converting the method call into a function call.07-23-2009
20090172637MARKUP-BASED LANGUAGE FOR MANIFESTS - Applications are deployed with manifests authored in a markup-based language to leverage the benefits afforded thereby. Application manifests are simple and easily expressible without requiring a complex implementation. Markup elements or tags can be mapped directly to objects or an object hierarchy visible to programmers to enable fine grain control. Programmers can subsequently interact with these objects in a predictable and consistent manner.07-02-2009
20110321008MULTI-MODAL CONVERSION TOOL FOR FORM-TYPE APPLICATIONS - GUI form code comprising a set of GUI elements can be imported. A user interface description can be generated from the GUI form code that has an element corresponding to each GUI element. For each user interface element converted from a corresponding to one of the GUI elements, a user interface element type can be determined as can temporal associations between the user interface elements. A Conversation User Interface (CUI) code corresponding to the GUI form code can be created from the user interface description. When creating the CUI code for each of the user interface elements, different and rules to convert the user interface element into CUI code can be used depending on a user interface element type of the user interface element being converted. When creating the CUI code, the user interface elements can be temporally ordered based on the pre-determined spatio-temporal associations between the graphical user interface (GUI) elements.12-29-2011
20120072886DOMAIN SPECIFIC LANGUAGE CREATION - In one embodiment of the present invention, a method for using a domain specific computer language to extend an existing computer language is provided, comprising: creating a rule for validation for a compiler, the rule for validation created in a rule description language created specifically to describe rules for validation, the rule defining a part of the domain specific computer language; examine source text to identify a domain specific language to use for compiling; and compiling the source text using a compiler for an existing computer language using the identified domain specific language, wherein the compiler contains a rules interpretation engine that runs the rules for validation for the identified domain specific language, wherein the rules for validation are external to the compiler.03-22-2012
20110099535Encoding Switch on Ordered Universes with Binary Decision Diagrams - 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.04-28-2011
20120233592Meta Garbage Collection for Functional Code - An execution environment for functional code may treat application segments as individual programs for memory management. A larger program of application may be segmented into functional blocks that receive an input and return a value, but operate without changing state of other memory objects. The program segments may have memory pages allocated to the segments by the operating system as other full programs, and may deallocate memory pages when the segments finish operating. Functional programming languages and imperative programming languages may define program segments explicitly or implicitly, and the program segments may be identified at compile time or runtime.09-13-2012
20100175048ARCHITECTURE THAT EXTENDS TYPES USING EXTENSION METHODS - Architecture that extends existing types including constructed and sealed types using extension methods. Extension methods are static methods that can be invoked using instance method syntax. Extension methods are declared by specifying the keyword “this” as a modifier on the first parameter of the methods. Extension methods have all the capabilities of regular static methods. In addition, once imported, extension methods can be invoked using instance method syntax. Also disclosed are rules for importing extension methods, and extension method invocations. Extension methods are imported through using-namespace-directives. In addition to importing the types contained in a namespace, a using-namespace-directive imports all extension methods in all static classes in the namespace. In effect, imported extension methods appear as additional methods on the types that are given by their first parameter and have lower precedence than regular instance methods.07-08-2010
20090019423XML BOARD SUPPORT CUSTOMIZATION - A markup language file comprises software build options usable to determine at least one software build configuration setting. One or more software build options are specified in a markup language file to specify one or more software build configuration settings for use in compilation of software. The markup language is an XML file, is editable in an Integrated Development Environment such as via a Graphical User Interface, and includes settings specific to an embedded processor system configuration.01-15-2009
20080301632Controller programmed with graphical language driving molecular sensor - An easy way of introducing a controller into an instrument used to study biomolecular interactions without labels. By introducing a controller, which may be programmed using a graphical programming language, into the system the development time for that system can be made much shorter.12-04-2008
20120266133PRECONDITION GENERATING APPARATUS - There is provided a precondition generating apparatus in which a storage stores a set “S” of logical expressions; a creating unit creates a first logical expression being a logical product of the “S”, logical expressions of a program and a negation of a logical expression indicating a postcondition; a solver finds a solution that makes the first logical expression true and specifies a set of clauses that cannot be simultaneously true in the first logical expression if not found; wherein the creating unit sets relaxing variables for the logical expressions belonging to the set “S” in the set of clauses wherein the logical expressions indicates a precondition of the program, generates a second logical expression by alleviating the clauses of logical expressions corresponding to the relaxing variables in the first logical expression, and applies same process as in the first logical expression to the second logical expression.10-18-2012
20120331446USING RANGE VALIDATION IN ASSEMBLY LANGUAGE PROGRAMMING - Embodiments of the present invention provide a method, system and computer program product for USING range validation during assembly of an assembly language program. In an embodiment of the invention, a method for USING range validation during assembly of an assembly language program has been provided. The method can include parsing assembler language source code loaded for assembly in an assembler executing in memory of a computer. The method also can include identifying a USING statement in the source code establishing a base address as the content of a register. Finally, in response to additionally identifying a subsequent statement in the source code that modifies the content of the register, a warning of an invalid USING range can be generated.12-27-2012
20120151437METHOD FOR TRANSLATING A COBOL SOURCE PROGRAM INTO READABLE AND MAINTAINABLE PROGRAM CODE IN AN OBJECT ORIENTED SECOND PROGRAMMING LANGUAGE - A method is disclosed for translating by a computer system of a COBOL computer program into a translated computer program in a readable and maintainable syntax in an object oriented programming language. The translated program including variable names equivalent to the original COBOL variable names and with attributes described in COBOL syntax. The translating method further providing for memory allocation in the translated computer program for storage of “COBOL” variables compatible with that of the original COBOL program; a description of program flow that is readable, and utilizing arithmetic operators to describe operations between COBOL variables. Also disclosed is a special object oriented run-time library for creating and performing operations between COBOL numeric objects, including maintaining storage of variable content in the original COBOL format, and for enabling readability of the translated source code by allowing arguments for variable type descriptions to be expressed in COBOL syntax.06-14-2012
20130024839SCALABLE LANGUAGE INFRASTRUCTURE FOR ELECTRONIC SYSTEM LEVEL TOOLS - Systems and methods of scalable language infrastructure for electronic system level tools. In accordance with embodiments of the present invention, knowledge about types, functions and the like is encapsulated in a plurality of intelligent components called active component extension modules that are external to the infrastructure. The infrastructure implements a communication mechanism between the clients and these intelligent components, and acts as a common backbone. The infrastructure itself does not maintain any knowledge about any client, types, functions, etc. In accordance with a method embodiment of the present invention, a request is received from a client of a language infrastructure. The request is forwarded from the language infrastructure to an active component extension module. The active component extension module performs a service responsive to the request.01-24-2013
20080216052Application Program Interface for Network Software Platform - An application program interface (API) provides a set of functions that make available support for processing XML documents for application developers who build Web applications on Microsoft Corporation's .NET™ platform.09-04-2008
20130159967AVAILABLE SYMBOL SET GENERATION USING UNTYPED VARIABLE - The facilitated computation of an available symbol set at code locations in a dynamic language program, in which the program is executed up to a particular halt point for which an available symbol set is to be generated. At the halt point, a type of a value of a particular variable may be used in order to generate the available symbol set. However, at the halt point, the variable does not yet have a value of a useful type (e.g., null or undefined), which is possible in a dynamic language program. Rather than return an error, the principles described herein returns an arbitrary symbol set anyway. Specifically, the variable had previously been annotated with information represented accessed type information for the variable, even though the variable has not formally been defined. This annotated information may be used to generate the available symbol set.06-20-2013
20130159968LANGUAGE SERVICE PROVIDER MANAGEMENT USING APPLICATION CONTEXT - A language service provider framework that generates an application context of a dynamic language program being authored. The application context includes a description of the dynamic language application being authored, one or more specific locations within the program, and runtime environment information. A language service provider port component holds one or more language service providers. Each language service provider may receive the application context and generate a set of available symbols corresponding to each of at least one of the identified one or more specific locations. A management component receives the application context from the application context generation component, provides the application context the language service provider, and correspondingly receives the available symbol set from the language service provider. Since the management component provides an application context that also includes runtime environment information, the available symbol set may be more accurately represented, thereby facilitating authoring of dynamic language programs.06-20-2013
20130185698SIMPLIFYING ANALYSIS OF SOFTWARE CODE USED IN SOFTWARE SYSTEMS - An aspect of the present invention facilitates analysis of software code written in a programming language. In one embodiment, a visual interface designed to receive values identifying constructs of the programming language is provided on a display unit. In response to receiving, from a user using the visual interface, values corresponding to a construct of interest, a rule indicating a string of characters (that would constitute the construct of interest) is generated based on the received values. The generated rule is then applied to the software code to identify blocks matching the string of characters, each block representing a corresponding occurrence of the construct of interest in the software code.07-18-2013

Patent applications in class Programming language

Patent applications in all subclasses Programming language