Binary file generation

1. A system for generating a mapping binary file, comprising a processor to:

map a function call from a legacy binary file to a function call from a virtualized namespace binary file by merging an export table from the legacy binary file and an export table from the virtualized namespace binary file, the virtualized namespace binary file to load the function call based on an application programming interface name;

store the mapping of the function call from the legacy binary file to the function call from the virtualized namespace binary file in a mapping binary file;

store, in the mapping binary file, an exception detected from the merger of the export tables; store the mapping binary file in a storage location accessible by a loader; and

implement a precedential binary file ordering to indicate that a system binary file is to be loaded prior to the mapping binary file in response to detecting the precedential binary file ordering.

2. The system of claim 1 , wherein the processor is to detect a build file that enables the mapping.

3. The system of claim 1 , wherein the processor is to:

detect a second function call to be mapped from the legacy binary file to the virtualized namespace binary file;

determine that the mapping of the second function call does not exist; and

generate a substitute implementation for the second function call.

4. A method for generating a mapping binary file, comprising:

mapping a function call from a legacy binary file to a function call from a virtualized namespace binary file using a builder to detect a build file that enables the mapping, the mapping comprising merging an export table from the legacy binary file and an export table from the virtualized namespace binary file, the virtualized namespace binary file to load the function call based on an application programming interface name;

storing the mapping of the function call from the legacy binary file to the function call from the virtualized namespace binary file in a mapping binary file;

storing, in the mapping binary file, an exception detected from merging the export tables;

storing the mapping binary file in a storage location accessible by a loader; and

implementing a precedential binary file ordering to indicate that a system binary file is to be loaded prior to the mapping binary file in response to detecting the precedential binary file ordering.

5. The method of claim 4 , further comprising:

detecting a second function call to be mapped from the legacy binary file to the virtualized namespace binary file;

determining that the mapping of the second function call does not exist; and

generating a substitute implementation for the second function call.

6. One or more computer-readable storage devices for generating a mapping binary file comprising a plurality of instructions that, when executed by a processor, cause the processor to:

map a function call from a legacy binary file to a function call from a virtualized namespace binary file by merging an export table from the legacy binary file and an export table from the virtualized namespace binary file, the virtualized namespace binary file to load the function call based on an application programming interface name;

store the mapping of the function call from the legacy binary file to the function call from the virtualized namespace binary file in a mapping binary file;

store, in the mapping binary file, an exception detected from merging the export tables;

store the mapping binary file in a binary mapping directory accessible by a loader along with a registry value indicating a location of the binary mapping directory; and

implement a precedential binary file ordering indicating a system binary file is to be loaded prior to the mapping binary file in response to detecting the precedential binary file ordering.

7. A system for implementing namespace virtualization with a legacy application, comprising a processor to:

detect an import table associated with an interface contract from a plurality of import tables; and

detect that an interface contract in the legacy application is to be resolved, to select one or more dynamically linked libraries that collectively implement the interface contract based at least in part on an interface name and/or a legacy binary indicator stored in the detected import table, and to load the one or more selected dynamically linked libraries into an executable file for execution, wherein the one or more selected dynamically linked libraries are comprised of system binary files and virtualized namespace binary files, and wherein the loading comprises implementing a precedential binary file ordering indicating the system binary files are to be loaded prior to the virtualized namespace binary files in response to detecting the precedential binary file ordering, and wherein the processor is to generate one of the plurality of import tables based on a virtualized namespace, the virtualized namespace to load a function call based on an application programming interface name.

8. The system of claim 7 , the import table comprising a parameter indicating a binary interface standard.

9. The system of claim 8 , the binary interface standard being a component object model.

10. The system of claim 7 , the detected import table comprising a mapping value indicating a relationship between a legacy reference namespace and the virtual namespace.

11. The system of claim 7 , the executable file comprising a legacy reference namespace and the virtual namespace.

12. The system of claim 7 , the detected import table comprising a versioning value or a size of a descriptor structure.

13. The system of claim 7 , wherein the processor is to detect a delay load table, and to modify the delay load table to include an API set-aware value and a relative virtual address corresponding to the API interface name.

14. A method for implementing namespace virtualization with a legacy application, comprising:

detecting that an interface contract in a legacy binary file corresponding to the legacy application is to be resolved;

detecting an import table associated with the interface contract from a plurality of import tables, wherein one of the plurality of import tables is generated based on a virtualized namespace;

selecting one or more dynamically linked libraries that collectively implement the interface contract based at least in part on an interface name and/or a legacy binary indicator stored in the detected import table, the one or more dynamically linked libraries comprising system binaries and virtualized namespace binaries, the system binaries having precedence over the virtualized namespace binaries based on a precedential binary file ordering that indicates the system binaries are to be loaded prior to the virtualized namespace binaries, and wherein the virtualized namespace binaries load a function call based on an application programming interface name; and

loading a function in the interface contract from the one or more selected dynamically linked libraries, the function being loaded into an executable file for execution.

15. The method of claim 14 , the import table comprising a parameter indicating a binary interface standard.

16. The method of claim 15 , the binary interface standard being a component object model.