Creating the Fortran COM Server (Windows*)

Creating a Fortran COM Server Project using the Visual Studio* IDE:

1. Start the Visual Studio IDE. Choose File > New > Project.

2. In the New Project dialog box, expand the Intel® Visual Fortran item and click COM Server.

To create the sample project, choose In-process Server (DLL). Now do the following:

1. Enter Adder as the name of the project.

2. Accept or modify the project folder location.

3. Click OK.

You can use the project AppWizard once per project to create the project files and skeleton template. The Fortran COM Server AppWizard displays default text for the interface name and class derived type name.

Now do the following:

1. Enter class name AddingMachine.

2. Shorten the default interface name to IAdd.

3. Accept the default class derived type name.

4. Click Finish. (If you click Cancel, project creation is terminated.)

The project is created and the COM Server Hierarchy file (adder.hie) is opened in the COM Hierarchy Editor.

Using the COM Hierarchy Editor to Define your COM Server

The COM Hierarchy Editor lets you interactively define the attributes (for example, classes, interfaces, and methods) for your COM server. The user interface contains two panes:

• The top pane is a tree control that displays attribute information in a hierarchy.

• The bottom pane is a panel that displays the IDL definition for a selected element in the hierarchy.

You can use "right-click" context menus to insert, delete, and modify items in the hierarchy. Context menus also let you change item properties. For example, you can right-click the IAdd element and select Properties to see the IAdd interface properties. You could then change the Is Dual property value to False; this indicates that the Adder example only supports a COM server interface.

An explanation of the hierarchy follows:

• The root is the COM server itself.

• The immediate children of the COM server are classes. The hierarchy initially contains a single class, AddingMachine. You can add additional classes to the COM server.

• The immediate children of a class are interfaces and the class derived-type. In the example, the hierarchy contains the interface IAdd and the class derived-type AddingMachine_InstanceData. Each class contains one, and only one, class derived-type. You can add additional interfaces to the class.

• The immediate children of an interface are methods (one or more).

• The immediate children of a method are the method arguments (one or more).

To add a class, interface, method, property, or argument:

1. Select the parent item, right-click and select the appropriate Add... item.

To delete an item:

1. Select the item to be deleted, right-click and select Delete.

2. Click the Delete button.

Continuing with the Adder COM server example, add methods to the IAdd interface:

1. Right-click the IAdd interface and select Add Method.

2. Enter Clear as the name of the method.

3. Repeat steps 1 and 2, this time entering the name of Add.

The Add method requires an argument. To add the Operand argument named Operand:

1. Right-click on the Add method and select Add Argument.

2. Enter the argument name, Operand.

The default data type of an argument is INTEGER(4).

Proceeding with this example, use the Properties Window to change the Fortran Type property value to REAL(4):

To add a third (and in this example, the last) method:

1. Right-click on the IAdd interface and select Add Method.

2. Enter GetValue as the name for the method.

The GetValue method requires an argument, CurrentValue. To add the CurrentValue argument:

1. Right-click on the GetValue method and select Add Argument.

2. Enter CurrentValue as the name of the argument.

For the CurrentValue argument:

1. Set Fortran Type property value to REAL(4).

2. Set Intent property values to [out,retval].

The screen appears as follows:

The server definition is now complete for this example. When you save the file using File > Save adder.hie, the Fortran sources will be regenerated.

For detailed information about the property pages (right pane) for the server, class, interface, method, argument, or instance properties, see Description of Property Pages.

To change the definition of your server, open adder.hie in the Editor.

Working with the Hierarchy Pane

As you have seen in the AddingMachine example, the hierarchy pane represents the definition of your server; that is, the classes, interfaces, methods, and so on. The hierarchy pane's user interface supports the following functionality:

Description of Property Pages

Property pages appear in the Properties Window. Property pages are available for the following:

• Server Properties

• Class Properties

• Interface Properties

• Method Properties

• Argument Properties

• Instance Type Properties

Server Properties:

Class Properties:

Interface Properties:

Method Properties:

Argument Properties:

Instance Type Properties:

Modifying the Generated Code

When you save the hierarchy file, Fortran sources are generated (or regenerated). Source files are stored as follows:

• Source files that you will need to modify are placed in the Source Files folder.

• Files that are complete and need no modification are placed in the Do Not Edit folder.

Modify the following files in the Source Files folder:

• UAddingMachineTY.f90, which contains a module that defines your class derived-type.

• UIAdd.f90, which contains the implementation of the IAdd methods.

Initially, the file UAddingMachineTY.f90 contains the following code:

The file contains a module named AddingMachine_USE (in the form classname_USE). There are three places in this module where you may need to add code specific to your class:

• The first entry in the module, marked by <BnDEF> and <EnDEF>, is your class derived-type. Initially it contains an "integer dummy" field to allow the module to be compiled without error. If your class has per-object data, remove the "integer dummy" field line and add your data to the derived-type. For the AddingMachine class, we add the following where the object stores the current value:

  real (4) CurrentValue

• The module also contains two module procedures, AddingMachine_CONSTRUCTOR and AddingMachine_DESTRUCTOR (referred to as classname_CONSTRUCTOR and classname_DESTRUCTOR below). The former delineated with <BnCON> and <EnCON>; the latter is delineated with <BnDES> and <EnDES>.

• The classname_CONSTRUCTOR procedure is called immediately after an instance of the class derived-type is created because of the creation of a new object. This function is where you initialize the fields of the class derived-type, if necessary. The new derived-type is passed as an argument to the function. For the AddingMachine class, initialize the current value to 0 by adding the following statement:

  ObjectData%CurrentValue = 0

• The classname_DESTRUCTOR procedure is called immediately before an instance of the class derived-type is destroyed because an object is being destroyed. This function is where you release any resources used by the fields of the class derived-type, if necessary. The derived-type is passed as an argument to the function. For the AddingMachine class, there is nothing that needs to be added.

Now modify the other source file called UIAdd.f90. The original file UIAdd.f90 contains the following code:

A file by the name Uinterfacename.f90 (for example UIadd.f90) is created for each interface defined by the class. The file contains the methods of the class. Each method is named interfacename_methodname, for example: IAdd_Clear. Each method is a function that is passed to the class derived-type as the first argument. This gives the function access to the per-object data. Each function returns a 32-bit COM status code called an HRESULT. S_OK is a parameter that defines a success status. For additional information on COM status codes, see Fortran COM Server Interface Design Considerations.

Replace the ! TODO: Add implementation line in each method with the code for the method. For the IAdd interface, the implementation of its three methods is as follows:

For IAdd_Clear: ObjectData%CurrentValue = 0

For IAdd_Add: ObjectData%CurrentValue = ObjectData%CurrentValue + Operand

For IAdd_GetValue: CurrentValue = ObjectData%CurrentValue

Save the file and, from the Build menu, click Build Solution to build the server. The COM server is now complete.

COM Server Projects and the MIDL Compiler

During the creation of a COM Server project -- either In-process Server (DLL) or Out-of-process Server (EXE), as described in this section -- the application wizard determines whether Visual C++* is installed. If it is installed, the MIDL compiler uses the Visual C++ C preprocessor. This is both the default and recommended setting. If Visual C++ is not installed, the application wizard specifies that the MIDL compiler use the Fortran preprocessor for preprocessing MIDL source files. It does this by setting the Additional Options property of the MIDL compiler to include the following: /cpp_cmdifort /cpp_opt"/nologo /fpp /P /E /Qoption,fpp,/no-fort-cont".

If, later, you install Visual C++ and want to specify that MIDL use the Visual C++ C preprocessor, remove these options from the MIDL compiler Additional Options property.