CTOI Program

The conversion from a .CSC file to an .IDL file is handled by the CTOI program. For example, to convert the file MYDOG.CSC to an IDL file, make sure all the CSC, SC, and PSC files referenced by MYDOG.CSC are accessible, and then invoke the program as shown in the following command line:

ctoi mydog.csc

Note: Converting a Workplace Shell application from a CSC file to an IDL file requires the SC files from the previous OS/2 Toolkit installed on your system (in the SC directory), and all the ones that you might have created. The IDL subdirectory from the OS/2 Toolkit contains the IDL files for the public Workplace Shell classes and objects.

In this example, the CTOI program produces a file called MYDOG.IDL containing the definitions in IDL format. In many cases, you should be able to compile, install and run your application without further modification. However, the following situations will require manual intervention:

Any classes that use IDL reserved words as functions or variable names need to be changed. For example, "string", "context", "interface".
The SOM compiler no longer generates .SC, .PSC, or .PH files. Installation and make files that refer to .CSC, .SC, .PSC, or .PH files need to be changed.

The data declaration changes. Public and private instance variables are converted to attributes. However, structures and arrays require manual changes, as shown in the following figure:

OIDL                           IDL

data:
  struct info infoBuffer;      interface: ...   {
                                  typedef struct info info;
                                  ...
                               implementation {
                                  info infoBuffer;
                                  ...
                                  };

data:
  char achMyArray[20];         interface: ...   {
                                  typedef char myarraytype[20];
                                  ...
                               implementation {
                                  attribute myarraytype achMyArray;
                                  ...
                                  };

data:
  unsigned char chFlag;        attribute octet chFlag;

data:
  char    *argv[];             char   **argv;

IDL does not permit structures to be passed by value. Instead, methods must pass a pointer to a structure. Methods can return a structure, and if a method does so, it should have the modifier struct attached to it, as shown in the following figure:
```
AStructure resolveMyIdentity(in string pszIdent), struct;
```
The OIDL private qualifier has been removed. Private instance data and methods must now be enclosed in a special #ifdef directive, as shown in the following figure:
```
OIDL                             IDL

int x, private;                  #ifdef __PRIVATE__
                                    int x;
VOID mymethod(), private;           VOID mymethod();
                                 #endif
```
To include private data and methods in the processing of an IDL file, the SOM compiler should be invoked with either the -P option or the -D_PRIVATE_ option, as shown in the following command lines:
```
sc -p yourname.idl

sc -d__PRIVATE__ yourname.idl
```
Note that there are two underscore ( __ ) characters before and after the word PRIVATE.
Passthru statement processing has changed. Passthru statements should only be used to pass #include directives to the language binding files. In addition:
- Information can no longer be directed to the implementation (.C) file
- Most information directed to implementation Header (.IH) files should be moved to the implementation (.C) file
Because IDL is strongly typed (unlike OIDL), data structures and constants should be declared before referencing them, in order to eliminate unnecessary warning messages during compilation. This is required if an interface repository (.IR) file is to be created from the IDL file.
[Back] [Next]