| Class / Patent application number | Description | Number of patent applications / Date published |
|---|
| 719331000 | DYNAMIC LINKING, LATE BINDING | 75 |
| 20080256564 | Application Compatibility Using a Hybrid Environment - A hybrid environment may be used for addressing application compatibility between a host operating system and one or more application(s) optimized to run on a different (“guest”) version of the host operating system. A thunking wrapper consisting of a native thunking layer, a service thunking layer, and a subsystem thunking layer provides translation between the guest application and the host operating system for a seamless interface. Multiple thunking wrappers may be included to support application compatibility between multiple guest operating systems and the host operating system. | 10-16-2008 |
| 20080301719 | Mapping Of Dynamic Link Libraries In Computing Devices - A remapping component is provided for facilitating a link between an executable and a function held in a new dynamic link library (DLL) in a computing device. The remapping component is provided with a relocation instruction arranged to update, upon loading, an export data table entry for the remapping component with the address location of the function in the new dynamic link library. In this way, the executable, when calling for the function at an address location in a known DLL, will automatically jump to the address location for the function in the new DLL. The additional subroutines usually associated with remapping DLLs can therefore be avoided, providing improved operation for the computing device. | 12-04-2008 |
| 20080307446 | Interoperable Managed and Unmanaged Code in a Document Environment - Managed and unmanaged code may operate in a document environment by enabling managed code to be called by unmanaged code. The managed code may make functions available to unmanaged code by creating a type library and loading the type library into a running object table using a filename identifier. The filename identifier may be used by the unmanaged code to locate the type library and thereby call managed code functions. | 12-11-2008 |
| 20090007161 | NAMESPACE MERGER - In a virtualization environment, there is often a need for an application to access different resources (e.g., files, configuration settings, etc.) on a computer by name. The needed resources can potentially come from any one of a plurality of discrete namespaces or containers of resources on the computer. A resource name can identify one resource in one namespace and another resource in another namespace, and the namespaces may have different precedence relative to one another. The resources needed by the application can be accessed by enumerating names in a logical merger of the namespaces such that as new names in the logical merger are needed they are dynamically chosen from among the namespaces. When two resources in different namespaces have a same name, the resource in the higher precedence namespace can be chosen. | 01-01-2009 |
| 20090007162 | FLEXIBLE NAMESPACE PRIORITIZATION - Access to resources on a computer may be provided by using a first namespace of resources and a second namespace of resources, where one or more names are common to both namespaces and those names refer to different respective instances of resources. A request is received for a first resource name from an application, where the first resource name exists in the first resource namespace and in the second resource namespace. In response to the request, whether to obtain a resource from the first namespace or from the second namespace is determined by applying one or more resource policies to the first resource namespace and to the second resource namespace. | 01-01-2009 |
| 20090013337 | APPARATUS, SYSTEM, AND METHOD FOR SWITCHING DATA LIBRARY MANAGERS - A device, method, and system for switching library managers of a data library while maintaining data library storage devices online. A library manager accepts and executes data transaction commands for access to data residing on the storage devices of the data library. A transition manager module receives a directive to transition library management functions from a first library manager to a second library manager. The transition manager module stops the first library manager from accepting new data transaction commands while maintaining the storage devices online. The first library manager may execute previously accepted data transaction commands. The transition manager module suspends the library management functions of the first library manager and activates the library management functions of the second library manager. The storage devices of the data library may complete data transaction commands throughout the library manager transition. | 01-08-2009 |
| 20090049459 | DYNAMICALLY CONVERTING SYMBOLIC LINKS - Technologies, systems and methods for converting symbolic links from one file system format to another. In particular, presented are example technologies that operate in conjunction with NTFS file systems and that determine the need and convert NFS symbolic links to be compatible with NTFS. | 02-19-2009 |
| 20090094624 | METHOD AND APPARATUS FOR BEQUEATHING PRIVILIGE TO A DYNAMICALLY LOADED MODULE - A computer implemented method, apparatus, and computer program product for transferring a privilege to a module. In one embodiment, a set of privileges required to initiate execution of code associated with the software module is identified to form enhanced privileges. The application is frozen. The enhanced privileges are unassigned to the application and the application has insufficient privileges to initiate execution of code associated with the software module. The software module is loaded into available application address space associated with the application. The enhanced privileges are transferred to the application. Execution of the application is unsuspended and the code associated with the software module is executed within the application. | 04-09-2009 |
| 20090133042 | EFFICIENT LINKING AND LOADING FOR LATE BINDING AND PLATFORM RETARGETING - The present invention is directed to a loadable virtual memory manager, and generally to a computer operating system capable of supporting application programs running in a computer having a working memory, the computer operating system including a kernel resident in the working memory at run time, and a loadable virtual memory manager resident at link time outside of the working memory and dynamically loadable into the working memory at run time upon demand of one of the application programs. The kernel includes a loader for loading the virtual memory manager into the working memory in response to a demand from one of the application programs. The computer is able to access a storage memory separate from the working memory, the loadable virtual memory manager residing at link time in the storage memory. The loader loads the virtual memory manager from the storage memory to the working memory. The loadable virtual memory manager is removable from the working memory upon lack of demand therefor by the application programs. | 05-21-2009 |
| 20090172712 | BIOS RUNTIME SERVICES INTERFACE - A method and article of manufacture for accessing at least one unexposed runtime service. | 07-02-2009 |
| 20090172713 | ON-DEMAND EMULATION VIA USER-LEVEL EXCEPTION HANDLING - Methods and apparatuses enable on-demand instruction emulation via user-level exception handling. A non-supported instruction triggers an exception during runtime of a program. In response to the exception, a user-level or application-level exception handler is launched, instead of a kernel-level handler. Then the exception handler can execute at the application layer instead of the kernel level. The handler identifies the instruction and emulates the instruction, where emulation of the instruction is supported by the handler. Emulating the instructions enables the program to continue execution. Repeated instruction emulation is amortized via dynamic binary translation of hot code. | 07-02-2009 |
| 20090172714 | METHOD AND APPARATUS FOR COLLECTING METADATA DURING SESSION RECORDING - Text that appears in sessions presented on a computer screen is indexed to enable future text-based search of the session content. During the recording, a text capture algorithm is used to capture any text data presented on any window on the computer screen, either in a selective or in an all-encompassing manner. Data captured are indexed to the capture time because a timestamp must be known to allow for a search that can provide temporal relevance. The interval used to capture the window data is modifiable, based on the needs of the application. Once the window is scanned, a comparison is done with the results of previous captures to determine if there is a need to update the metadata database with new results. | 07-02-2009 |
| 20090172715 | NETWORK OPERATING SYSTEM - Generally described, the present invention is directed to a network operating system that provides more effective ways of leveraging the connectivity of computer networks. In one embodiment, an XML virtual machine is implemented that accepts high-level application code written in an XML programming language as input. Functionality is provided to interpret or translate the application code written in an XML programming language into code that is suitable for execution across computer platforms. Moreover, the XML virtual machine supports the Model View Controller (MVC) design paradigm that facilitates true data abstraction from applications to a common data model. Multi-instance applications, with each instance potentially supporting multiple views, may be created and executed. | 07-02-2009 |
| 20090193444 | TECHNIQUES FOR CREATING AND MANAGING EXTENSIONS - Various technologies and techniques are disclosed for creating and managing extensions. An extension manager is operable to interact with and manage extensions in at least two categories, such as operative extensions and cooperative extensions. The extension manager loads zero or more extensions from a first set of extensions into a host application. The extension manager loads zero or more extensions from a second set of extensions into the host application based upon an analysis of one or more declarations of compatibility. An extension manager framework is described that has a language syntax for describing the operation of extensions. The language syntax enables a cooperative extension to declare compatibility with operative extensions, so that the cooperative extension is only loaded into a host application in situations where the cooperative extension has been pre-defined as being compatible. A process for loading extensions in a host application using declarations of compatibility is described. | 07-30-2009 |
| 20090210890 | REAL-TIME DATA COLLECTION VIA HIERARCHICAL WEB PAGE PARSING - Methods and systems for instrumenting a web page to collect information on user actions associated with the web page and any of the elements contained therein are provided. For an element contained in the web page for which user actions are to be instrumented, include a single piece of instrumentation code in the source code of the web page, such that the piece of instrumentation code references the element with a unique element ID. Upon execution of the piece of instrumentation code, a hierarchical data structure representing the web page and the elements contained therein is parsed to determine any additional element(s) contained in the element. Information on one or more user actions associated with the element and the additional element(s) contained therein are transmitted. The piece of instrumentation code may invoke one or more library functions to perform various operations related to the collection of user action information. | 08-20-2009 |
| 20090249373 | METHOD FOR PROGRAM PROTECTION BASED ON .NET CARD AND A SYSTEM THEREOF - A method and system for program protection based on a .NET card. The method includes compiling, by a first device, first source code into a first assembly, and storing the first assembly to a .NET card. Information of a remotely invoked class in the first source code is extracted to form a new class. A remote invocation instruction is written in the new class to generate second source code. The second source code is compiled into a second assembly, and the .NET card and the second assembly are provided to a second device. The second device executes the second assembly, remotely invoking the class in the first source code, executing the class at the .NET card via an interface of the .NET card, and receiving an execution result returned by the .NET card. The system includes a .NET card, a first device and a second device. | 10-01-2009 |
| 20090260024 | Process Information Management System - An information management system is provided. The information management system includes a common process portal, which may, in one example architecture, be provided as a web-based application. The portal includes a variety of modules to enable housing of information such as process documentation. The portal also provides for the seamless and automatic referencing of the information and exporting of information to one or more additional applications using the information. One or more reference identifiers may be used to automatically link a data element to one or more pre-determined, selectable modules of the common process portal. | 10-15-2009 |
| 20090265724 | SYSTEM ELIMINATING HARDWARE DUPLICATION DURING APPLICATION TESTING OF AN INTERNAL STORAGE ARRAY ACROSS DIFFERENT OPERATING SYSTEMS - A method for capturing data comprising the steps of (A) handling a call for a first operating system at a storage library, (B) routing the call from the storage library to a controller firmware, (C) sending a response to the call from the controller firmware to the storage library, and (D) storing the response in a data store box for later use by the storage library. | 10-22-2009 |
| 20100031276 | Method for Constructing Virtual Operating System - The present invention provides a method for constructing a virtual operating system (VOS), the method comprises according to executable code of an application program loaded in user-mode memory space, acquiring library invoking information of an operating system (OS) library to be invoked for executing the application program; according to the library invoking information, modifying an access path of the OS library to be invoked by the application program so as to make the application program invoke the VOS instead; and a VOS loader loading program code corresponding to the VOS into user-mode memory space. When a computer run in user mode, the VOS serves as a general library, and application programs will not invoke the OS interface directly, but invoke the VOS instead, which does not need to run in kernel mode and has a wide range of applications, high stability, and security. Furthermore, the present invention is flexible to construct different VOSs for applications in different virtual environments according to requirements. | 02-04-2010 |
| 20100077411 | ROUTING FUNCTION CALLS TO SPECIFIC-FUNCTION DYNAMIC LINK LIBRARIES IN A GENERAL-FUNCTION ENVIRONMENT - A method and system for routing a function call to a core dynamic link library (DLL) via a pass-through DLL. An indication that an application requires a specific functionality is received. Using the indication, an initialization function internal to the pass-through DLL identifies a core DLL as providing the specific functionality. The core DLL is loaded into a memory. The pass-through DLL calls an internal processing initialization function included in the core DLL. The pass-through DLL receives and stores an address of a list of pointers that reference a set of functions included in the core DLL. The pass-through DLL receives a function call to a first function in the set of functions. The pass-through DLL calls the first function by utilizing the address of the list of pointers to identify a pointer that references the first function in the set of functions. | 03-25-2010 |
| 20100192167 | GRAPHICAL USER INTERFACE GENERATION THROUGH USE OF A BINARY FILE - A system for generating and displaying a graphical user interface on a computer screen is described herein. The system includes a receiver component that receives a binary formatted file and a virtual machine that generates a graphical user interface based at least in part upon the binary formatted file. A display component causes the graphical user interface to be displayed on the computer screen. | 07-29-2010 |
| 20100205619 | ENVIRONMENT MODIFICATION IN A HYBRID NODE COMPUTING ENVIRONMENT - Embodiments of the invention provide techniques that improve resource management on a massively parallel computing system having a plurality of hybrid compute nodes. For example, a job scheduler may be provided which determines a library to link to an application based on system and user requirements. In one embodiment, the libraries may provide optimizations for job execution time, and also provide optimizations directed towards a specific processor architecture. Once the library is determined, the job scheduler may configure the environment of the application so that the application links with the optimized library during run-time. Doing so may improve overall system performance of the massively parallel computing system. | 08-12-2010 |
| 20100218202 | Method and Apparatus for Case-Based Service Composition - An apparatus for creating composite services includes a processing unit which identifies at least one constituent component for a composite service by a processor unit. The constituent component has a runtime state. The apparatus includes a data-store having past composition decisions and corresponding runtime states. The processing unit locates a past composition decision regarding the constituent component that has essentially the equivalent runtime state in the data-store, and reuses the past composition decision for the constituent component for the composite service. A method for creating composite services includes the steps of identifying at least one constituent component for a composite service by a processor unit, the constituent component having a runtime state. There is the step of locating a past composition decision regarding the constituent component that has essentially the equivalent runtime state in a data-store by the processing unit. There is the step of reusing the past composition decision for the constituent component for the composite service by the processor unit. | 08-26-2010 |
| 20100275222 | Networked spreadsheet template designer - A networked spreadsheet template designer allows administrators to easily create and deploy robust reporting and input applications that leverage existing spreadsheet templates and knowledge in an easy to use user interface. Templates are created to operate directly in the particular spreadsheet program environment, such as Microsoft Excel®, and can be created using existing templates and modeling workbooks of that spreadsheet program without the need for any code to be written. A library of dynamic link library (DLL) worksheet functions makes creation of templates a faster, simpler task. The template designer uses these DLL worksheet functions directly on template worksheets to perform specified actions. The DLL functions enable a user to create an interactive, custom application by automating/encapsulating complex tasks. The DLL functions are managed across a computer network through an administrator interface to create the functions and a viewer interface that combines an Explorer® window to select the functions and a spreadsheet window for the actual spreadsheet program that implements the DLL functions. | 10-28-2010 |
| 20110078710 | Value container propagation in development tools, business process management, and business rules management solutions - Systems and methods consistent with the invention include propagating parameter definitions between computer elements and may include at least one memory device containing computer readable instructions. Also included is a computer processor executing the instructions on the memory device to perform the steps of selecting a sub-routine to be called by a calling unit. The processor may determine whether a definition for a parameter in the selected sub-routine is known to the calling unit using the computer processor, the calling unit also containing a definition for a parameter. The definitions for the parameters that are unknown to the calling unit are incorporated into the selected sub-routine using the computer processor. The process of the calling unit is executed. The computer processor is used to bind the definition for the parameter in the sub-routine to the definition of the parameter contained in the calling unit. | 03-31-2011 |
| 20110179430 | Computer System and Method for Preventing Dynamic-Link Library Injection Attack - A computer system and method for preventing a Dynamic-Link Library (DLL) injection attack are provided. The computer system monitors an operation where a process attempts to dynamically link an executable code library to another process, and intercepts the dynamic link of the executable code library. | 07-21-2011 |
| 20110289520 | METHOD AND APPARATUS FOR INTEGRATING APPLICATIONS ON DEMAND TO DISPLAY AND MANIPULATE A SEMANTIC RESOURCE - An approach is provided for integrating applications on demand to display and manipulate a semantic resource. An integrating application causes, at least in part, reception of a request for a semantic resource, and determines whether the semantic resource is known to a first application. The integrating application discovers one or more properties of the semantic resource based, at least in part, on the determination. The integrating application identifies a second application associated with the semantic resource based, at least in part, on the one or more properties. The integrating application causes, at least in part, presentation of the semantic resource through the second application. | 11-24-2011 |
| 20120066699 | DYNAMIC NATIVE BINDING FOR MANAGED ASSEMBLIES - A method, apparatus, system, article of manufacture, and computer readable storage medium provides the ability to dynamically bind a native assembly from a managed assembly. A managed assembly (e.g., a dynamically linked library (DLL)) is obtained. In the managed assembly, native application program interface entry points are identified. For each of the entry points, intended platform(s) and associated correct native assembly(ies) are specified in the managed assembly. The managed assembly is deployed onto a computer. For example, the single collection of managed and native assemblies can be deployed to all targeted computers, which consist of varying platform environments. During runtime execution, the executing platform of the application is determined. Based on the executing platform, an intended platform is selected and the entry points are bound to the correct native assembly. | 03-15-2012 |
| 20120084799 | SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR TERMINATING A HIDDEN KERNEL PROCESS - A system, method, and computer program product are provided for terminating a hidden kernel process. In use, a hidden kernel process structure associated with a hidden kernel process is identified. In addition, the hidden kernel process structure is inserted into an active process list. Further, the hidden kernel process is terminated. | 04-05-2012 |
| 20120174124 | DYNAMIC SOFTWARE VERSION SELECTION - Dynamic software version selection is performed by associating a binding library with a software component. The binding library comprises a loader component and a binding component, wherein the loader component serves as an intermediary between the software component and the binding component, and the binding component comprises software component-side logic. Dynamic software version selection further comprises logic in the loader component that decides to load a library from the binding component into memory of a processing device, and selecting by the loader component, a desired version of the requested library, where the desired version of the library is selected from at least two versions of the library associated with the binding component of the binding library. Still further, dynamic software version selection comprises loading the desired version of the library into memory of a computer processing system without requiring that the associated software component restart. | 07-05-2012 |
| 20120216219 | METHODS AND APPARATUS FOR DYNAMIC CUSTOMIZATION OF CLINICAL WORKFLOWS - Methods and apparatus for dynamic customization of clinical workflows are disclosed. An example method includes receiving a script that implements one or more actions of a clinical workflow from a first healthcare entity that utilizes an electronic clinical information system, wherein the electronic clinical information system aggregates healthcare information from a plurality of healthcare entities including the first healthcare entity; loading the script into a dynamic module core framework that interacts with a runtime environment to execute application bundles; and publishing the script of the dynamic module core framework to the runtime environment such that the clinical workflow is installed into the electronic clinical information system dynamically at runtime. | 08-23-2012 |
| 20120227061 | APPLICATION COMPATIBILITY WITH LIBRARY OPERATING SYSTEMS - Application compatibility is facilitated by use of library operating systems. Library operating systems can encapsulate portions of an application likely to break application compatibility. An application can be bound to a compatible library operating system that operates over a host operating system. Furthermore, library operating system version can be greater than, equal, or less than the version of the host operating system. Consequently, both backward and forward compatibility is enabled. | 09-06-2012 |
| 20120324484 | Dynamic Loading of Kernel Extensions - An approach is provided in preparing a dynamically loaded kernel extension. The approach includes compiling a kernel extension program that includes a symbol, such as a function. The symbol is exported from the kernel extension program and a symbol broker that references the exported symbol is compiled. A kernel extension loader library is created with a defined callable symbol that corresponds to the exported symbol. The kernel extension loader library is linked by an external program after compilation of the external program resulting in a compiled external program. The kernel extension loader library dynamically loads the compiled kernel extension program, the compiled symbol broker, and the exported symbol when the defined callable symbol is referenced by during execution of the compiled external program. | 12-20-2012 |
| 20120331488 | COMPONENT NAVIGATION IN AN EXTENSIBLE APPLICATION - In one embodiment, a method receives configuration information for a set of components of an extensible application. A component in the set of components includes extending information if the component is an extension of another component and hosting information if the component is hosting a set of extension points. A computing device dynamically generates an extension structure at runtime of the application from the configuration information. The extension structure is generated by connecting components together based on the extending information and the hosting information of the set of components. A navigation request to a target component is received and a path of components to the target component is determined using the extension structure. The path of components is traversed until the target component is loaded and the target component is displayed. | 12-27-2012 |
| 20120331489 | BYPASSING USER MODE REDIRECTION - In one embodiment, a non-transitory processor-readable medium stores code associated with a function module included in a resource library. The code can represent instructions that when executed cause a processor to define, in response to a function hook associated with the function module, a copy of the resource library, the copy of the resource library including an unhooked copy of the function module. The code can further represent instructions that when executed cause the processor to execute the unhooked copy of the function module based on at least one policy from a plurality of policies. | 12-27-2012 |
| 20130042260 | Distributed Pluggable Middleware Services - Plug-in configurable middleware for managing distributed applications includes at least one core runtime engine configured as a plurality of concurrent instantiations on one or more hosts within a distributed architecture. These hosts can represent separate nodes or a single node within the architecture. Each core runtime engine instance provides the minimum amount of functionality required to support plug-in architecture, that is to support the instantiation of one or more plug-ins within that core runtime engine instance. Each core runtime engine instance is in communication with other concurrent core runtime engine instances and can share the functionality of plug-in instances with the other core runtime engine instances, for example through the use of proxies. A plurality of personalities representing pre-defined functions is defined and one of more of these personalities is associated with each core runtime engine instance. A plurality of pre-defined plug-ins are defined and associated with the personalities. | 02-14-2013 |
| 20130055296 | DYNAMICALLY BINDING DATA IN AN APPLICATION - A method for binding data in an application. An expression is created via a framework based on input from a developer. The expression is received at an expression engine wherein the expression describes a relation between a first property of a first data of the application to a first property of a second data of the application. A binding is created between the first data and the second data based on the relation via the expression engine. The first property of the second data is changed based on a change to the first property of the first data wherein the changing occurs because of the binding. The receiving the expression, the creating the binding, and the changing the first property are orchestrated via the framework to manage when the expression is executed in the application. | 02-28-2013 |
| 20130145382 | COMPUTING DEVICE AND FUNCTION MODULE MANAGEMENT METHOD - A method for managing function modules using a computing device. The computing device loads the function modules according to a serial number corresponding to a filename and a directory path of each function module. The computing device obtains register commands from an interface of each function module and saves the register commands into a command library. The computing device searches for a register command in the command library when the register command is inputted by an input device connected to the computing device, and executes the searched register command of the function module. | 06-06-2013 |
| 20130174182 | Optimized Delivery of Web Application Code - Application code for deployment to a client over a data link is optimized to minimize download time by supplying only the application code with a particular object that is required by the object. In a web application that includes multiple pages, the HTML and JAVASCRIPT are scanned to identify code resources called by a particular web page. When all called resources are identified, they are extracted and concatenated into a single resource file. When the page is downloaded to the client, the import file is included with the page. The import file may be cached so that it need only be downloaded once, rather than being downloaded every time the page is requested. The invention is suitable for use with other interpreted scripting languages. | 07-04-2013 |
| 20130174183 | Optimized Delivery of Web Application Code - Application code for deployment to a client over a data link is optimized to minimize download time by supplying only the application code with a particular object that is required by the object. In a web application that includes multiple pages, the HTML and JAVASCRIPT are scanned to identify code resources called by a particular web page. When all called resources are identified, they are extracted and concatenated into a single resource file. When the page is downloaded to the client, the import file is included with the page. The import file may be cached so that it need only be downloaded once, rather than being downloaded every time the page is requested. The invention is suitable for use with other interpreted scripting languages. | 07-04-2013 |
| 20130290987 | TYPE INFERENCE AND TYPE-DIRECTED LATE BINDING - Systems and methods that enhance and balance a late binding and an early binding in a programming language, via supplying an option component to opt-in (or opt-out) late binding, and wherein a late binding is triggered based on a static type for the variable (e.g., object or a type/string.) Additionally, the variable is enabled to have different static types at different regions (e.g., a program fragment) of the programming language. | 10-31-2013 |
| 20130332943 | METHOD AND DEVICE FOR PUBLISHING AND IMPLEMENTING WIRELESS APPLICATION - Embodiments of the present application relate to a method of publishing a wireless application, a method of implementing a wireless application, a device for publishing a wireless application, a device for implementing a wireless application, and a computer program product for publishing a wireless application. A method of publishing a wireless application is provided. The method includes integrating a permanent interface layer of a software development kit (SDK) into a wireless application, publishing the integrated wireless application, and installing the dynamic implementation layer of the SDK onto a server. The SDK includes the permanent interface layer and a dynamic implementation layer, the permanent interface layer including an interface protocol to be invoked by the wireless application and the dynamic implementation layer including an interface implementation corresponding to the interface protocol. | 12-12-2013 |
| 20130347011 | INSTALLER AND METHOD FOR ADDING AN ANDROID PLATFORM DYNAMIC LIBRARY - An installer for adding an Android platform dynamic library comprises a unit for generating an external directory which generates an external directory for storing a library, a unit for generating library information which generates library information including at least one of library name information and library location information, and a control unit which stores the library in the external directory and stores the generated library information in an external library management directory. | 12-26-2013 |
| 20140007142 | HANDLING DYNAMICALLY LINKED FUNCTION CALLS WITH RESPECT TO PROGRAM CODE CONVERSION | 01-02-2014 |
| 20140047461 | COMPUTING DEVICE HAVING A DLL INJECTION FUNCTION, AND DLL INJECTION METHOD - Provided are a computing device provided with a DLL injection function and a DLL injection method. When receiving from an operating system notification of whether a target process corresponding to a program ordered by a user to be executed is created, a process creation module of an injection program executes a launcher process to create the target process as a child process of the launcher process and sets the target process to a suspend mode. A code insertion module receives allocation of a memory region where the target process is stacked, using a process handle of the target process, to insert a code for executing a DLL file to be injected into the target process. A restoration module cancels the suspend mode of the target process to allow the target process to be executed. According to the present invention, it is possible to stably perform DLL injection without confliction with another DLL injection technique by inserting a DLL executable code into the memory region of the target process which is created in the suspend mode. | 02-13-2014 |
| 20140059573 | METHOD AND SYSTEM FOR IDENTIFYING AND REPLACING SYSTEM CALLS - One embodiment of the system disclosed herein facilitates identifying a system call in an application and replacing the identified system call with a customized function call. During operation, the system executes an executable file of the application, wherein the executable file has been modified to execute a hooking and injection manager at run time. Prior to executing the system call, the system executes the hooking and injection manager. While executing the hooking and injection manager, the system determines, from a symbol table, a symbol table index value corresponding to a symbol associated with the system call. The system further determines an import table entry storing a pointer to the system call based on the symbol table index value, and changes the pointer in the import table entry so that the pointer indicates an address of the customized function call. | 02-27-2014 |
| 20140082641 | Enhanced Hook Function for Use with Different Versions of a Dynamically Loaded Library - A hooking system for hooking predetermined references to predetermined dynamically loaded library (DLL) functions includes a DLL version identifier provided by a hook entry code to an enhanced hook. The hook entry code is dynamically generated during runtime of an affected software application. The version identifier enables unambiguous communication of a single enhanced hook with functions of multiple versions of identically named DLLs loaded into the same isolated process memory area. | 03-20-2014 |
| 20140101677 | OPTIMIZING SUBROUTINE CALLS BASED ON ARCHITECTURE LEVEL OF CALLED SUBROUTINE - A technique is provided for generating stubs. A processing circuit receives a call to a called function. The processing circuit retrieves a called function property of the called function. The processing circuit generates a stub for the called function based on the called function property. | 04-10-2014 |
| 20140157291 | METHOD AND SYSTEM FOR BINDING OBJECTS IN DYNAMIC PROGRAMMING LANGUAGES USING CACHING TECHNIQUES - Disclosed are a method and system for binding a program object in a source code to one of a number of implementations of the program object, using caching techniques. Binding a program object to a particular implementation includes performing the binding process at compile time and runtime of the source code. During compilation phase, the program objects in the source code are identified, and each of the program objects is assigned a slot in a target cache. The slot is configured to store a pointer that points to a particular implementation of a program object to which the slot is assigned. During execution phase, the particular implementation of the program object is determined based on execution flow of the source code. After the particular implementation is determined, the program object is bound to the particular implementation by updating the assigned target cache slot with a pointer pointing to the particular implementation. | 06-05-2014 |
| 20140181846 | COMPUTING DEVICE AND WEB SYSTEM MANAGEMENT METHOD - A method manages a web system having a plurality of sub-systems using a computing device. A web project is created for the web system and is stored in a storage of the computing device. Each of the sub-systems has a directory created under the web project. Programs of each sub-system are compiled to generate a dynamic link library (DLL) document of each sub-system. The DLL document of each sub-system is written into a corresponding directory under the web project. | 06-26-2014 |
| 20140282630 | BACKEND CUSTOM CODE EXTENSIBILITY - Techniques are described herein that are capable of providing backend custom code extensibility. Such extensibility allows custom code to be automatically loaded dynamically (e.g., on-demand) in a runtime that is hosted by a backend-as-a-service (BaaS) module while the runtime is running to provide custom backend features that are defined by the custom code to an application in response to receipt of a request from the application. | 09-18-2014 |
| 20140304720 | METHOD FOR STARTING PROCESS OF APPLICATION AND COMPUTER SYSTEM - A method and a computer system are provided for starting a process of an application. When starting the application, the computer system may load a second dll file by default. However, in instances when a first dynamic link library file is to be injected into the process, a driving module adds information about the first dynamic link library file into an import table of the second dynamic link library file. The second dynamic link library file that includes the import table with the added information of the first dynamic link library is loaded into memory. In this manner, the default-loading mechanism of the system is bypassed, and the first dll file is injected by modifying the import table of the second dll file before it is loaded into memory. Therefore, it is not required to load the first dll file while executing the process of the application. | 10-09-2014 |
| 20140373035 | DYNAMICALLY BINDING DATA IN AN APPLICATION - A computer-usable storage medium having instructions embodied therein that when executed cause a computer system to perform a method for binding data in an application. An expression is created via a framework based on input from a developer. The expression is received at an expression engine wherein the expression describes a relation between a first property of a first data of the application to a first property of a second data of the application. A binding is created between the first data and the second data based on the relation via the expression engine. The first property of the second data is changed based on a change to the first property of the first data wherein the changing occurs because of the binding. The receiving the expression, the creating the binding, and the changing the first property are orchestrated via the framework to manage when the expression is executed in the application. | 12-18-2014 |
| 20150143387 | DYNAMIC LINKING AND LOADING OF POST-PROCESSING KERNELS - A computer system may generate a plurality of component kernels, which are to be linked during the runtime. The system may determine whether a combined kernel K is present in response to receiving a first request to retrieve the combined kernel K. The system may compose the combined kernel K from the selected component kernels of the plurality of component kernels during the runtime if the combined kernel is not already present. | 05-21-2015 |
| 20150309811 | Modifying an Application for Managed Execution - Methods and systems for configuring mobile applications for managed execution are described herein. Executable application binaries may each be converted into a corresponding dynamic library. The dynamic libraries may be bundled with a managing application that is configured to manage execution of the dynamic libraries at a mobile computing device. Resource files consumed by the application binary may also be bundled with the managing application and accessible to the dynamic libraries during execution. The managing application may provide a workspace within which operation of the dynamic library occurs. Operation of the dynamic library may at least partially correspond to operation of the executable application binary. Execution of the dynamic library may be bound to a process that is executed for the managing application at a processor of a computing device. | 10-29-2015 |
| 20160019071 | ACCURATE STATIC DEPENDENCY ANALYSIS VIA EXECUTION-CONTEXT TYPE PREDICTION - Exemplary embodiments provide methods, mediums, and systems for generating a runtime environment that is customized to a particular computer program, particularly in terms of the function definitions that support function calls made in the computer program. The customized runtime environment may therefore be smaller in size than a conventional runtime environment. To create such a customized runtime environment, an analyzer may be provided which monitors test executions of the computer program and/or performs a structural analysis of the source code of the computer program. The analyzer may determine a list of probabilistically or deterministically required function definitions, and provide the list to a component reducer. The component reducer may eliminate any function definitions not deemed to be required from a runtime environment, thereby producing a customized runtime environment that is built to support a particular computer program. | 01-21-2016 |
| 20160019072 | DYNAMIC DETERMINATION OF APPLICATION SERVER RUNTIME CLASSLOADING - Embodiments of the present invention provide a method, system and computer program product for dynamic selection of a runtime classloader for a generated class file. In an embodiment of the invention, a method for dynamic selection of a runtime classloader for a generated class file is provided. The method includes extracting meta-data from a program object directed for execution in an application server and determining from the meta-data a container identity for a container in which the program object had been compiled. The method also includes selecting a container according to the meta-data. Finally, the method includes classloading the program object in the selected container. | 01-21-2016 |
| 20160026496 | METHOD AND SYSTEM FOR PROFILING VIRTUAL APPLICATION RESOURCE UTILIZATION PATTERNS - A method and system for profiling execution of an application implemented by an application file comprising a plurality of data blocks. The application is executed in response to an execute command from a management process. Read messages are sent to the management process each time the application reads one or more of the plurality of data blocks of the application file. The management process records information about the read operations in one or more transcripts which may be used to create a streaming model for the application allowing the application to be downloaded using a conventional download protocol without using a specialized streaming protocol. | 01-28-2016 |
| 20160062776 | EXECUTING GRAPH-BASED PROGRAM SPECIFICATIONS - A graph-based program specification includes components corresponding to tasks and directed links between ports of the components, including: a first type of link configuration defined by respective output and input ports of linked components, and a second type of link configuration defined by respective output and input ports of linked components. A compiler recognizes different types of link configurations and provides in a target program specification occurrences of a target primitive for executing a function for each occurrence of a data element flowing over a link of the second type. A computing node initiates execution of the target program specification, and determines at runtime, for components associated with the occurrences of the target primitive, an order in which instances of tasks corresponding to the components are to be invoked, and/or a computing node on which instances of tasks corresponding to the components are to be executed. | 03-03-2016 |
| 20160092246 | REVERSE DEPENDENCY INJECTION IN A SYSTEM WITH DYNAMIC CODE LOADING - Embodiments are directed to utilizing reverse dependency injection for managing bootstrapping of applications in web browser and mobile environments. By using reverse dependency injection, embodiments enable a component to declare that it is a “dependency of” another component in a visual analyzer application. This ensures that the dependencies are loaded before the other component is loaded, thereby minimizing delays when a user starts up an application. In some embodiments, information identifying a plugin to be loaded can be received. Embodiments can determine configuration information for the plugin where the configuration information includes both forward and reverse dependencies. Embodiments may generate, based on the configuration information, a data structure that represents the forward and reverse dependencies. Embodiments may analyze the data structure to determine an ordered list of loadings. Some embodiments may load the individual components per the ordered list of loadings and indicate that the plugin is ready for execution. | 03-31-2016 |
| 20160132343 | INFORMATION PROCESSING DEVICE, LIBRARY LOADING METHOD, AND COMPUTER READABLE MEDIUM - Provided is an information processing device and others in which a plurality of applications are capable of appropriately using a plurality of libraries requested to be loaded with an identical name and including different contents. The information processing device includes an identifier generation unit which generates identifier information used for identifying contents of a library file, generates load request association information representing a relationship between the identifier information and request target information; a load request interpretation unit which obtains identifier information about the library file including a target of a load request; and a load unit which loads at least a part corresponding to the target of the load request from the library file indicated by the obtained identifier information when the load unit determines that the part corresponding to the target of the load request is not loaded. | 05-12-2016 |
| 20170235619 | SYSTEMS AND METHODS FOR ENABLING DYNAMIC CALLS VIA FILTERING, GROUPING, AND SUBSTITUTION MECHANISMS | 08-17-2017 |
| 20220137987 | UPDATED SHARED LIBRARY RELOADING WITHOUT STOPPING THE EXECUTION OF AN APPLICATION - Techniques include executing a software program having a function call to a shared library and reloading the shared library without stopping execution of the software program. A global offset table (GOT) is updated responsive to resolving a link address associated with the function call. An entry in GOT included a link address field, an index field, and a resolved field, the updating including updating the index field with an affirmative value and marking the resolved field with an affirmative flag for the entry in the GOT. Responsive to reloading the shared library, the entry in the GOT is found having the affirmative value in the index field and the affirmative flag in the resolved field. An address value in the link address field is returned for the entry having the affirmative value in the index field, responsive to a subsequent execution of the function call to the shared library. | 05-05-2022 |
| 719332000 | Object oriented dynamic linking, late binding | 12 |
| 20080209453 | System and Method for Reducing the Start-up Time of Mhp Applications - A system and method is provided for reducing the start-up time of MHP applications based on the MHP 1.0.x standard through exploiting the custom Classloader and persistent storage capabilities of MHP 1.0.x. A generic wrapper class is created that allows any MHP 1.0.x application to copy itself to, and run itself from, persistent storage thereby reducing the startup time. The generic wrapper class utilizes two pre-existing APIs in the MHP protocol, a DVBClassloader API and a persistent storage API. | 08-28-2008 |
| 20080216102 | CROSS APPLICATION DOMAIN LATE BINDING TO NON-LOCAL TYPES - A system allows a non-virtual method of a base class inherited by a derived class to be effectively overridden so that code developed to access the method via the base class accesses the overriding behavior. The system replaces an instance of the derived class with a dynamic object and transparent object with the transparent object appearing to provide to invoking code an implementation of the derived class. Upon receiving an invocation of a method, the transparent proxy directs the invocation to the dynamic object by invoking an invoke method of the dynamic object passing an indication of the invoked method of the transparent object. The dynamic object may be an instance of a dynamic class that inherits a real class with a virtual invoke method. The dynamic class overrides the invoke method to provide overriding behavior. | 09-04-2008 |
| 20080320503 | URL Namespace to Support Multiple-Protocol Processing within Worker Processes - A server system in typical operation has a process manager, multiple listeners (each to receive requests for its protocols) and multiple worker processes that are each able to handle requests in multiple protocols. At server start-up, each listener connects with the process manager via a pipe published by the process manager. The listener then receives information via the process manager that includes information defining the application(s) for which that listener is to “listen” and associating application(s) to application pool(s). When the listener receives a request for such an application, the listener starts a queue for the associated application pool. The listener may use a hierarchical matching scheme to determine the associated application or application pool from the requested application. The process manager launches an appropriate worker process to handle requests in the listener's protocol. The worker process then makes a connection with the listener. | 12-25-2008 |
| 20090070792 | SYSTEM AND METHOD FOR THE SERVICE CONFIGURATION OF APPLICATION SERVER ENVIRONMENTS - A system and method for dynamic, application dependency implicit, service configuration of application server environments. A dynamic and implicit mechanism can be provided using technologies such as OSGi and the Java Module System, that then reduce the need for external application server configuration. An application server so implemented can be enabled to dynamically/lazily load the required services implementations on demand, at the time an application is deployed and/or initialized at runtime, and to subsequently release any such resources consumed when they are no longer required. | 03-12-2009 |
| 20090193445 | METHOD AND SYSTEM FOR PROVIDING SUPPORT FOR SOFTWARE APPLICATIONS - A method and system for providing support for a Java™ based software application in a communication system. The communication system includes a support server communicating with an application server. The Java™ based software application has a plurality of instances installed on the application server. The method includes receiving a first attribute-list corresponding to an instance of the Java™ based software application from the application server based on an operating environment of the instance. The method further includes comparing a second attribute-list stored on the support server with the first attribute-list. Thereafter, based on the comparison, a diagnostic report for the instance of the Java™ based software application is displayed. | 07-30-2009 |
| 20090249374 | DYNAMIC TEMPLATE INSTANTIATION - Method, system, and computer program product for instantiating a template in a composite application infrastructure. A template that describes a composite application having a plurality of application components is created. The template includes a composite application component assembly descriptor which lists each application component of the composite application. The template is stored in a template library. The composite application is instantiated using the template for creating at least one composite application instance. In an application instance registry, composite application instance(s) and instance information related to the composite application instance(s) is/are registered. The composite application instances are transiently represented in the application instance registry by a respective table entry without creating a real object. The real object that is dynamically created represents a particular composite application instance during a composite application usage session. At an end of the composite application usage session, the particular unused composite application instance is removed. | 10-01-2009 |
| 20090276795 | VIRTUAL AUTOMATA - Computer-based machines can be modeled after a virtual automaton. The virtual automaton defines processes that are not bound statically to particular behavior but rather perform a lookup at runtime to bind behavior to a specific process mechanism. In accordance with one aspect, binding can be dependent upon runtime context information such as object type. Instances of virtual automaton are provided in the context of graph processing including serialization of object graphs and scanning/parsing, among others. | 11-05-2009 |
| 20100023955 | METHOD AND SYSTEM AND APPARATUS FOR DYNAMIC SOFTWARE ENVIRONMENT - A method and system are provided for runtime dynamic binding. The system includes a processor for executing computer-readable instructions. The system includes a computer-readable medium for storing an object definition in communications with the processor. The system includes a user object instantiated from the object definition, the object definition including a programmer-defined lookup method and a programmer-defined binding method. The programmer-defined lookup method dynamically searches and retrieves a requested functionality. The programmer-defined binding method dynamically binds the requested functionality at runtime for execution without a system restart. | 01-28-2010 |
| 20100162277 | APPARATUS AND METHOD FOR EXECUTING ROBOT APPLICATION PROGRAM - An apparatus for executing a robot application program includes a robot application execution device to which an operating system supporting a dynamic library to execute the robot application program is mounted; a robot device unit having various sensors and effectors; a plug-in storage for storing therein plug-ins forming the dynamic library; and a robot application program storage for storing therein the robot application program. Each plug-in is a dynamically loadable file implementing functions of the robot application program by modules. | 06-24-2010 |
| 20120124597 | METHOD AND SYSTEM FOR VIRTUALIZING CONNECTION END-POINTS IN DISTRIBUTED, COMPONENT BASED APPLICATIONS AT RUNTIME - A method, system and computer program product of setting up a virtual connection at run time. The method includes the steps of: analyzing a topology of an application to determine at least one port pair where the port pair comprises an output port of a first operator and an input port of a second operator; configuring a first auxiliary operator to receive data from a first operator; configuring a second auxiliary operator to send data to a second operator; deploying the first operator, the second operator, the first auxiliary operator and the second auxiliary operator; receiving a function address of the second auxiliary operator; and sending the function address of the second auxiliary operator to a first destination; where at least one of the steps is carried out using a computer device so that the virtual connection is setup at run time. | 05-17-2012 |
| 20120185881 | Debugging Support For Core Virtual Machine Server - A method and apparatus of a device that adds debugging support for compiling applications in memory using a core virtual machine server is described. In an exemplary method, the device receives source code for an executable. The device generates an internal representation of the source code and generates an object file in the memory of the device from the internal representation. The device links the object file to resolve one or more external symbols in the object file without storing the executable in a filesystem of the device. | 07-19-2012 |
| 20140089949 | DYNAMICALLY BUILDING SUBSECTIONS OF LOCALE OBJECTS AT RUN-TIME - Subsections of locale objects are dynamically built from locale source files when requested at run-time without building all subsections of the locale object. When a subsection of a locale object is dynamically built, the subsection is stored in global memory so it may be read by multiple applications. Dynamically building subsections of locale objects when requested allows software to operate with a relatively small number of locale objects instead of with hundreds or thousands of locale objects, as is known in the art, and requires fewer system resources because only the requested subsection of the locale object is built when it is requested. The result is significant savings in system-wide resources while still allowing for access to a large number of possible locales. | 03-27-2014 |
