You can build a .lib library file from the assembly code file given earlier. By the current configuration, you already have a .obj file in the project folder. You have noted that the PUBLIC directive was used in the assembly code to expose function parameters to the global namespace. You have also noted that the EXTERN directive is to be used in the calling program, here, in the C language source code. A library file is a binary format that encapsulates an assembly code-assembled object file and builds a unit that can be reused and shared in other projects as and when needed with minimal recoding. If regular assembly programming is to be done, then the library .lib files are of immense value.

This is known as static linking wherein the function code is extracted from the library module and compiled in the main binary as part of the final executable. The other method is dynamic linking where the dynamic link library is dynamically linked and the import tables and export tables are filled by the loader during runtime process mapping with the addresses of the library functions. These jump thunk tables are then used by the code during runtime to access the invoked function entry points. For most functions that return a value, EAX is the register. By convention, the return values are fed back after function exit.

To build a library file from the object file, you have to invoke LIB.exe from Visual Studio Command. If not already present, you can use ml.exe /c /Cx /Coff <.asm file> to generate the object file for that particular assembly source only. Go to the prompt and type LIB <objectfile.obj> to generate the library file from the object file.

Thereafter, you have to include this library in your VC++ project. To do so, you have to right-click on the project name and open Properties, navigate to Linker | Additional Dependencies, and type "$(InputDir)SpaceCounter.lib".

Remember to enter the line with quotation marks so that VC++ does not complain about not finding the lib file. Use the name of the lib file that you have named:

In the new source text, include the preceding extern "C" statement as described and press F5 to compile, link, and run the new project.

In Visual Studio Command Prompt, you can type dumpbin /all SpaceCounter.lib to familiarize yourself with the binary format and attributes of particular interest (as mentioned in the following excerpt). You first have to set the current path to the path of the library file; else, you have to feed the full path (~ shortening of paths also works in Windows). Study the output; notice how the public symbols are exposed. Also notice the binary format, which is a version of the PE/Coff (common object file format) format for Windows. You will see the various section names and their section headers. The file header looks as it should for a typical 32-bit PE binary; here, the binary has 4 sections and is x86 compatible. RAW DATA #1 is the opcode sequence for the assembly code in the hexadecimal format. .debug$S is the section name for debug symbols, with RAW DATA #4 giving the hex dump view of the debug strings.

You can download the PEView tool and open the lib file in it to see a more comprehensive and consolidated view of the entire file structure in hexadecimals, including the parsed headers.

Let us compile the project with the library file to see how the static linking takes place. Open the executable in OllyDbg. The debugging details will be covered later on, but as a starter, you can look for the following code sequence inside OllyDbg.

Right-click in the main disassembly window to get to the context menu, and choose Search For | Binary String or press Ctrl + B. In the modal dialog box, type the following in the HEX box: 55 8B EC 56 8B 75 08

You have just typed the function prologue and some more opcodes from the function. The sequence 8B 75 08 moves the first argument value, which is a pointer to a character array to ESI. The number appended to the box name is the length of the hexadecimal string in bytes. Keep the Entire block option checked.

You should be reaching an address in the binary where the statically linked function assembly code is compiled in the preceding binary. Note that the process memory addresses might be different in your system.

You can use the inline assembler along with GUI code in Visual Studio so that you get the best of both worlds and build software with user interactivity and fast optimizations for regions where you feel the assembler fits best. While the classic use of Win32 API function calls to build a Windows form or dialogs using callbacks and message queues is well documented in C/C++ programming and even x86 assembly code, it is important to understand that there are other methods that can be leveraged immediately from the current setup. This also lets you focus on the algorithms rather than spend the time writing OS-specific boilerplate code, which can be investigated later on if so required. Once you are comfortable with the foundations, you can safely pursue GDI+/DirectX/assembly 2D/3D graphics programming on your own.

In Visual C++ 2008, create a CLR-based project and choose Windows Forms Application. Give a name and click OK.

You get a plain Windows form in the designer view. Press F5 to run the application. Close the form after you verify the execution and see how the form works by default; see if the minimize, maximize, and exit buttons work as expected.

Open project properties, navigate to Configuration Properties | General, and change the Common Language Runtime Support option to Common Language Runtime /clr from /clr:pure. This will ensure that inline assembly compiles in the project. The GUI runs in a managed environment called the CLR, which is like a bytecode-based machine and executes Microsoft Intermediate Language (MSIL) pseudo code in .NET technology-based applications. This is not like the native instruction set of Intel microprocessors but a layer of abstraction above that. It eventually is Just-In-Time (JIT) compiled to native code. To ensure that your inline assembly is compiled properly, you have to place your code before all managed code in the source file.

In the designer view, press Alt + Enter to open the Properties Window (View | Other Windows | Properties Window) view. In this pane, you will see a list of attributes that you can set. Toolbox from the View menu (Ctrl + Alt + X) provides form controls that can be dragged and dropped. You can double-click the form itself to reach the event handler for the Form1_Load event.

Drag a label and a button to the form and arrange the controls as shown. Use the Properties view to change the value of the label text to Counter.

Double-click on the button to create the event handler for the button.

In the source, type the following at the top of the file or just after the #pragma directive and the namespace definition at the top of the file. Notice how these are inside regular function definitions:

#pragma once

namespace DEMOGUI {

  using namespace System;
  using namespace System::ComponentModel;
  using namespace System::Collections;
  using namespace System::Windows::Forms;
  using namespace System::Data;
  using namespace System::Drawing;

int increment (int a){
_asm {
lea eax, a
mov eax, [eax]
inc eax
mov a, eax
}
return a;
}

int compare(int b) {
  int result=0;
  _asm{
    cmp b,10
  jle ender
    mov result,1
ender:
  nop
  }
return result;
}//… skipped managed class declaration below

In the button event handler, type the following:

static int counter=0; /* initialize a static integer variable as a
counter */
private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {
  System::String^ result = counter.ToString();
  counter=increment(counter);
  label1->Text=result;
  if (compare(counter)){
    counter=0;
    MessageBox::Show("Rollover at 10");
  }

}

Press F5 to run the application, and press the button to see the counter value incrementing. At counter=10, a message box modal dialog shows the value 10. The counter is also reset to 0 on the next click.

If you use keyboard and mouse event handling in VC++ with Windows forms along with assembly code, as well as the standard C library and the C++ STL library among tons of other external libraries, you can build any application that you can think of, which has user interactivity as well as speed and an environment for rapid development.