somFree Compiler and Emitter Framework is a free open source binary compatible reimplementation of IBM SOM Compiler and Emitter Framework. It is tries to be as compatible as possible on API and ABI level.

Changes from original somFree compiler:

• Most of internal structures now also present as in old IBM SOM 2.1 NT Toolkit.
• New emitters:
  • LNK - Open Watcom WLink support.
  • DUMP - displays structures, available to emitter.
  • PAS - Pascal client support.
  • IPAS - Pascal implementation classes support.
• SOM Compiler library now mostly documented.
• SOMLINK style functions for most of SOM Compiler library added.
• Emitters now IBM SOM 2.1 and IBM SOM 3.0 compatible without recompilation.
• somFree Compiler supports IBM SOM 2.1, IBM SOM 3.0, and somFree 1.0 emitters.
• somtShowEntry function outputs more info.
• Undocumented SOMTTypes now documented.
• SOMIPC now supports IDL 4.2 specification.
• CORBA C Language Mapping Specification 1.0 now supported by default instead of SOM C Language mapping.
• Added support of OIDL files

The somFree Compiler is a tool to produce various file formats from Interface Definition Language (IDL) files or Object Interface Definition Language (OIDL) files. somFree Compiler reads IDL or OIDL file and produces an abstract graph tree. Using abstract tree, somFree Compiler generates an object graph tree. After the object graph is ready, somFree Compiler produces an output using template.

The somFree Compiler uses DLL-name based loading of classes libraries (other programs can user another approach, like WPS does. WPS uses an Interface Repository to find corresponding class). Most of the somFree Compiler classes libraries it is implementation of corresponding emitter. Emitters can be created with help of Emitter Framework.

somFree Compiler actually is a client program which uses Emitter Framework classes. somFree Compiler is open source program with an open architecture. The only things that couldn't be easily extended are parser, abstract graph builder and object graph builder. Other things can be shadowed and replaced by our own.

Let's look at somFree Compiler command line syntax to understand how to produce corresponding skeleton code from somFree Compiler template (below is somFree Compiler help screen):

sc [-C:D:E:I:S:VU:cd:hi:m:prsvw] f1 f2 ...
Where:
      -C <n>            - size of comment buffer (default: 200000)
      -D <DEFINE>       - same as -D option for cpp.
      -E <var>=<value>  - set environment variable.
      -I <INCLUDE>      - same as -I option for cpp.
      -S <n>            - size of string buffer (default: 200000)
      -U <UNDEFINE>     - same as -U option for cpp.
      -V                - show version number of compiler.
      -c                - ignore all comments.
      -d <dir>          - output directory for each emitted file.
      -h                - this message.
      -i <file>         - use this file name as supplied.
      -m <name[=value]> - add global modifier.
      -p                - shorthand for -D__PRIVATE__.
      -r                - check releaseorder entries exist (default: FALSE).
      -s <string>       - replace SMEMIT variable with <string>
      -u                - update interface repository.
      -v                - verbose debugging mode (default: FALSE).
      -w                - don't display warnings (default: FALSE).

Modifiers:
      addprefixes : adds `functionprefix' to method names in template file
      [no]addstar : [no]add `*' to C bindings for interface references.
            corba : check the source for CORBA compliance.
              csc : force running of OIDL compiler.
       emitappend : append the emitted files at the end of the existing file.
         noheader : don't add a header to the emitted file.
            noint : don't warn about "int" causing portability problems.
           nolock : don't lock the IR during update.
             nopp : don't run the source through the pre-processor.
             notc : don't use typecodes for emit information.
       nouseshort : don't generate short names for types.
        pp=<path> : specify a local pre-processor to use.
         tcconsts : generate CORBA TypeCode constants.

Note: All command-line modifiers can be set in the environment
by changing them to UPPERCASE and preappending "SM" to them.

Environment Variables:
      SMEMIT=[h;ih;c;xh;xih;xc;def;ir;pdl]
      	: emitters to run (default : h;ih).
      SMINCLUDE=<dir1>[;<dir2>]+
      	: where to search for .idl and .efw files.
      SMKNOWNEXTS=ext[;ext]+
      	: add headers to user written emitters.
      SMTMP=<dir>
      	: directory to hold intermediate files.
      SOMIR=<path>[;<path>]+
      	: list of IRs to search.

Pragmas:
      #pragma somemittypes on          : turn on emission of global types.
      #pragma somemittypes off         : turn off emission of global types.
      #pragma modifier <modifier stm>; : instead of modifier statement.

Now let's explain some command line switches deeper.

First of the most interesting switch is -s. By default somFree Compiler uses SMEMIT environment variable to determine which emitter to use. Look at emit*.dll files for corresponding emitter. Using switch -s you can change default logic and select one-time emitter instead of global emitters. In easy situation you need only one emitter (say, C emitter). In complex situations you need use more emitters (say, C, H, DEF and IH emitters). You can create your own emitter to produces, for example, some sort of documentation and other stuff.

Another interesting switch is -m. Using -m you can set and/or unset so named modifiers. Modifiers allow you to change default behaviour of emitter and compiler. As example, by default compiler adds new methods or modifies existent. You can tell compiler just add new text to end of file. Modifiers can control emitters. addstart and noaddstar controls C emitter to add or not add pointer sign (*) to references of objects.

Switch -u adds or updates Interface Repository with new information about class interface. Interface repository filename controlled by SOMIR environment variable. This thing useful to add info for Object REXX access and other things which uses Interface Repository.

Other switches are like for standard C/C++ preprocessor and not described here.

Now let's play with somFree Compiler. Most often, you need to create interface files for C/C++ client programs. Usually you need to call the SOM Compiler as following:

sc -sdef somobj.idl
sc -sh somobj.idl

In case of C++ you need to call:

sc -sdef somobj.idl
sc -sxh somobj.idl

Of course, not very nice to call somFree Compiler so often. And somFree Compiler provides such functionality:

sc -sdef;h;xh somobj.idl

The above command will do exactly as all recent commands.

The above emitters were designed for IBM toolset. Nowadays, developers also use GCC or Open Watcom Compilers. The problem here is that Watcom Linker doesn't support .DEF files, but has its own .LNK linker files. In case of one or two classes no many problems to convert .DEF files to .LNK files manually. But such approach just ugly for MUCH classes. So, one of good solution is write REXX script for DEF→LNK conversion. But somFree Compilers contains Open Watcom Linker Emitter for such approaches.

Now let's talk about internals of somFree Compiler. somFree Compiler designed in the way as most of C compilers implemented. It is exists of following parts:

• IDL Preprocessor
• IDL Parser
• OIDL Preprocessor
• OIDL Parser
• Emitter Framework

somFree Compiler first calls IDL or OIDL Preprocessor. Output of IDL/OIDL Preprocessor goes to IDL/OIDL Parser. IDL/OIDL Parser creates Object tree from IDL/OIDL source. Object tree, using templates and emitters, stored to file.

As you see, most of the parts can be extended or replaced by its own implementation. For example, we can reuse CPP instead of SPP. Why not? Just support required command-line switches for compatibility. Also, default emitters can be rewritten. For C and C++ emitter it is not so hard. For other, more structured languages, like Pascal, Modula, etc. emitter creation is more hard work, but it is also possible.

Actually, we can extend and rewrite somFree Compiler as we want.

Usage of somFree Compiler will not be problem for most of you. But understanding some details about compiler internals makes life easer.

Latest IBM SOM 3.0 supports CORBA IDL mostly at level of CORBA 1.1. somFree supports CORBA IDL 4.2 with all extensions found in SOM IDL.

• Include Directives (optional)
• Type and Constant Declarations (optional)
• Exception Declarations (optional)
• Interface Declarations (optional)
• Module declaration (optional)

Let's try to define our class interface.

Interface Definition Language (IDL) is the core of System Object Model. All classes have definition of its interface via IDL. With help of somFree Compiler IDL file can be translated to various formats, including various language bindings. For example, to produce C header you can run

sc -s"h" somcls.idl

to produce DEF file you can run

sc -s"def" somcls.idl

somFree Compiler uses emitter to produce corresponding language binding. You can create new bindings emitter using Emitter Framework.

First of all, think about your class. What it must do? Define them in terms of object. Propose attributes and methods of class.

Ok. Imagine, we need class to have access to Java objects. Let's write a class interface in terms of Interface Definition Language.

 #include <somobj.idl>
 
 interface JavaObject : [[SOMObject]]
 {
   implementation
   {
     somDefaultInit: override;
     // Init Java Virtual Machine (if no current) and create Java object
     somDefaultDestruct: override;
     // Destruct Java object and close Java Virtual Machine (if needed)
   }
 }

As you can see, no many problems. Syntax of IDL too closest to C-like languages. First thing you need is to include definitions of parent classes. In our case it is 'SOMObject' definition. Generic Java object doesn't need to have any methods. Only thing 'JavaObject' will do its check for existence of Java Virtual Machine and execution of it if required.

On object destruction checks is Java Virtual Machine still required will be done and it will be destroyed if not required. Also same constructor and destructor will call corresponding constructor and destructor of Java object.

Classic IDL file contains definitions like

 interface <class> : <parent_class>
 {
   attribute <type> <name>
 
   <type> <method>(<parameters>)
 }

[http://www.omg.org OMG] IDL doesn't support methods override. SOM IDL has such feature (and incompatibility with OMG CORBA). This is done via keyword 'implementation'. To solve problems with other IDL compilers such part must be wrapped to #ifdef structure:

 #include <somobj.idl>
 
 interface JavaObject : [[SOMObject]]
 {
 
   #ifdef __SOMIDL__
   implementation
   {
     somDefaultInit: override;
     // Init Java Virtual Machine (if no current) and create Java object
     somDefaultDestruct: override;
     // Destruct Java object and close Java Virtual Machine (if needed)
   }
   #endif
 }

Such approach well known in C-world, but also have some problems. For example, IDL of Document Object Model (DOM) (Yes, [http://www.w3.org W3C] DOM uses same IDL as SOM and CORBA) has attribute 'implementation'. As result, somFree Compiler has some problems with IDL compilation.

As a first step we'll create SOM class interface for java.lang.Object. It can be done with help of javah tool.

javah -jni java.lang.Object

As result you'll have such file:

 /* DO NOT EDIT THIS FILE - it is machine generated */
 #include <jni.h>
 /* Header for class java_lang_Object */
 
 #ifndef _Included_java_lang_Object
 #define _Included_java_lang_Object
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
  * Class:     java_lang_Object
  * Method:    hashCode
  * Signature: ()I
  */
 JNIEXPORT jint JNICALL Java_java_lang_Object_hashCode
   (JNIEnv *, jobject);
 
 /*
  * Class:     java_lang_Object
  * Method:    notify
  * Signature: ()V
  */
 JNIEXPORT void JNICALL Java_java_lang_Object_notify
   (JNIEnv *, jobject);
 
 /*
  * Class:     java_lang_Object
  * Method:    notifyAll
  * Signature: ()V
  */
 JNIEXPORT void JNICALL Java_java_lang_Object_notifyAll
   (JNIEnv *, jobject);
 
 /*
  * Class:     java_lang_Object
  * Method:    registerNatives
  * Signature: ()V
  */
 JNIEXPORT void JNICALL Java_java_lang_Object_registerNatives
   (JNIEnv *, jclass);
 
 /*
  * Class:     java_lang_Object
  * Method:    wait
  * Signature: (J)V
  */
 JNIEXPORT void JNICALL Java_java_lang_Object_wait
   (JNIEnv *, jobject, jlong);
 
 /*
  * Class:     java_lang_Object
  * Method:    getClass
  * Signature: ()Ljava/lang/Class;
  */
 JNIEXPORT jclass JNICALL Java_java_lang_Object_getClass
   (JNIEnv *, jobject);
 
 /*
  * Class:     java_lang_Object
  * Method:    clone
  * Signature: ()Ljava/lang/Object;
  */
 JNIEXPORT jobject JNICALL Java_java_lang_Object_clone
   (JNIEnv *, jobject);
 
 #ifdef __cplusplus
 }
 #endif
 #endif

So, this header can be used to generate actual class interface using this script:

 /* REXX - our best dog */
 
 do while lines('java_lang_Object.h')
   s=linein('java_lang_Object.h');
   parse value s with x 'Header for class' name '*/'
   if name\='' then
   do
     classname=strip(name)
     say '#include <JavaObject.idl>'
     say ''
     say 'interface '||classname||' : JavaObject'
     say '{'
   end
   parse value s with x 'Method:' name
   if name\='' then
   do
     /* skip 3 lines */
     s=linein('java_lang_Object.h');
     s=linein('java_lang_Object.h');
     s=linein('java_lang_Object.h');
     s2=linein('java_lang_Object.h');
     interpret("parse value s with 'JNIEXPORT' type 'JNICALL Java_"||classname||"_' name")
     name=strip(name)
     s2=strip(s2)
     parse value s2 with start 'JNIEnv *, jobject' end
     s2=start||end
     parse value s2 with x ', ' y
     if x='(' then s2='('||y
     say '  '||type||name||' '||s2
   end
 end
 say '}'

As result, you'll have following:

 #include <JavaObject.idl>
 
 interface java_lang_Object : JavaObject
 {
    jint hashCode ();
    void notify ();
    void notifyAll ();
    void registerNatives (JNIEnv *, jclass);
    void wait (jlong);
    jclass getClass ();
    jobject clone ();
 } 

Using such approach you can easily make SOM wrappers for all Java classes. Using Java_JNI_API you can create Java classes and using SOM wrappers you integrate Java code to SOM-based applications. Because SOM API more generic then Java API you can use any available language bindings for development. Also, you can start to extend Java classes by native code with help of SOM engine.

SOM Object Interface Definition Language is a pre-IDL object definition language used before IBM SOM 2.1. Since IBM SOM 2.1 uses CORBA IDL as defined in OMG CORBA 1.1. SOM Object Interface Definition Language (OIDL) is a simple definition language and not recommended to use. SOM Compiler support is only for compatibility with old source code. OIDL support implementation mostly based on [1] and various OIDL source files found on the Web. OIDL consist of sections set:

• Include section (optional)
• Class section (required)
• Release order section (optional)
• Parent class section (required)
• Passthru section (optionsl)
• Metaclass section (optional)
• Data section (optional)
• Methods section (optional)

Include section is optional and contains names of OIDL files with definition of parent class, metaclasses and private interfaces of ancestor classes.

[#include ( <ancestor> | "ancestor" ) ] *
#include ( <parent> | "parent")
[#include ( <metaclass> | "metaclass" ) ]

ancestor is the name of the OIDL file containing the private part of an ancestor class' interface needed in the definition of this class. If ancestor is enclosed in angle brackets (<>), the search for the file will begin in system-specific locations. If parent is enclosed in double quotation marks (""), the search for the file will begin in the local context, then move to the system-specific locations.

class: name
  [, file stem = stem]
  [, external stem = stem]
  [, function prefix = prefix |
  , external prefix = prefix |
  , classprefix = prefix]
  [, major version = number]
  [, minor version = number]
  [, global | local];
  [, classInit = function];
[description]

release order: name [, name ]* ;

parent [class]: name;
description

[passthru: language.suffix, [ before | after ];
line 1
line 2
endpassthru; [description]]*

metaclass: name;
[description]

data:
[description1 ]
[declaration [ , private | , public | , internal] [, class];
[ description2]]*

methods:
[description1 ]
[[group: name;
[ description2]]
[method prototype
[, public | , private]
[, method | , procedure]
[, class]
[, offset | , name lookup]
[, local | , external]
[, use = name];
[descriptionS]]*
[override: method name
[, public | , private]
[, class]
[, local | , external]
[, use = name];
[description4]] *

somFree compiler is a tool to convert various interface definition languages to another one or language bindings. somFree compiler frontend is a sc or somc command which control workflow. Because somFree compiler and Emitter Framework modeled after IBM SOM Compiler from here SOM Compiler term will be used. Most of somFree Compiler and Emitter Framework and SOM Compiler and Emitter Framework are same and binary compatible at the documented level. Internal structures of somFree and IBM versions are different.

SOM Compiler at file level consist of:

• SOM Compiler frontend
  • sc [Linux]
  • sc.exe [OS/2, Windows]
  • somc.exe [Windows]
• IDL SOM Pre-processor
  • somcpp [Linux]
  • somcpp.exe [OS/2, Windows]
• IDL SOM Compiler
  • somipc [Linux]
  • somipc.exe [OS/2, Windows]
• OIDL SOM Pre-processor
  • spp [Linux]
  • spp.exe [OS/2, Windows]
• OIDL SOM Compiler
  • somopc [Linux]
  • somopc.exe [OS/2, Windows]
• SOM Compiler Library
  • somc.so [Linux]
  • somc.dll [OS/2, Windows]
• SOM Emitter Framework
  • some.so [Linux]
  • some.dll [OS/2, Windows]
• Emitters
  • emit*.so [Linux]
  • emit*.dll [OS/2, Windows]
• Public IDL files generator
  • pdl [Linux]
  • pdl.exe [OS/2, Windows]

Currently SOM Compiler provides following emitters:

• IDL - IDL Emitter
• CSC - OIDL Emitter
• SC - OIDL public emitter
• GEN - Generic Emitter
• IR - Interface Repository Emitter
• H - C Binding public header files
• C - C Binding implementation template file
• IH - C Binding implementation header files
• XH - C++ Binding public header files
• XIH - C++ Binding implementation header files
• DEF - DEF Module Definition file
• LNK - LNK Module Linking file
• HC
• IMOD - SOM Module initialization emitter
• MODS - List of class modifiers
• PDL - Private IDL emitter
• PH
• PSC - OIDL private emitter
• UC
• UXC
• XPH
• XTM
• PAS - Pascal client library for use of SOM
• IPAS - Pascal implementation library to write SOM classes.

Some of Emitters uses Templates such as:

• cpp.efw
• ctm.efw
• gen_c.efc
• gen_c.efs
• gen_c.efw
• gen_cpp.efw
• gen_def.efw
• gen_emit.efc
• gen_emit.efs
• gen_emit.efw
• gen_emit.efx
• gen_idl.efw
• gen_make.efc
• gen_make.efs
• gen_make.efw
• gen_make.efx
• gen_mk32.efc
• gen_mk32.efs
• gen_mk32.efw
• gen_mk32.efx
• gen_mknt.efs
• gen_mknt.efw
• gen_mknt.efx
• gen_nid.efw
• gen_temp.efw
• imod.efw

Emitter Framework is a set of classes and SOM Compiler tool. Emitter Framework is used to produce various file formats from the SOM Interface Definition Language files. Emitter Framework classes consist of Emitter classes and Entry classes. Classes can be shadowed. This means a programmer can replace original classes with his own classes. So the SOM Compiler can be highly customized. The only things hard-coded (and closed source) are the IDL file reader and abstract graph builder.

Before starting description of Emitter Framework let's talk about SOM Compiler. We already talked briefly about SOM Compiler. But for emitters we need to know internals of SOM Compiler much better.

Let's start from visible parts of SOM Compiler that requires for its work the following files:

• sc.exe, somc.dll and somc.msg - Main part of compiler.
• somcpp.exe - SOM Preprocessor
• somipc.exe - Goals not known. Seems just execute different emitters
• emit*.dll - Emitters
• *.efw - Emitter templates

sc.exe is general part of compiler. Let's try to investigate some internals of sc.exe. First of all we can switch on verbose output and look on it:

Running shell command:
somcpp -D__OS2__  -I. -IC:\os2tk45\h -IC:\os2tk45\idl -IC:\os2tk45\som\include \
      -D__SOMIDL_VERSION_1__ -D__SOMIDL__ -C somobj.idl > C:\var\temp\0a500000.CTN
somipc -mppfile=C:\var\temp\0a500000.CTN -v -e emith -e emitih -e emitctm -e emitc \
      -o somobj somobj.idl
Loading  emith.
"SOMObject"
Unloading  emith.
Loading  emitih.
"SOMObject"
Unloading  emitih.
Loading  emitctm.
"SOMObject"
Unloading  emitctm.
Loading  emitc.
"SOMObject"
Unloading  emitc.
Removed "C:\var\temp\0a500000.CTN".

Not so many info, but some information here. If we look at SMINCLUDE environment variable:

SMINCLUDE=.;C:\os2tk45\h;C:\os2tk45\idl;C:\os2tk45\som\include;

then we will see all paths in -I option.

Considering -D is same as for CPP we can see three symbols defined: * OS2 * SOMIDL_VERSION_1 * SOMIDL somobj.idl it is file we emitted and CTN file is output from preprocessor. The only unknown switch is -C. After small playing we can see it means “leave comments”.

So, we can try to replace somcpp with some preprocessor. In [http://www.osfree.org osFree] project we tried to use [http://mcpp.sourceforge.net MCPP] preprocessor. Results is well.

sc.exe reads SMINCLUDE variable and puts its content to -I options of somcpp.exe and redirect output to temporary file.

Ok. Now we can try to detect what is somipc.exe. If we try to execute it with command line pointed above, then we will see: Loading emith. “SOMObject” Unloading emith. Loading emitih. “SOMObject” Unloading emitih. Loading emitctm. “SOMObject” Unloading emitctm. Loading emitc. “SOMObject” Unloading emitc.

Heh. Actually, somipc.exe is a real SOM Compiler. Not sc.exe. sc.exe only prepares the input file for the compiler and handles command line and environment variables.

After some playing we can see, somipc returns 0 if all ok and -1 if error.

So, somipc.exe parses preprocessed IDL file and builds Abstract graph. From Abstract graph Object Graph are build. After this somipc.exe calls one by one all emit*.dll files according to -e switches. emit*.dll are set of DLLs with SOM classes.

Drawing here!!

SOM Compiler IDL SOM Preprocessor IDL SOM Compiler Emitter Template

		OIDL SOM Preprocessor	OIDL SOM Compiler

Разрисовать по аналогии с со структурой, что в патентах и документации по SOM, но с учетом наличия OIDL и SOMC.

SOM Compiler sc or somc is a frontend which controls basic workflow. Depending on source file extension it call or IDL or OIDL pre-processor and, after preprocessing, IDL or OIDL compiler. IDL or OIDL compiler builds abstract syntax graph using Entry structure. Entry structure contains information about entry type, pointer to object wrapper and all information about object specific attributes.

Note! Entry structure is not documented and differs in somFree and IBM SOM versions.

IDL or OIDL calls required emitters with root Entry structure on emitter entry. Emitter requests root object wrapper and, using or not using template faculty, process all graph using Object Syntax Graph. Object Syntax Graph generates required Entry objects on demand.

Emitter is a subclass of 'SOMTEmitC' class. Emitter used to produce output file using template file from object graph of the SOM Interface Definition Language file. Physically emitter represented as DLL with name EMIT<identificator>.DLL. For C headers emith.dll emitter DLL is used. For C++ headers emitxh.dll emitter DLL is used. Emitter DLL contains only one entry with ordinal 1 and name 'emit'.

SOMEXTERN FILE * SOMLINK emit(char *file, Entry * cls, Stab * stab);

'emit' function creates emitter object (from emitter class, which based on 'SOMTEmitC') and calls 'somtGenerateSections' method.

Usually an emitter file can be generated using 'newemit.cmd' script (can be found at Hobbes in SOMObjects toolkit).

newemit -C <className> <file_stem>

To emitter passed Entry object which is root of Object Graph. The root object can be an interface or module class. Processing of such classes slightly different.

Last part of Emitter Framework is template files. Template files allow you to make some control of emitting process. Templates are usual text files with extension *.efw. Here you can modify output for your wish. Not all emitters support templates.

So, now you have some imagination about that Emitter Framework is and how it works.

Emitters uses template faculty to produce output file. Template file has structure divided by sections. Each section begins from section name ended by colon. Each emitter can use its own section names. Refer to corresponding emitter and Entry classes description for section names information. Here is template file example:

:copyrightS
This is example template
:templateS
/* Template output example */
<className>

Core of Template faculty is a Key-Value strings collection represented by SOMStringTableC class. All substitutable to template values stored in SOMStringTableC class instance. On template file process, First of all SOMTEmitC method somtSetPredefinedSymbols sets section names symbols. By default it is following sections:

Generic emitter is a generic template based emitter. It uses simplest template with only one section “template”. Main goal of Generic Emitter is to produce Generic framework emitter files. It is used by newemit tool to produce full set of files required to build new emitter. Добавить описание символов шаблона и описание, какой шаблон за что отвечает.

DEF emitter used to generate definition file for DLL creation using MS LINK. somFree version of emitter uses template file to generate DEF file. Original IBM SOM DEF Emitter uses hard coded generation. Добавить описание символов шаблона.

LNK emitter used to generate linking file for DLL creation using Watcom WLINK. somFree version of emitter uses template file to generate LNK file. Original IBM SOM DEF Emitter doesn't have such emitter. Добавить описание символов шаблона.

CSC emitter used to generate OIDL class definition file (CSC) used in IBM SOM 1.0. somFree version of emitter uses template file to generate CSC file. Original IBM SOM CSC Emitter uses hard coded generation. Добавить описание символов шаблона.

IDL emitter used to generate IDL class definition file used in IBM SOM 2.0 and higher. somFree version of emitter uses template file to generate IDL file. Original IBM SOM IDL Emitter uses hard coded generation. Добавить описание символов шаблона.

somFree Emitter Framework provides templates and libraries for developing emitters compatible with both IBM SOM 2.1 and IBM SOM 3.0 compilers. Because of different ABI (refer Appendix 1 for more information) somFree emitters automatically configures for corresponding API.

somFree Compiler support CORBA C Language Mapping Specification 1.0 [1]. CORBA C Language mapping slightly differ from SOM C Language mapping, used by original IBM SOM 2.1. CORBA C Language mapping is default for somFree Compiler. This chapter provides short description of mapping. For full description refer to [1].

SOM C Language mapping is a IBM SOM mapping variant. For some reason (most probably because variable arguments support) IBM SOM not exactly implements C Language Mapping Specification.

SOM Runtime C library somwm35i is a subset of C runtime library functions found to be used by IBM SOM 3.0 for NT emitters. SOM Runtime C library provided only for support of IBM SOM 3.0 for NT emitters. This is not full featured C library but compatibility layer and must not be used for development. Functions utilize IBM Optlink calling convention. This library required only under Windows NT systems.

List of emulated function and variables.

• _CRT_init
• _CRT_term
• _abort_in_progress
• _exception_dllinit
• _matherr
• fclose
• _fprintfieee
• strlen
• _sprintfieee
• strcmp
• strstr
• _ctype
• feof
• fgetc
• fgets
• fputs
• fread
• fseek
• fwrite
• memmove
• memset
• remove
• rename
• rewind
• strchr
• strcpy
• strlen
• strncmp
• strncpy
• strrchr
• strtok
• tolower
• memcpy
• strcat
• getenv
• _printfieee
• _sscanfieee
• exit
• stderr
• _putenv
• _terminate
• _PrintErrMsg
• _SysFindFirst
• _SysFindNext
• _SysFindClose
• malloc
• free
• strdup
• strpbrk

somFree Compiler library somc is a set of helper functions for compiler tasks. Used by IBM SOM emitters. Library provided solely to provide support of IBM emitters. Must not be used to write new code.

SOMEXTERN BOOL somtfexists(char *file);
SOMEXTERN BOOL SOMLINK somtfexistsSL(char *file);

Check is file exists in paths.

Note: somtfexists version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtsearchFile(char *file, char *fullpath, char *env);
SOMEXTERN char * SOMLINK somtsearchFileSL(char *file, char *fullpath, char *env);

Search path using file and env dirs and return full path if exists.

Note: somtsearchFile version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somttraverseParents(FILE *fp, Entry * cls, Entry *arg, int (*fn)(FILE*,Entry*,Entry*), SMTraverse flg);
SOMEXTERN int SOMLINK somttraverseParentsSL(FILE *fp, Entry * cls, Entry *arg, int (*fn)(FILE*,Entry*,Entry*), SMTraverse flg);

Note: somttraverseParents version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN EmitFn  SOMLINK somtloadSL(char *fileName, char *functionName, void **modHandle);

Load emitter <fileName> and return pointer <EmitFn> to emit or emitSL function <functionName> and return handle <modHandle> of loaded module. This function switches somc to IBM SOM 3.0 ABI if emitSL function found or to IBM SOM 2.1 ABI if emit function found.

SOMEXTERN Entry * somtfindBaseEp(Entry *ep);
SOMEXTERN Entry * SOMLINK somtfindBaseEpSL(Entry *ep);

Note: somtfindBaseEp version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Entry * somtgetType(char *name, SOMTTypes type);
SOMEXTERN Entry * SOMLINK somtgetTypeSL(char *name, SOMTTypes type);

Note: somtGetType version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN FILE * somtokfopen(char *path, char *mode);
SOMEXTERN FILE * SOMLINK somtokfopenSL(char *path, char *mode);

Same as C fopen function.

Note: somtokfopen version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtokrename(const char*, const char *);
SOMEXTERN int SOMLINK somtokrenameSL(const char*, const char *);

Note: somtokrename version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN FILE * somtopenEmitFile(char *file, char *ext);
SOMEXTERN FILE * SOMLINK somtopenEmitFileSL(char *file, char *ext);

Note: somtopenEmitFile version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN BOOL somtisDbcs(int c);
SOMEXTERN BOOL SOMLINK somtisDbcsSL(int c);

Note: somtisDbcs version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN boolean somtremoveExt(char *name, char *ext, char *buf);
SOMEXTERN boolean SOMLINK somtremoveExt(char *name, char *ext, char *buf);

Remove extension from<name> and return to <buf>

Note: somtremoveExt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtaddExt(char *name, char *ext, char *buf);
SOMEXTERN char * SOMLINK somtaddExtSL(char *name, char *ext, char *buf);

Add <ext> extension to <name> filestem and return result in <buf>

Note: somtaddExt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtarrayToPtr(Entry *ep, char *stars, char *buf);
SOMEXTERN char * SOMLINK somtarrayToPtrSL(Entry *ep, char *stars, char *buf);

Note: somtarrayToPtr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtattNormalise(char *name, char *buf);
SOMEXTERN char * SOMLINK somtattNormaliseSL(char *name, char *buf);

Note: somtattNormalise version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtbasenameSL(char *path);
SOMEXTERN char * SOMLINK somtbasenameSL(char *path);

Return filename without path.

Note: somtbasename version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtctos(Const *con, char *buf);
SOMEXTERN char * SOMLINK somtctosSL(Const *con, char *buf);

Note: somtctos version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtdbcsPostincr(char **p);
SOMEXTERN char * SOMLINK somtdbcsPostincrSL(char **p);

Note: somtdbcsPostincr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtdbcsPreincr(char **p);
SOMEXTERN char * SOMLINK somtdbcsPreincrSL(char **p);

Note: somtdbcsPreincr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtdbcsStrchr(char *s, int c);
SOMEXTERN char * SOMLINK somtdbcsStrchrSL(char *s, int c);

Note: somtdbcsStrchr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtdbcsStrrchr(char *s, int c);
SOMEXTERN char * SOMLINK somtdbcsStrrchrSL(char *s, int c);

Note: somtdbcsStrrchr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtdbcsStrstr(char *s1, char *s2);
SOMEXTERN char * SOMLINK somtdbcsStrstrSL(char *s1, char *s2);

Note: somtdbcsStrstr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somteptotype(Entry *ep, char *ptrs, char *buf);
SOMEXTERN char * SOMLINK somteptotypeSL(Entry *ep, char *ptrs, char *buf);

Note: somteptotype version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtgetDesc(Stab *stab, Entry *cls, Entry *method, char *desc, BOOL addQuotes, BOOL use, BOOL versflg);
SOMEXTERN char * SOMLINK somtgetDescSL(Stab *stab, Entry *cls, Entry *method, char *desc, BOOL addQuotes, BOOL use, BOOL versflg);

Note: somtgetDesc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtgetVersion(char *sccsid, char *version);
SOMEXTERN char * SOMLINK somtgetVersionSL(char *sccsid, char *version);

Note: somtgetVersion version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtgetgatt(char *s);
SOMEXTERN char * SOMLINK somtgetgattSL(char *s);

Note: somtgetgatt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtnextword(const char *s, char *buf);
SOMEXTERN char * SOMLINK somtnextwordSL(const char *s, char *buf);

Note: somtnextword version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtnormaliseDesc(char *desc, char *normal);
SOMEXTERN char * SOMLINK somtnormaliseDescSL(char *desc, char *normal);

Note: somtnormaliseDesc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtsatos(char **sa, char *sep, char *buf);
SOMEXTERN char * SOMLINK somtsatosSL(char **sa, char *sep, char *buf);

Note: somtsatos version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtsearchFile(char *file, char *path, char *envvar);
SOMEXTERN char * SOMLINK somtsearchFileSL(char *file, char *path, char *envvar);

Note: somtsearchFile version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtskipws(const char *s);
SOMEXTERN char * SOMLINK somtskipwsSL(const char *s);

Note: somtskipws version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtstringFmtSL(char *fmt, ...)
SOMEXTERN char * SOMLINK somtstringFmtSL(char *fmt, ...)

Allocate buffer for string, format it using <fmt> and return pointer to buffer.

Note: somtstringFmt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somttype(SOMTType type);
SOMEXTERN char * SOMLINK somttypeSL(SOMTType type);

Return string representation of type of Entry structure except special case SOMTEmitterBeginE and SOMTEmitterEndE types.

Note: somttype version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

Warning: Depricated. Use somtEntryTypeName instead.

SOMEXTERN char * somtuniqFmt(MemBuf *membuf, char *fmt, ...)
SOMEXTERN char * SOMLINK somtuniqFmtSL(MemBuf *membuf, char *fmt, ...)

Return unique formatted string.

Note: somtuniqFmt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtargFlag(int *argc, char ***argv);
SOMEXTERN int SOMLINK somtargFlagSL(int *argc, char ***argv);

Note: somtargFlag version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtattjoin(register AttList *ap1, AttList *ap2);
SOMEXTERN int SOMLINK somtattjoinSL(register AttList *ap1, AttList *ap2);

Note: somtattjoin version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtdbcsLastChar(char *buf);
SOMEXTERN int SOMLINK somtdbcsLastCharSL(char *buf);

Note: somtdbcsLastChar version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtdbcsScan(char **buf);
SOMEXTERN int SOMLINK somtdbcsScanSL(char **buf);

Note: somtdbcsScan version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtdiskFull(FILE *fp);
SOMEXTERN int SOMLINK somtdiskFullSL(FILE *fp);

Note: somtdiskFull version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtfclose(FILE *fp);
SOMEXTERN int SOMLINK somtfcloseSL(FILE *fp);

Same as C fclose function.

Note: somtfclose version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtisparent(Entry *cls, Entry *parent);
SOMEXTERN int SOMLINK somtisparentSL(Entry *cls, Entry *parent);

Note: somtisparent version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtmget(int setnum, int msgnum, char *msgbuf);
SOMEXTERN int SOMLINK somtmgetSL(int setnum, int msgnum, char *msgbuf);

Note: somtmget version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtmopen(char *filename);
SOMEXTERN int SOMLINK somtmopenSL(char *filename);

Note: somtmopen version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtmprintf(int setnum, int msgnum, ...);
SOMEXTERN int SOMLINK somtmprintfSL(int setnum, int msgnum, ...);

Note: somtmprintf version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtokremove(char *file);
SOMEXTERN int SOMLINK somtokremoveSL(char *file);

Alias of C remove function.

Note: somtokremove version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtunload(void *modHandle);
SOMEXTERN int SOMLINK somtunloadSL(void *modHandle);

Note: somtunload version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtwriteaccess(char *file);
SOMEXTERN int SOMLINK somtwriteaccessSL(char *file);

Note: somtwriteaccess version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtsmalloc(size_t nbytes, BYTE clear);
SOMEXTERN void * SOMLINK somtsmallocSL(size_t nbytes, BYTE clear);

Allocate <nbytes> of memory and fill it by zeroes if <clear> flag is set.

Note: somtsmalloc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtaddGAtt(MemBuf **membuf, AttList **ap, char *buf);
SOMEXTERN void SOMLINK somtaddGAttSL(MemBuf **membuf, AttList **ap, char *buf);

Note: somtaddGAtt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtcalcFileName(char *def, char *over, char *ext);
SOMEXTERN void SOMLINK somtcalcFileNameSL(char *def, char *over, char *ext);

Note: somtcalcFileName version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void  somtcleanFilesFatal(int status);
SOMEXTERN void  SOMLINK somtcleanFilesFatalSL(int status);

Delete temporary files (if emitted file opened) and exit.

Note: somtcleanFilesFatal version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtemitTypes(FILE *fp, Mlist *mp, Stab *stab);
SOMEXTERN void SOMLINK somtemitTypesSL(FILE *fp, Mlist *mp, Stab *stab);

Note: somtemitTypes version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somterror(char *file, long lineno, char *fmt, ...);
SOMEXTERN void SOMLINK somterrorSL(char *file, long lineno, char *fmt, ...);

Note: somterror version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtfatal(char *file, long lineno, char *fmt, ...);
SOMEXTERN void SOMLINK somtfatalSL(char *file, long lineno, char *fmt, ...);

Note: somtfatal version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtinternal(char *file, long lineno, char *fmt, ...);
SOMEXTERN void SOMLINK somtinternalSL(char *file, long lineno, char *fmt, ...);

Note: somtinternal version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtmclose(void);
SOMEXTERN void SOMLINK somtmcloseSL(void);

Note: somtmclose version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtmsg(char *file, long lineno, char *fmt, ...);
SOMEXTERN void SOMLINK somtmsgSL(char *file, long lineno, char *fmt, ...);

Note: somtmsg version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtreadDescFile(Stab *stab, char *file);
SOMEXTERN void SOMLINK somtreadDescFileSL(Stab *stab, char *file);

Note: somtreadDescFile version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtsetDefaultDesc(Stab *stab);
SOMEXTERN void SOMLINK somtsetDefaultDescSL(Stab *stab);

Note: somtsetDefaultDesc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtsetEmitSignals(void(*cleanup) (int), void (*internal) (int));
SOMEXTERN void SOMLINK somtsetEmitSignalsSL(void(*cleanup) (int), void (*internal) (int));

Note: somtsetEmitSignals version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtsetTypeDefn(Entry *type, Entry *ep, char *ptrs, Entry *ret, BOOL array);
SOMEXTERN void SOMLINK somtsetTypeDefnSL(Entry *type, Entry *ep, char *ptrs, Entry *ret, BOOL array);

Note: somtsetTypeDefn version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtshowVersion(char *s, char *progname, char *sccsid);
SOMEXTERN void SOMLINK somtshowVersionSL(char *s, char *progname, char *sccsid);

Note: somtshowVersion version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtsmfree(void *first, ...);
SOMEXTERN void SOMLINK somtsmfreeSL(void *first, ...);

Note: somtsmfree version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtunsetEmitSignals(void);
SOMEXTERN void SOMLINK somtunsetEmitSignalsSL(void);

Note: somtunsetEmitSignals version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtwarn(char *file, long lineno, char *fmt, ...);
SOMEXTERN void SOMLINK somtwarnSL(char *file, long lineno, char *fmt, ...);

Note: somtwarn version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtuppercase(char *s, char *buf);
SOMEXTERN char * SOMLINK somtuppercaseSL(char *s, char *buf);

Convert <s> to upper case and return to <buf>.

Note: somtuppercase version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtlowercase(char *s, char *buf);
SOMEXTERN char * SOMLINK somtlowercase(char *s, char *buf)

Convert <s> to lower case and return to <buf>.

Note: somtlowercase version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtdbcsuppercase(char *s, char *buf);
SOMEXTERN char * SOMLINK somtdbcsuppercaseSL(char *s, char *buf);

Note: somtdbcsuppercase version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtdbcslowercase(char *s, char *buf);
SOMEXTERN char * SOMLINK somtdbcslowercaseSL(char *s, char *buf);

Note: somtdbcslowercase version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtresetEmitSignals(void);
SOMEXTERN void SOMLINK somtresetEmitSignalsSL(void);

Note: somtresetEmitSignals version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN size_t somtsizeofEntry(SOMTTypes type);
SOMEXTERN size_t SOMLINK somtsizeofEntrySL(SOMTTypes type);

Return size of Entry structure for <type> of entry;

Note: somtsizeofEntry version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

Mapping of type to Entry.u type and nameis following:

SOMEXTERN char * somtepname(Entry *ep, char *buf, BOOL suppressImpctxCheck);
SOMEXTERN char * SOMLINK somtepnameSL(Entry *ep, char *buf, BOOL suppressImpctxCheck);

Note: somtepname version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtgenSeqName(long n, Entry *base, char *buf, BOOL fullname);
SOMEXTERN char * SOMLINK somtgenSeqNameSL(long n, Entry *base, char *buf, BOOL fullname);

Note: somtgenSeqName version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtmrifatal(char *file, long lineno, int msgnum,...);
SOMEXTERN void SOMLINK somtmrifatalSL(char *file, long lineno, int msgnum,...);

Note: somtmrifatal version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtmriinternal(char *file, long lineno, int msgnum,...);
SOMEXTERN void SOMLINK somtmriinternalSL(char *file, long lineno, int msgnum,...);

Note: somtmriinternal version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtmrierror(char *file, long lineno, int msgnum,...);
SOMEXTERN void SOMLINK somtmrierrorSL(char *file, long lineno, int msgnum,...);

Note: somtmrierror version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtmrimsg(char *file, long lineno, int msgnum,...);
SOMEXTERN void SOMLINK somtmrimsgSL(char *file, long lineno, int msgnum,...);

Note: somtmrimsg version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtmriwarn(char *file, long lineno, int msgnum,...);
SOMEXTERN void SOMLINK somtmriwarnSL(char *file, long lineno, int msgnum,...);

Note: somtmriwarn version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtsetInternalMessages(char *too_long, char *cant_continue, char *segv, char *bus);
SOMEXTERN void SOMLINK somtsetInternalMessagesSL(char *too_long, char *cant_continue, char *segv, char *bus);

Note: somtsetInternalMessages version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN boolean somtisvoidSL(Entry *type, char *defn)
SOMEXTERN BOOL SOMLINK somtisvoidSL(Entry *type, char *defn)

Return TRUE if type->type is SOMTVoidBE it defn equal to “void”, “VOID”, “PMVOID”.

Note: somtisvoid version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN BOOL somtreturnsStruct(Entry *ep);
SOMEXTERN BOOL SOMLINK somtreturnsStructSL(Entry *ep);

Note: somtreturnsStruct version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN BOOL somtreturnsPtr(Entry *ep);
SOMEXTERN BOOL SOMLINK somtreturnsPtrSL(Entry *ep);

Note: somtreturnsPtr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtsimpleName(Entry *ep);
SOMEXTERN char * SOMLINK somtsimpleNameSL(Entry *ep);

Note: somtsimpleName version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtqualifyNames(Stab * stab, BOOL fully);
SOMEXTERN void SOMLINK somtqualifyNamesSL(Stab * stab, BOOL fully);

Note: somtqualifyNames version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Entry * somtfindBaseEpNonPtr(Entry *ep);
SOMEXTERN Entry * SOMLINK somtfindBaseEpNonPtrSL(Entry *ep);

Note: somtfindBaseEpNonPtr version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN BOOL somtprocessTraps(void);
SOMEXTERN BOOL SOMLINK somtprocessTrapsSL(void);

Note: somtprocessTraps version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Mlist * somtallocMlist(Entry * ep);
SOMEXTERN Mlist * SOMLINK somtallocMlistSL(Entry * ep);

Note: somtallocMlist version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Mlist * somtmlistend(Mlist * mp, char *name);
SOMEXTERN Mlist * SOMLINK somtmlistendSL(Mlist * mp, char *name);

Note: somtmlistend version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN BOOL somtisMutRef(Entry *ep, Mlist *seen, BOOL isself, long level);
SOMEXTERN BOOL SOMLINK somtisMutRefSL(Entry *ep, Mlist *seen, BOOL isself, long level);

Note: somtisMutRef version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Mlist * somtfreeMlist(Mlist *mp);
SOMEXTERN Mlist * SOMLINK somtfreeMlistSL(Mlist *mp);

Note: somtfreeMlist version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Mlist * somtdupMlist(Mlist *mp, Entry *ep);
SOMEXTERN Mlist * SOMLINK somtdupMlistSL(Mlist *mp, Entry *ep);

Note: somtdupMlist version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtfreeWorld();
SOMEXTERN void SOMLINK somtfreeWorldSL();

SOMEXTERN void somtinitMalloc(BOOL dynamic)
SOMEXTERN void SOMLINK somtinitMallocSL(BOOL dynamic)

Initialize memory allocation/free functions.

Note: <dynamic> flag ignored in somFree version.

Note: somtinitMalloc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtInitialiseEmitlib(void);
SOMEXTERN void SOMLINK somtInitialiseEmitlibSL(void);

Note: somtInitialiseEmitlib version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtInitialiseSmmeta(void);
SOMEXTERN void SOMLINK somtInitialiseSmmetaSL(void);

Note: somtInitialiseSmmeta version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtInitialiseCreatetc(void);
SOMEXTERN void SOMLINK somtInitialiseCreatetcSL(void);

Note: somtInitialiseCreatetc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtInitialiseSmtypes(void);
SOMEXTERN void SOMLINK somtInitialiseSmtypesSL(void);

Note: somtInitialiseSmtypes version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtInitialiseSomc(void);
SOMEXTERN void SOMLINK somtInitialiseSomcSL(void);

Note: somtInitialiseSomc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtInitialiseSmsmall(void);
SOMEXTERN void SOMLINK somtInitialiseSmsmallSL(void);

Note: somtInitialiseSmsmall version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtexit(SOMTExitBuf *ebuf, int status);
SOMEXTERN void SOMLINK somtexitSL(SOMTExitBuf *ebuf, int status);

Note: somtexit version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtdymain(char *file, Entry *cls, EmitFn emitfn, char *emitter, int first, char *version, Stab *stab);
SOMEXTERN void SOMLINK somtdymainSL(char *file, Entry *cls, EmitFn emitfn, char *emitter, int first, char *version, Stab *stab);

Note: somtdymain version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtaddHeader(char *file, FILE *fp, char *ext);
SOMEXTERN void SOMLINK somtaddHeaderSL(char *file, FILE *fp, char *ext);

Note: somtaddHeader version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Entry * somtnthArg(Entry * method, int n);
SOMEXTERN Entry * SOMLINK somtnthArgSL(Entry * method, int n);

Note: somtnthArg version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN FILE * somtemitModule(char *file, Entry *cls, char *ext);
SOMEXTERN FILE * SOMLINK somtemitModuleSL(char *file, Entry *cls, char *ext);

Same as somtopenEmitFile.

Note: somtemitModule version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Mlist * somtallocDataList(Entry *cls);
SOMEXTERN Mlist * SOMLINK somtallocDataListSL(Entry *cls);

Note: somtallocDataList version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Mlist * somtallocMethodList(Entry *cls, boolean all);
SOMEXTERN Mlist * SOMLINK somtallocMethodListSL(Entry *cls, boolean all);

Note: somtallocMethodList version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtclsfilename(Entry * cls);
SOMEXTERN char * SOMLINK somtclsfilenameSL(Entry * cls);

Note: somtclsfilename version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtclsname(Entry * cls);
SOMEXTERN char * SOMLINK somtclsnameSL(Entry * cls);

Return name of class <cls>.

Note: somclsname version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtfindMethodName(const char *bp, char *name);
SOMEXTERN char * SOMLINK somtfindMethodNameSL(const char *bp, char *name);

Note: somtfindMethodName version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtfullPrototype(char *buf, Entry * method, char *sep, int varargs);
SOMEXTERN char * SOMLINK somtfullPrototypeSL(char *buf, Entry * method, char *sep, int varargs);

Note: somtfullPrototype version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtfullTypedef(char *buf, Entry * cls, Entry * method);
SOMEXTERN char * SOMLINK somtfullTypedefSL(char *buf, Entry * cls, Entry * method);

Note: somtfullTypedef version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtgetNonRepeatedParent(Entry *cls, int i);
SOMEXTERN char * SOMLINK somtgetNonRepeatedParentSL(Entry *cls, int i);

Note: somtgetNonRepeatedParent version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtgetatt(Entry * ep, char *s);
SOMEXTERN char * SOMLINK somtgetattSL(Entry * ep, char *s);

SOMEXTERN char * somtgetdatt(Entry * ep, char *s);
SOMEXTERN char * SOMLINK somtgetdattSL(Entry * ep, char *s);

SOMEXTERN enum SOMTABIStyle  somtgetAbistyle( Entry * ep );
SOMEXTERN enum SOMTABIStyle  SOMLINK somtgetAbistyleSL( Entry * ep );

Return ABI style of Entry. At the current time returns always SOMTABIStyle_2

Note: somtgetABIStyle version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtimplicit(Entry *ep, boolean shortform, char *buf);
SOMEXTERN char * SOMLINK somtimplicitSL(Entry *ep, boolean shortform, char *buf);

Note: somtimplicit version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtimplicitArgs(Entry *ep);
SOMEXTERN char * SOMLINK somtimplicitArgsSL(Entry *ep);

Note: somtimplicitArgs version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtincludeOnceSL(Entry *cls, char *ext, char *buf);
SOMEXTERN char * SOMLINK somtincludeOnceSL(Entry *cls, char *ext, char *buf);

Return token to <buf> for once include checks using name of class <cls> and extension <ext> in form SOM_classname_ext.

Note: somtincludeOnce version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtpclsfilename(Entry *parent);
SOMEXTERN char * SOMLINK somtpclsfilenameSL(Entry *parent);

Note: somtpclsfilename version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtpclsname(Entry *parent);
SOMEXTERN char * SOMLINK somtpclsnameSL(Entry *parent);

Note: somtpclsname version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtprefixedPrototype(char *buf, Entry * method, char *sep, int varargs, char *prefix);
SOMEXTERN char * SOMLINK somtprefixedPrototypeSL(char *buf, Entry * method, char *sep, int varargs, char *prefix);

Note: somtprefixedPrototype version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtreplaceDataName(char *buf, Entry * data, char *replace);
SOMEXTERN char * SOMLINK somtreplaceDataNameSL(char *buf, Entry * data, char *replace);

Note: somtreplaceDataName version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtrmSelf(char *str);
SOMEXTERN char * SOMLINK somtrmSelfSL(char *str);

Note: somtrmSelf version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtshortArgList(char *buf, Entry * method, char *sep, boolean varargs, boolean addself);
SOMEXTERN char * SOMLINK somtshortArgListSL(char *buf, Entry * method, char *sep, boolean varargs, boolean addself);

Note: somtshortArgList version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int  somtimplicitMeta(Entry *cls);
SOMEXTERN int  SOMLINK somtimplicitMetaSL(Entry *cls);

Note: somtimplicitMeta version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int  somtlistAttribute(FILE * fp, int n, AttList * ap, char *s, boolean value, boolean breakLine, boolean firstComma);
SOMEXTERN int  SOMLINK somtlistAttributeSL(FILE * fp, int n, AttList * ap, char *s, boolean value, boolean breakLine, boolean firstComma);

Note: somtlistAttribute version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int  somtnewMethodsCount(Entry * cls, int meta, boolean procflg);
SOMEXTERN int  SOMLINK somtnewMethodsCountSL(Entry * cls, int meta, boolean procflg);

Note: somtnewMethodsCount version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somtprivateMethodsCount(Entry * cls, int meta);
SOMEXTERN int SOMLINK somtprivateMethodsCountSL(Entry * cls, int meta);

Note: somtprivateMethodsCount version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtaddHeader(char *file, FILE *fp, char *ext);
SOMEXTERN void SOMLINK somtaddHeaderSL(char *file, FILE *fp, char *ext);

Note: somtaddHeader version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtcleanFiles(int status);
SOMEXTERN void  SOMLINK somtcleanFilesSL(int status);

Delete temporary files and exit.

Note: somtcleanFiles version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtdeclareIdlVarargs(FILE *fp, Entry *ep);
SOMEXTERN void SOMLINK somtdeclareIdlVarargsSL(FILE *fp, Entry *ep);

Note: somtdeclareIdlVarargs version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtdymain(char *file, Entry *cls, EmitFn emitfn, char *emitter, int first, char *version, Stab *stab);
SOMEXTERN void SOMLINK somtdymainSL(char *file, Entry *cls, EmitFn emitfn, char *emitter, int first, char *version, Stab *stab);

Note: somtdymain version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtemitModuleTypes(FILE *fp, Entry *ep, Stab *stab);
SOMEXTERN void SOMLINK somtemitModuleTypesSL(FILE *fp, Entry *ep, Stab *stab);

Note: somtemitModuleTypes version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN long somtemitPassthru(FILE * fp, Entry * cls, char *name, int mode, char *att);
SOMEXTERN long SOMLINK somtemitPassthruSL(FILE * fp, Entry * cls, char *name, int mode, char *att);

Note: somtemitPassthru version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtfreeDataList(Mlist *mlist);
SOMEXTERN void SOMLINK somtfreeDataListSL(Mlist *mlist);

Note: somtfreeDataList version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtfreeMethodList(Mlist *mlist);
SOMEXTERN void SOMLINK somtfreeMethodListSL(Mlist *mlist);

Note: somtfreeMethodList version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtfullCommentSL(FILE * fp, char *fmt,...);
SOMEXTERN void SOMLINK somtfullCommentSL(FILE * fp, char *fmt,...);

Outout formatted string <fmt> to emitted file as comment using C-style comment via somtoidlComment function;

Note: somtfullComment version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somthandleDiskFull(FILE *fp);
SOMEXTERN void SOMLINK somthandleDiskFullSL(FILE *fp);

Note: somthandleDiskFull version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtinitialiseMeta(Entry * cls, Stab * stab, boolean meta, int imp);
SOMEXTERN void SOMLINK somtinitialiseMetaSL(Entry * cls, Stab * stab, boolean meta, int imp);

Note: somtinitialiseMeta version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtoidlComment(FILE * fp, int min, int max, char style, char *comment);
SOMEXTERN void  SOMLINK somtoidlCommentSL(FILE * fp, int min, int max, char style, char *comment);

Output oidl-<style> <comment> to file <fp> from colon <min> up to colon <max>.

Note: Seems IBM SOM ignores <max> value.

Style is one of following:

• '/' - each line started from "//#";
• '#' - each line started from “#”;
• 'c' - C-style comment started from '/*' and ended with '*/'. each line started from "*";
• 's' -each line started from "--";
• 'd' - each line started from “;”;
• '+' - each line started from "//";

Other values forced to 'c' style.

<comment> can contains at offset 0 0x01 signature indicating comment style. If style is zero the used style from comment position 1. Two first symbols of comment are ignored if style signature is present.

Note: somtoidlComment version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtscmsg(Entry *cls, Entry *ep, char *fmt, ...);
SOMEXTERN void SOMLINK somtscmsgSL(Entry *cls, Entry *ep, char *fmt, ...);

Note: somtscmsg version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtshortDefine(FILE *fp, Entry *ep, char *fmt, ...);
SOMEXTERN void SOMLINK somtshortDefineSL(FILE *fp, Entry *ep, char *fmt, ...);

Note: somtshortDefine version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void  somtuninitialiseMeta(Entry * cls);
SOMEXTERN void SOMLINK somtuninitialiseMetaSL(Entry * cls);

Note: somtuninitialiseMeta version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN FILE * somtobseleteHeaderFile(char *file, Entry *cls, char *ext, char *newext);
SOMEXTERN FILE * SOMLINK somtobseleteHeaderFileSL(char *file, Entry *cls, char *ext, char *newext);

Open emit file and write info about obsolete header. Return file pointer.

Note: somtoboleteHeaderFile version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtwidenType(Entry *ep, char *args, char *type);
SOMEXTERN char * SOMLINK somtwidenTypeSL(Entry *ep, char *args, char *type);

Note: somtwidenType version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtgenAttStubs(FILE *fp, Entry *cls, char *prefix, char *classprefix);
SOMEXTERN void SOMLINK somtgenAttStubsSL(FILE *fp, Entry *cls, char *prefix, char *classprefix);

Note: somtgenAttStubs version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtstrictidl(FILE *fp);
SOMEXTERN void SOMLINK somtstrictidlSL(FILE *fp);

Output definition of SOM_STRICT_IDL macro if somadd variable is TRUE;

Note: somtstrictidl version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtcreateTypeCodes (Stab *stab);
SOMEXTERN void SOMLINK somtcreateTypeCodesSL(Stab *stab);

Note: somtcreateTypeCodes version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN TypeCode * somtemitTcConstant(TypeCode t, FILE *f, char *name, TypeCode *alreadyDone);
SOMEXTERN TypeCode * SOMLINK somtemitTcConstantSL(TypeCode t, FILE *f, char *name, TypeCode *alreadyDone);

Note: somtemitTcConstant version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtemitPredefinedTcConstants (FILE *f);
SOMEXTERN void SOMLINK somtemitPredefinedTcConstantsSL(FILE *f);

Note: somtemitPredefinedTcConstants version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN Entry * somtAncestorClass(Entry *cls, char *name);
SOMEXTERN Entry * SOMLINK somtAncestorClassSL(Entry *cls, char *name);

Note: somtAncestorClass version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN short somttcAlignment (TypeCode t, Environment *ev);
SOMEXTERN short SOMLINK somttcAlignmentSL(TypeCode t, Environment *ev);

Note: somttcAlignment version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN long somttcSize (TypeCode t, Environment *ev);
SOMEXTERN long SOMLINK somttcSizeSL(TypeCode t, Environment *ev);

Note: somttcSize version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN TCKind somttcKind (TypeCode t, Environment *ev);
SOMEXTERN TCKind SOMLINK somttcKindSL(TypeCode t, Environment *ev);

Note: somttcKind version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN sequence(string) somttcSeqFromListString (string s);
SOMEXTERN sequence(string) SOMLINK somttcSeqFromListStringSL(string s);

Note: somttcSeqFromListString version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN _IDL_SEQUENCE_EntryPtr somtGetReintroducedMethods(Entry *cls);
SOMEXTERN _IDL_SEQUENCE_EntryPtr SOMLINK somtGetReintroducedMethodsSL(Entry *cls);

Note: somtGetReintroducedMethods version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

Note: somtallocBuf version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN char * somtuniqString(MemBuf *membuf, char *s);
SOMEXTERN char * SOMLINK somtuniqStringSL(MemBuf *membuf, char *s);

Check is string unique and return NULL if not, or string itself if unique;

Note: somtuniqString version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN long somtkeyword(KeytabEntry *keytab, char *kword, long keytabsize);
SOMEXTERN long SOMLINK somtkeywordSL(KeytabEntry *keytab, char *kword, long keytabsize);

Return token for keyword <kword> from keytaable <keytab> of <keytabsize> size.

Note: somtkeyword version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtaddEntry(Stab *stab, char *name, void *ep);
SOMEXTERN void * SOMLINK somtaddEntrySL(Stab *stab, char *name, void *ep);

Add entry <ep> with name <name> to symbol table <stab>. Buffer for entry allocated by function.

Note: somtaddEntry version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtgetEntry(Stab *stab, char *name);
SOMEXTERN void * SOMLINK somtgetEntrySL(Stab *stab, char *name);

Return pointer to entry structure with name equal to <name> from symbol table <stab>

Note: somtgetEntry version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtstabFirst(Stab *stab, Sep **sepp);
SOMEXTERN void * SOMLINK somtstabFirstSL(Stab *stab, Sep **sepp);

Return first entry from symbol table <stab> and, optionally, returns sep entry in <sepp>.

Note: somtstabFirst version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtstabNext(Stab *stab, Sep **sepp);
SOMEXTERN void * SOMLINK somtstabNextSL(Stab *stab, Sep **sepp);

Return next after last search entry from symbol table <stab> and, optionally, returns sep entry in <sepp>.

Note: somtstabNext version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtstabFirstName(Stab *stab, char *name, Sep **sepp);
SOMEXTERN void * SOMLINK somtstabFirstNameSL(Stab *stab, char *name, Sep **sepp);

Return first entry with <name> from symbol table <stab> and, optionally, returns sep entry in <sepp>.

Note: somtstabFirstName version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtstabNextName(Stab *stab, Sep **sepp);
SOMEXTERN void * SOMLINK somtstabNextNameSL(Stab *stab, Sep **sepp);

Return next after last search entry from symbol table <stab> and, optionally, returns sep entry in <sepp>.

Note: somtstabNextName version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtcreateMemBuf(MemBuf **membufp, size_t bufsize, long stabsize);
SOMEXTERN void SOMLINK somtcreateMemBufSL(MemBuf **membufp, size_t bufsize, long stabsize);

Note: somtcreateMemBuf version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtcreateStab(Stab *stab, long stabsize, long entrysize);
SOMEXTERN void SOMLINK somtcreateStabSL(Stab *stab, long stabsize, long entrysize);

Initialize symbol table structure <stab> using hash index size <stabsize> and entry size <entrysize>.

Note: somtcreateStab version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN int somticstrcmp(char *s, char *t)
SOMEXTERN int SOMLINK somticstrcmpSL(char *s, char *t);

Alias of C stricmp.

Note: somticstrcmp version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void * somtaddEntryBuf(Stab *stab, char *name, void *ep, void *buf, size_t len);
SOMEXTERN void * SOMLINK somtaddEntryBufSL(Stab *stab, char *name, void *ep, void *buf, size_t len);

Add entry <ep> with name <name> to symbol table <stab> to buffer <buf> with size <len>

Note: somtaddEntryBuf version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

SOMEXTERN void somtfreeStab(Stab *stab, BOOL freeEp);
SOMEXTERN void SOMLINK somtfreeStabSL(Stab *stab, BOOL freeEp);

Note: somtfreeStab version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.

readonly attribute boolean somtIsReadonly;

Whether the attribute is readonly.

readonly attribute SOMTEntryC somtAttribType;

The type of the attribute. This does not include pointer stars or array declarators. To get the “full” type, get each attribute declarator and get the somtType attribute.

SOMTDataEntryC somtGetFirstAttributeDeclarator();

The first attribute declarator for this attribute declaration.

SOMTDataEntryC somtGetNextAttributeDeclarator();

The next attribute declarator for this attribute declaration, relative to the previous call to this method or somtGetFirstAttributeDeclarator.

SOMTMethodEntryC somtGetFirstGetMethod();

The first get method for this attribute declaration.

SOMTMethodEntryC somtGetNextGetMethod();

The next get method for this attribute declaration, relative to the previous call to this method or somtGetFirstGetMethod.

SOMTMethodEntryC somtGetFirstSetMethod();

The first set method for this attribute declaration.

SOMTMethodEntryC somtGetNextSetMethod();

The next set method for this attribute declaration, relative to the previous call to this method or somtGetFirstSetMethod.

readonly attribute SOMTClassEntryC somtBaseClassDef;

Returns the class definition entry for the Base class named in this entry.

readonly attribute string somtSourceFileName;

Returns the name of file containing the definition of this class.

readonly attribute SOMTMetaClassEntryC somtMetaClassEntry;

Returns the entry for the meta class statement in class definition or NULL if there is no meta class statement.

Note: the SOM architecture requires that all classes have a meta class, however <SOMClass> is its own metaclass. Thus, any attempt to walk up the metaclass chain must terminate when it finds a class that is its own meta class, otherwise an infinite loop is possible.

readonly attribute SOMTModuleEntryC somtClassModule;

The module that contains this class, or NULL if there is not one.

readonly attribute long somtNewMethodCount;

Returns the number of new methods introduced in this class definition.

readonly attribute boolean somtLocalInclude;

Returns true if the header files associated with this class definition should be included using local search, eg, “name.h” instead of <name.h>

readonly attribute long somtPrivateMethodCount;

Returns number of new private methods in class.

readonly attribute long somtStaticMethodCount;

Returns number of new static methods in class.

readonly attribute long somtOverrideMethodCount;

Returns number of new override methods in class.

readonly attribute long somtProcMethodCount;

Returns number of procedure methods for class.

readonly attribute long somtVAMethodCount;

Returns number of VarArg methods for class.

readonly attribute long somtBaseCount;

Returns number of base classes for class.

readonly attribute long somtExternalDataCount;

Returns number of external (public or private) data members for class.

readonly attribute long somtPublicDataCount;

Returns number of public data members for class.

readonly attribute long somtPrivateDataCount;

Returns number of private data members for class.

readonly attribute SOMTClassEntryC somtMetaclassFor;

If this is a metaclass, the class for which it is a metaclass, else NULL.

readonly attribute boolean somtForwardRef;

Whether this is a forward reference or not.

SOMTBaseClassEntryC somtGetFirstBaseClass();

Returns the entry for the “left most” direct base class form for this class, if it has one and NULL otherwise.

Note: <SOMObject> does not have any base classes and therefore will terminate an attempt to walk up the base class chain.

SOMTBaseClassEntryC somtGetNextBaseClass();

Returns the entry for the next direct base class form of this class, if it has one and NULL otherwise. The direct base classes of a derived class are ordered from “left to right”.

string somtGetFirstReleaseName();

Returns the first name in the release order statement for this entry if it has one and NULL otherwise.

string somtGetNextReleaseName();

Returns the next name in the release order statement for this entry if it has one and NULL otherwise.

long somtGetReleaseNameList(in string buffer);

Puts all the release names in <buffer> in template output form, buffer must be large enough, no tests are made. The number of release names is returned.

SOMTPassthruEntryC somtGetFirstPassthru();

Returns the first passthru entry for this class definition if it has one and NULL otherwise.

SOMTPassthruEntryC somtGetNextPassthru();

Returns the next passthru entry for this class definition if it has one and NULL otherwise. The passthru entry will be returned in an order based on the appearence of passthru statements in the class definition.

SOMTDataEntryC somtGetFirstData();

Returns the first data entry for this class definition if it has one and NULL otherwise.

SOMTDataEntryC somtGetNextData();

Returns the next data entry for this class definition if it has one and NULL otherwise. The data entries will be returned in an order based on the appearence data member declarations in the class definition.

SOMTDataEntryC somtGetFirstStaticData();

Returns the first static data entry for this class definition if it has one and NULL otherwise. Static data is handled specialy in SOM so a different accessor method is provided.

SOMTDataEntryC somtGetNextStaticData();

Returns the next static data entry for this class definition if it has one and NULL otherwise. The data entries will be returned in an order based on the release order

SOMTMethodEntryC somtGetFirstMethod();

Returns the first method entry for this class definition if it has one and NULL otherwise. Method entries may be for new or overridden methods.

SOMTMethodEntryC somtGetNextMethod();

Returns the next method entry for this class definition if it has one and NULL otherwise. The method entries will be returned in an order based on the appearence method declarations in the class definition. Method entries may be for new or overridden methods.

SOMTMethodEntryC somtGetFirstInheritedMethod();

Returns the first inherited and not overridden method entry for this class definition if it has one and NULL otherwise.

SOMTMethodEntryC somtGetNextInheritedMethod();

Returns the next inherited and not overridden method entry for this class definition if it has one and NULL otherwise. The method entries will be returned in an unspecified, but constant order.

SOMTAttributeEntryC somtGetFirstAttribute();

SOMTAttributeEntryC somtGetNextAttribute();

SOMTStructEntryC somtGetFirstStruct();

SOMTStructEntryC somtGetNextStruct();

SOMTTypedefEntryC somtGetFirstTypedef();

SOMTTypedefEntryC somtGetNextTypedef();

SOMTUnionEntryC somtGetFirstUnion();

SOMTUnionEntryC somtGetNextUnion();

SOMTEnumEntryC somtGetFirstEnum();

SOMTEnumEntryC somtGetNextEnum();

SOMTConstEntryC somtGetFirstConstant();

SOMTConstEntryC somtGetNextConstant();

SOMTSequenceEntryC somtGetFirstSequence();

SOMTSequenceEntryC somtGetNextSequence();

SOMTEntryC somtGetFirstPubdef();

SOMTEntryC somtGetNextPubdef();

boolean somtFilterNew(in SOMTMethodEntryC entry);

Returns 1 if entry is new in the class.

boolean somtFilterOverridden(in SOMTMethodEntryC entry);

Returns 1 if entry is an overriding method of the class.

boolean somtFilterPrivOrPub(in SOMTCommonEntryC entry);

Returns TRUE if entry is Private or Public.

readonly attribute SOMTEntryC somtTypeObj;

The object representing the base type of the entry. This does not include pointer stars or array declarators.

readonly attribute string somtPtrs;

The string of stars associated with the entry's type. For example, an object of type “foo” would have somtPtrs = NULL, type “foo *” would have somtPtrs = “*”, type “foo **” would have somtPtrs = “**”, etc.

readonly attribute string somtArrayDimsString;

Array dimensions in string form.

unsigned long somtGetFirstArrayDimension();

The first array dimension, for items of type array. Zero indicates that the item is not an array.

unsigned long somtGetNextArrayDimension();

The next array dimension, for items of type array, relative to the previous call to this method or to somtGetFirstArrayDimension. Zero indicates no more dimensions.

readonly attribute string somtSourceText;

The un-parsed source text for this entry, with leading and trailing white space removed. For attribute/typedef declarators and for user-defined types, this attribute only provides the source text for the entry's name. For methods, arguments, and instance variables, however, this attribute provides the full definition.

readonly attribute string somtType;

The IDL type for this entry in string form. For methods this is the return type. For data or parameters this is the type of the data item or parameter. For user-defined types, this is the type specification. It is of the form: <typename><pointer-stars> <array-declarators>

readonly attribute somtVisibilityT somtVisibility;

The visibility of this entry. Note: the visibility of parameter entries will always be public, and methods can never be internal.

boolean somtIsArray(out long size);

Returns 1 (true) if the type involves an array. When the type involves an array then <size> is set to be the size of the array.

boolean somtIsPointer();

Returns 1 (true) if the type involves a pointer, and 0 (false) otherwise

readonly attribute SOMTEntryC somtConstTypeObj;

A pointer to an object representing the type of the const.

readonly attribute string somtConstType;

The type of the constant's value.

readonly attribute string somtConstStringVal;

The string value of the constant (unevaluated).

readonly attribute unsigned long somtConstNumVal;

The number value of the constant. This attribute is not valid if the value cannot be stored in an unsigned long (string, float, double, negative). The somtConstIsNegative attribute can be used to determine if the value is negative. The somtConstType attribute can be used to determine whether the value is a float or double.

readonly attribute long somtConstNumNegVal;

The number value of the constant, if negative.

readonly attribute boolean somtConstIsNegative;

Whether the constant's value is a negative integer and must be obtained using somtConstNumNegVal rather than somtConstNumVal.

readonly attribute string somtConstVal;

The string value of the constant (evaluated). The “get” method for this attribute returns a string whose ownership is transferred to the caller.

readonly attribute boolean somtIsSelfRef;

Whether a declarator of a struct is self-referential.

attribute SOMTTemplateOutputC somtTemplate;

The template is to provide template output and maintains a symbol table that provides a sort of global context for the emitter.

attribute FILE *somtTargetFile;

The target file is the one to which all emitter output is to be directed.

attribute SOMTClassEntryC somtTargetClass;

The target class is the class definition for which code is to be emitted.

attribute SOMTModuleEntryC somtTargetModule;

The target module is the module definition for which code is to be emitted.

attribute SOMTTargetTypeT somtTargetType;

The target type indicates what type of output file is being produced, public, private, or implementation. This allows the same emitter subclass to produce several different output files that generally differ only in how much of the class definition they cover. Eg, .csc, .sc, and .psc. This is attribute is for OIDL compatibility only.

attribute string somtEmitterName;

The short name of the emitter (the name used to invoke it via the SOM Compiler. Typically this is the file stem of the subclass of SOMTEmitC. This attribute should be set in the driver program that runs the emitter. It is used to filter passthrus so that only passthrus directed to a particular emitter are seen by it.

boolean somtGenerateSections();

Calls each of the section methods in order. The order is:

   somtEmitProlog
   when emitting a class:
   	  somtEmitClass
   	  somtEmitBase
   	  somtEmitMeta
   somtEmitConstant
   somtEmitTypedef
   somtEmitStruct
   somtEmitUnion
   somtEmitEnum
   when emitting a class:
      somtEmitAttribute
      somtEmitMethod
      somtEmitRelease
      somtEmitPassthru
      somtEmitData
   when emitting a module:
       somtEmitInterface
       somtEmitModule
   somtEmitEpilog

This method will need to be overridden by many emitters in order to rearange the order of the sections and to add or delete sections.

Note: repeating sections such as methods, data, and passthru, have a prolog and epilog method as well. The prolog method is called before the first sections is processed and the epilog method is called after the last section is processed.

FILE* somtOpenSymbolsFile(in string file, in string mode);

This method attempts to open the symbols file. If file doesn't exist then it will attempt to find it in the directories specified in the SMINCLUDE environment variable. If the file can be found a FILE * pointer is returned, otherwise NULL is returned.

void somtSetPredefinedSymbols();

Set predefined symbols that are used for such things as section names etc.

void somtFileSymbols();

Symbols that are common to the file. This includes the target class symbols, and the metaclass symbols, and special symbols like <timeStamp>. IE, all symbols that have a single definition.

void somtEmitProlog();

void somtEmitBaseIncludesProlog();

void somtEmitBaseIncludes(in SOMTBaseClassEntryC base);

void somtEmitBaseIncludesEpilog();

void somtEmitMetaInclude();

void somtEmitClass();

void somtEmitMeta();

void somtEmitBaseProlog();

void somtEmitBase(in SOMTBaseClassEntryC base);

void somtEmitBaseEpilog();

void somtEmitPassthruProlog();

void somtEmitPassthru(in SOMTPassthruEntryC entry);

void somtEmitPassthruEpilog();

void somtEmitRelease();

void somtEmitDataProlog();

void somtEmitData(in SOMTDataEntryC entry);

void somtEmitDataEpilog();

void somtEmitAttributeProlog();

void somtEmitAttribute(in SOMTAttributeEntryC att);

void somtEmitAttributeEpilog();

void somtEmitConstantProlog();

void somtEmitConstant(in SOMTConstEntryC con);

void somtEmitConstantEpilog();

void somtEmitTypedefProlog();

void somtEmitTypedef(in SOMTTypedefEntryC td);

void somtEmitTypedefEpilog();

void somtEmitStructProlog();

void somtEmitStruct(in SOMTStructEntryC struc);

void somtEmitStructEpilog();

void somtEmitUnionProlog();

void somtEmitUnion(in SOMTUnionEntryC un);

void somtEmitUnionEpilog();

void somtEmitEnumProlog();

void somtEmitEnum(in SOMTEnumEntryC en);

void somtEmitEnumEpilog();

void somtEmitInterfaceProlog();

void somtEmitInterface(in SOMTClassEntryC intfc);

void somtEmitInterfaceEpilog();

void somtEmitModuleProlog();

void somtEmitModule(in SOMTModuleEntryC mod);

void somtEmitModuleEpilog();

void somtEmitMethodsProlog();

void somtEmitMethods(in SOMTMethodEntryC method);

void somtEmitMethodsEpilog();

void somtEmitMethod(in SOMTMethodEntryC entry);

void somtEmitEpilog();

boolean somtScanBases(in string prolog, in string each, in string epilog);

boolean somtScanBaseIncludes(in string prolog, in string each, in string epilog);

boolean somtCheckVisibility(in SOMTMethodEntryC entry);

Return 1 (true) if <entry> should be visible in the current target file. This method is used by each of the following filter methods that are concerned with visibility.

The default rule for visibility is:

• only private methods are visible in private target files,
• only public methods are visibile in public target files,
• all methods are visibile in implementation or <somtAllE> target files.

boolean somtNew(in SOMTMethodEntryC entry);

Returns 1 (true) if <entry> is a method introduced by the target class and its visibility matches <somtTargetType> (somtImplementationE matches both private and public)

boolean somtImplemented(in SOMTMethodEntryC entry);

Returns 1 (true) if <entry> is a method introduced or overridden by the target class and its visibility matches <somtTargetType> (somtImplementationE matches both private and public)

boolean somtOverridden(in SOMTMethodEntryC entry);

Returns 1 (true) if <entry> is an overridding method of the target class and its visibility matches <somtTargetType> (somtImplementationE matches both private and public)

boolean somtInherited(in SOMTMethodEntryC entry);

Returns 1 (true) if <entry> is inherited by the target class and its visibility matches <somtTargetType> (somtImplementationE matches both private and public)

boolean somtAllVisible(in SOMTMethodEntryC entry);

Returns 1 (true) if <entry> is supported by the target class and its visibility matches <somtTargetType> (somtImplementationE matches both private and public)

boolean somtAll(in SOMTMethodEntryC entry);

Returns 1 (true) if <entry> is supported by the target class.

boolean somtNewNoProc(in SOMTEntryC entry);

Returns 1 (true) if somtNew does and the method IS NOT a direct call Procedure.

boolean somtPrivOrPub(in SOMTEntryC entry);

Returns 1 (true) if entry is Private or Public.

boolean somtNewProc(in SOMTEntryC entry);

Returns 1 (true) if somtNew does and the method IS a direct call Procedure.

boolean somtLink(in SOMTEntryC entry);

Returns 1 (true) if “nolink” is not set.

boolean somtVA(in SOMTEntryC entry);

Returns 1 (true) if entry is a VarArgs method.

boolean somtScanMethods(in string filter, in string prolog, in string each, in string epilog, in boolean forceProlog);

Will only call <each> on methods accepted by <filter>. If <forceProlog> is not true then the prolog and epilog emiters will be called only if there is at least one method that passes the filter.

boolean somtScanConstants(in string prolog, in string each, in string epilog);

boolean somtScanTypedefs(in string prolog, in string each, in string epilog);

boolean somtScanStructs(in string prolog, in string each, in string epilog);

boolean somtScanUnions(in string prolog, in string each, in string epilog);

boolean somtScanEnums(in string prolog, in string each, in string epilog);

boolean somtScanData(in string prolog, in string each, in string epilog);

boolean somtScanAttributes(in string prolog, in string each, in string epilog);

boolean somtScanInterfaces(in string prolog, in string each, in string epilog);

boolean somtScanModules(in string prolog, in string each, in string epilog);

boolean somtScanPassthru(in boolean before, in string prolog, in string each, in string epilog);

void somtEmitFullPassthru(in boolean before, in string language);

Emits each passthru section defined for the language and targetType, and the result of the somtIsBeforePassthru method is equal to the before parameter. (before = 1(true), or before = 0(false), i.e. after.)

boolean somtScanDataF(in string filter, in string prolog, in string each, in string epilog, in boolean forceProlog);

This method is like somtScanData but it also provides a paramater for a filter method.

boolean somtScanBasesF(in string filter, in string prolog, in string each, in string epilog, in boolean forceProlog);

This method is like somtScanBases but it also provides a paramater for a filter method.

string somtGetGlobalModifierValue(in string modifierName);

Returns the value of the specified global modifier.

Global modifiers are specified when the SOM Compiler is invoked, via the “-m” option. For example,

sc -m"foo=bar"  file.idl

specifies to the SOM Compiler and the emitters being run that the global modifier “foo” has the value “bar.”

Values of global modifiers are transient; they last only for the duration of the compile for which they were specified.

If a modifier is specified in the “sc” command with no value, as in

sc -mfoo file.idl

then the result of this method will be non-NULL.

If no such modifier is specified, then the result is NULL.

Older SOM compiler version uses “-a” option which is same as “-m” option.

SOMTEntryC somtGetFirstGlobalDefinition();

Returns the first type or constant definition that is not associated with any interface or module.

These global definitions must be surrounded by the somemittypes pragmas for them to be visible via this method. E.g.,

#pragma somemittypes on
....
#pragma someemittypes off

The list of global definitions returned by this method and the somtGetNextGlobalDefinition method may include entries for forward declarations as well as typedefs and constants.

Global structs and unions are also included in the list.

SOMTEntryC somtGetNextGlobalDefinition();

Returns the next type or constant definition that is not associated with any interface or module, relative to a previous call to somtGetFirstGlobalDefinition or somtGetNextGlobalDefinition.

attribute string somtEntryName;

The name associated with this entry. Eg, the name of the data item, the class, the method, the type, etc.

attribute SOMTTypes somtElementType;

Returns the type of this entry. This is not datatype, but entry type (method, class, passthru, etc.). The value is defined by SOMTTypes.

readonly attribute string somtElementTypeName;

String version of somtElementType.

readonly attribute string somtEntryComment;

Returns the comment associated with this entry, or NULL is this entry has no associated comment. Comments will have comment delimitors removed, but will retain newline characters as specified in the source file. (use smLookupComment)

readonly attribute unsigned long somtSourceLineNumber;

Returns the line number in the source file where this entry's syntactic form ended.

readonly attribute TypeCode somtTypeCode;

The typecode, if appropriate, or NULL.

readonly attribute boolean somtIsReference;

Whether the entry is just a reference to the real type (TRUE) rather than a declaration of it (FALSE).

readonly attribute string somtIDLScopedName;

The IDL scoped name of the entry (using double colon as delimiter).

readonly attribute string somtCScopedName;

The C scoped name of the entry (using underscore as delimiter).

string somtGetModifierValue(in string modifierName);

Returns the value of the named modifier if this entry has the named modifier and NULL otherwise. Note: if the modifier is present but does not have a value then a value of <'\1'> is returned.

boolean somtGetFirstModifier(inout string modifierName, inout string modifierValue);

Returns the first modifier associated with this entry. 1 (true) is returned if the entry has at least one modifier and 0 (false) otherwise.

boolean somtGetNextModifier(inout string modifierName, inout string modifierValue);

Returns the next modifier (with respect to the last call to <somtGetNextModifier> or <somtGetFirstModifier>) associated with this entry. 1 (true) is returned if the entry had another modifier and 0 (false) otherwise.

long somtFormatModifier(in string buffer, in string name, in string value);

Formats the indicated name/value pair into buffer. Buffer must be big enough to hold all the formatted pair, no checks are made. The number of characters added to buffer are returned (not including the trailing null character).

Note: value may be null

You will probably never call this method, it is provided so that you can override it to control the format returned in <somtGetModifierList>.

long somtGetModifierList(in string buffer);

The modifiers for this entry are placed in <buffer> in template list form (newline separated). Buffer must be big enough to hold all the modifiers, no checks are made. The number of modifiers is returned.

long somtSetSymbolsOnEntry(in SOMTEmitC emitter, in string prefix);

Places a number of symbol/value pairs in <t>. All the symbols will begin with <prefix>.

void somtSetEntryStruct(inout Entry es);

Sets the entry struct data member.

Note, when overridding this method, it is important to call the parent version of the method first and then do your processing.

SOMTEnumNameEntryC somtGetFirstEnumName();

SOMTEnumNameEntryC somtGetNextEnumName();

readonly attribute SOMTEnumEntryC somtEnumPtr;

A pointer to the enumerator.

readonly attribute unsigned long somtEnumVal;

The value of the enumeration.

readonly attribute string somtMetaFile;

Returns the name of the file containing the definition of the meta class named in this entry.

readonly attribute SOMTClassEntryC somtMetaClassDef;

Returns the class definition entry for the meta class named in this entry.

readonly attribute boolean somtIsVarargs;

Returns 1 (true) if this method definition has a variable length parameter list.

readonly attribute SOMTMethodEntryC somtOriginalMethod;

If this is an override method definition (<SOMTOverrideMethodE>) then this is the method definition entry that orginially introduced the method.

readonly attribute SOMTClassEntryC somtOriginalClass;

If this is an override method definition (<SOMTOverrideMethodE>) then this is the class definition entry that orginially introduced the method.

readonly attribute SOMTEntryC somtMethodGroup;

The group this method is defined in within a class definition.

readonly attribute boolean somtIsPrivateMethod;

Whether or not the method is private.

readonly attribute boolean somtIsOneway;

Whether or not the method is oneway.

readonly attribute short somtArgCount;

The number of arguments for the method.

SOMTParameterEntryC somtGetFirstParameter();

Returns the first formal parameter entry for this method if it has one and NULL otherwise. Note: the target object parameter is not included, therefore the first parameter is really the second parameter from a SOM runtime perspective.

SOMTParameterEntryC somtGetNextParameter();

Returns the next formal parameter entry for this method if it has one and NULL otherwise.

string somtGetIDLParamList(in string buffer);

Returns the formal parameter list (in IDL syntax) for this method. The parameter list is built in <buffer> and the address of <buffer> is returned.

Parameters are delimited with newlines.

The method receiver and any implicit method arguments are NOT included.

string somtGetShortCParamList(in string buffer, in string selfParm, in string varargsParm);

Returns the formal parameter list (in ANSI C function prototype form, with types) for this method. The parameter list is built in <buffer> and the address of <buffer> is returned.

Parameters are delimited with newlines.

If this method takes a variable number of arguments then the final parameter substring is replaced by <varargsParm>, unless <varargsParm> is NULL in which case the final parameter is removed.

If <selfParm> is not null then it is added as an initial parameter. (The <selfParm> string may actually contain multiple parameters, delimited by newline characters.)

The method receiver and any implicit method arguments are NOT included.

The types of the method parameters are given in C form (with pointer stars, where needed) rather than in the IDL form.

string somtGetFullCParamList(in string buffer, in string varargsParm);

Same as somtGetShortCParamList except that the method receiver and any implicit method arguments (Environment and Context) are included. The types of the method parameters are given in C form (with pointer stars, where needed) rather than in the IDL form.

string somtGetShortParamNameList(in string buffer, in string selfParm, in string varargsParm);

Returns the parameter list for this method in call form (without types). The argument list is built in <buffer> and the address of <buffer> is returned. Parameters are delimited with newlines.

If this method takes a variable number of arguments then the final parameter is replaced by <varargsParm>, unless <varargsParm> is NULL in which case the final parameter is removed.

If <selfParm> is not null then it is added as an initial parameter. (The <selfParm> string may actually contain multiple parameters, delimited by newline characters.)

The method receiver and any implicit method arguments are NOT included.

string somtGetFullParamNameList(in string buffer, in string varargsParm);

Same as somtGetParamNameList except that the method receiver and any implicit method arguments (Environment and Context) are included.

SOMTParameterEntryC somtGetNthParameter(in short n);

Returns the object representing the nth explicit method parameter.

SOMTStructEntryC somtGetFirstException();

The first exception this method raises.

SOMTStructEntryC somtGetNextException();

The next exception this method raises, relative to the previous call to this method or to somtGetFirstException.

readonly attribute string *somtContextArray;

An array of the context string-literals for the method.

readonly attribute string somtCReturnType;

The C datatype the method returns. This may not correspond to the IDL data type (in particular, pointer stars may be added).

readonly attribute SOMTModuleEntryC somtOuterModule;

The module enclosing this module, or NULL if there is none.

readonly attribute string somtModuleFile;

The name of the file in which the module appears.

SOMTStructEntryC somtGetFirstModuleStruct();

SOMTStructEntryC somtGetNextModuleStruct();

SOMTTypedefEntryC somtGetFirstModuleTypedef();

SOMTTypedefEntryC somtGetNextModuleTypedef();

SOMTUnionEntryC somtGetFirstModuleUnion();

SOMTUnionEntryC somtGetNextModuleUnion();

SOMTEnumEntryC somtGetFirstModuleEnum();

SOMTEnumEntryC somtGetNextModuleEnum();

SOMTConstEntryC somtGetFirstModuleConstant();

SOMTConstEntryC somtGetNextModuleConstant();

SOMTSequenceEntryC somtGetFirstModuleSequence();

SOMTSequenceEntryC somtGetNextModuleSequence();

SOMTClassEntryC somtGetFirstInterface();

SOMTClassEntryC somtGetNextInterface();

SOMTModuleEntryC somtGetFirstModule();

SOMTModuleEntryC somtGetNextModule();

SOMTEntryC somtGetFirstModuleDef();

SOMTEntryC somtGetNextModuleDef();

readonly attribute somtParameterDirectionT somtParameterDirection;

The direction for this parameter. (somtInE, somtOutE, or somtInOutE).

readonly attribute string somtIDLParameterDeclaration;

The IDL declaration of the parameter, including the type and name.

readonly attribute string somtCParameterDeclaration;

The declaration for the parameter within a C method procedure prototype. It includes the parameter's type and name. This may differ from the parameter's IDL declaration. In particular, pointer stars may be added.

readonly attribute string somtPascalParameterDeclaration;

The declaration for the parameter within a Pascal method procedure prototype. It includes the parameter's type and name. This may differ from the parameter's IDL declaration. In particular, pointer stars may be added.

readonly attribute string somtPassthruBody;

The source content text of this passthru entry without any modification. Newlines that were present in the source will still be present.

readonly attribute string somtPassthruLanguage;

Returns the name of the language for which this passthru entry is intended. Language names are always all upper case.

readonly attribute string somtPassthruTarget;

Returns the target for this passthru entry.

boolean somtIsBeforePassthru();

Returns 1 (true) if this passthru entry is to be put at the beginning of the file or 0 (false) if this passthru entry is to go later in the file.

readonly attribute long somtSeqLength;

The length of the sequence.

readonly attribute SOMTEntryC somtSeqType;

The type of the sequence.

readonly attribute long somtStringLength;

The length of the string.

SOMTTypedefEntryC somtGetFirstMember();

The first member of the struct.

SOMTTypedefEntryC somtGetNextMember();

The next member of the struct, relative to the previous call to this method or somtGetFirstMember.

readonly attribute SOMTClassEntryC somtStructClass;

The class in which the structure was defined.

readonly attribute boolean somtIsException;

Whether the structure is really an exception.

void somtAddSectionDefinitions(in string defString);

Add section definitions from <defString> buffer to Symbol table.

attribute somtCommentStyleT somtCommentStyle;

Set style of output comment. Supported styles are:

• somtDashesE: “–” at the start of each line
• somtCPPE: C++ style, "//" at the start of each line
• somtCSimpleE: simple C style, each line wrapped in /* and */
• somtCBlockE: block C style, block style, ie leading /* then a * on each line and then a final */
• somtPSimpleE: simple Pascal style, each line wrapped in (* and *)
• somtPBlockE: block Pascal style, block style, ie leading (* then a * on each line and then a final *)
• somtPBorlandE: block Borland Pascal style, block style, ie leading { and then a final }

attribute long somtLineLength;

Line length limit. At least on list item will be output.

attribute boolean somtCommentNewline;

Output comment block from new line flag.

boolean somtCheckSymbol(in string name);

Return TRUE id symbol <name> exists in Symbol Table.

string somtExpandSymbol(in string s, in string buf);

string somtGetSymbol(in string name);

Return symbol value for <name> from Symbol table.

void somto(in string tmplt);

Outputs a template, <tmplt>, after substitution for any symbols that occur in it. Five substitutions are supported: simple, list, comment, tab, and conditional.

Substitutable items in the template are bracketed with angle brackets. (Backslash can be used to escape an angle bracket.)

Simple substitutions just replace a symbol with its value. If the symbol has no value in this template object then the symbol is replaced error string but no error is raised.

List substitution assumes that the symbol has a value in output template list form. This is a newline separated string of values. The list substitution specification consists of four parts, a prefix, a symbol, a separator, and a list indicator. prefixes and separators can only be composed of blanks, comma, colons, and semi-colons. The list indicator is “…” (three periods). For example, the list substitution specification “<, name, …> has a prefix of ”, “, a symbol of “name” and a separator of ”, “. The prefix will be used whenever there is at least one item in the list and the separator will be used between any two list items. After the first items of a list is placed each additional item is evaluated to see if it would begin after the line length limit (set by _set_somtLineLength), if it would then a new line is begun and the value is placed directly under the first item. Comment substitution assumes that the symbol has a value in output template list form. A comment specification consists of a comment indicator followed by a symbol name. The comment indicator is ”–“. Eg, <-- classComment> is a valid comment substitution specification. The lines of the comment are output according to the current comment style (see <somtCommentStyle>) and aligned with the starting column of the comment specification. Tab substitution is specified by <@dd> where “dd” is a valid positive integer. Blanks will be inserted into the output stream if necessary to position the next character of output at the column indicated by “dd”.

Conditional substitution is specified by putting a question mark, ”?“, in column one of the template line. The line will not be output at all unless at least one valid, non-blank, symbol substitution occurs on the line.

Note: Due design error in IBM SOM 3.0 this method can't be fully replaced. You can do some preprocessing of <templ> and call parent method. This is due direct usage of FILE structure in somto method. This means you can't write to file using standard C file functions because FILE structure is a compiler depended. But you don't know which compiler was used for. Header files contains compiler-independed file functions (somtok*), but no any of this functions, except two ones, exported in SOM DLLs. So, if you want to fully replace this method then you need also replace lot of other methods and functions of Emitter Framework and SOM Compiler library. For IBM SOM 2.1 all seems to be ok, but you must use somtok* functions from SOMC.DLL, not standard C runtime for file operations.

void somtOutputComment(in string comment);

Outputs comment using comment style settings.

Note: Due design error in IBM SOM 3.0 this method can't be fully replaced. You can do some preprocessing of <comment> and call parent or somto method. This is due direct usage of FILE structure in somto method. This means you can't write to file using standard C file functions because FILE structure is a compiler depended. But you don't know which compiler was used for. Header files contains compiler-independed file functions (somtok*), but no any of this functions, except two ones, exported in SOM DLLs. So, if you want to fully replace this method then you need also replace lot of other methods and functions of Emitter Framework and SOM Compiler library. For IBM SOM 2.1 all seems to be ok, but you must use somtok* functions from SOMC.DLL, not standard C runtime for file operations.

void somtOutputSection(in string sectionName);

Same as somto method, but template read from Symbol table with key equal to sectionName. Uses somto method for actual output.

void somtReadSectionDefinitions(inout FILE fp);

This method reads sections from template file and stores them in Symbol table. fp is a value returned by somtOpenSymbolsFile method of SOMTEmitC class.

Note: Due design error in IBM SOM 3.0 this method can't be replaced. This is due unknown structure of FILE type. This means you can't read file using standard C file functions because FILE structure is a compiler depended. But you don't know which compiler was used for. Header files contains compiler-independed file functions (somtok*), but no any of this functions, except two ones, exported in SOM DLLs. So, if you want to fully replace this method then you need also replace lot of other methods and functions of Emitter Framework and SOM Compiler library. For IBM SOM 2.1 all seems to be ok, but you must use somtok* functions from SOMC.DLL, not standard C runtime for file operations.

void somtSetOutputFile(inout FILE fp);

Pass FILE structure to object to use for file I/O. fp is a value returned by somtOpenEmitFile or somtOpenEmitFileSL.

Note: FILE structure must be same as in other I/O methods and functions.

void somtSetSymbol(in string name, in string value);

Set symbol name in Symbol table to value. name and value must be allocated using SOMMaloc function. It will be deallocated using SOMFree on object destroying.

void somtSetSymbolCopyBoth(in string name, in string value);

Same as somtSetSymbol but name and value will be copied to internally allocated buffer.

void somtSetSymbolCopyName(in string name, in string value);

Same as somtSetSymbol but name will be copied to internally allocated buffer.

void somtSetSymbolCopyValue(in string name, in string value);

Same as somtSetSymbol but value will be copied to internally allocated buffer.

readonly attribute SOMTEntryC somtTypedefType;

The type of the typedef. This does not include pointer stars or array declarators. These must be obtained by examining each of the declarators.

SOMTCommonEntryC somtGetFirstDeclarator();

The first declarator for this typedef. Declarators of struct members will be instances of SOMTDataEntryC, while declarators of typedefs will be instances of SOMTUserDefinedTypeEntryC.

SOMTCommonEntryC somtGetNextDeclarator();

The next declarator for this typedef, relative to the previous call to this method or somtGetFirstDeclarator. Declarators of struct members will be instances of SOMTDataEntryC, while declarators of typedefs will be instances of SOMTUserDefinedTypeEntryC.

readonly attribute SOMTEntryC somtSwitchType;

The switch type of the union.

somtCaseEntry *somtGetFirstCaseEntry();

The first case for the union.

somtCaseEntry *somtGetNextCaseEntry();

The next case for the union, relative to the previous call to this method or to somtGetFirstCaseEntry.

readonly attribute SOMTTypedefEntryC somtOriginalTypedef;

The typedef that defined the user-defined type.

readonly attribute SOMTEntryC somtBaseTypeObj;

The object representing the base type (eg. short, float, unsigned long) of a user-defined type, skipping over any intermediate user-defined types.

interface SOMStringTableC : SOMObject

Объектами класса SOMStringTableC являются символьные таблицы, которые отображают строки на строки (ключ-значение, ассоциативные массивы). Любой экземпляр класса может хранить неограниченное число элементов. При увеличении количества строк время поиска строки увеличивается. В отличие от IBM SOM в данной реализации не используются хэш-таблицы.

attribute unsigned long somstTargetCapacity;

Емкость ассоциативного массива. Значение не влияет на работу и сохранено для совместимости. В IBM SOM данный атрибут определял размер хэш-таблицы. Данный атрибут должен выставляться до вызова любого из методов данного класса

readonly attribute unsigned long somstAssociationsCount;

Текущее число ассоциаций в массиве

short somstAssociate(in string key, in string value);

Устанавливает связь <key> и <value>. Возвращает 0, если связь не может быть установлена (<key> нулевой или недостаточно памяти); -1 - ассоциация успешна выполнена, но <key> уже имел значение до вызова метода, 1 - ассоциация успешно выполнена и <key> не существовал. Замечание: массив сохраняет ссылки на <key> и <value>, передаваемые в аргументах. Копия значений <key> и <value> не создается. При уничтожении объекта память, занимаемая <key> и <value> освобождается с помощью SOMFree, т.е. память под <key> и <value> должна быть выделена с помощью SOMMalloc и аналогичных функций. Замечание: При замене <value> при имеющемся <key> старое <value> заменаяется, память не освобождается

short somstAssociateCopyKey(in string key, in string value);

То же, что и <somstAssociate>, но массив содержит копии значений <key>. Значение <key> копируется в выделяемую с помощью SOMMalloc память.

short somstAssociateCopyValue(in string key, in string value);

То же, что и <somstAssociate>, но массив содержит копии значений <value>. Значение <value> копируется в выделяемую с помощью SOMMalloc память.

short somstAssociateCopyBoth(in string key, in string value);

То же, что и <somstAssociate>, но массив содержит копии значений <key> и <value>. Значения <key> и <value> копируются в выделяемую с помощью SOMMalloc память.

string somstGetAssociation(in string key);

Возвращается строка, ассоциированная с <key>, или NULL, если нет ассоциации. Массив продолжает хранить указатель на значение.

boolean somstClearAssociation(in string key);

The association for <key>, if any, is removed.1 is returned if <key> had an association, and 0 is returned if it did not.

string somstGetIthKey(in unsigned long i);

Возвращает ключевую часть <i>-й по счету ассоциации. Если нет ассоциации, то возвращает NULL. Порядок ассоциации в массиве не определен, но остается постоянным до следующей модификации.

string somstGetIthValue(in unsigned long i);

Возвращает значимую часть <i>-й по счету ассоциации. Если нет ассоциации, то возвращает NULL. Порядок ассоциации в массиве не определен, но остается постоянным до следующей модификации.

SOMEXTERN char * SOMLINK somtStrDup(char *str);

Allocate memory and duplicate string str

SOMEXTERN char * SOMLINK somtEntryTypeName(SOMTTypes type);

Return string representation of type of Entry structure except special case SOMTEmitterBeginE and SOMTEmitterEndE types.

SOMEXTERN void SOMLINK somtShowEntry(Entry * ep);

Output using somPrintf information about Entry structure.

SOMEXTERN char * SOMLINK somtStrCat(int count,...);

Concatenate count of strings.

SOMEXTERN char * SOMLINK somtMakeIncludeStr(boolean local, char *stem, char *suffix);

Produce include string for local (include ”“) or global (include <>) using file stem as file name and suffix as file extension.

SOMEXTERN char * SOMLINK somtNewSymbol(char *prefix, char *stem);

Allocate memory and produce string from prefix and stem.

SOMEXTERN char * SOMLINK somtGetFileStem(char *fullName);

Allocate memory and return file stem from file name.

SOMEXTERN SOMTEntryC * SOMLINK somtGetObjectWrapper(Entry * ep);

Return SOMT*EntryC object for ep Entry structure.

Mapping of Entry types to SOMT*EntryC classes:

Due switching from MSVC (IBM SOM 2.1) to VAC (IBM SOM 3.0) some problems was occur:

First problem is a calling convention. All non SOMLINK calls in IBM SOM 2.1 is a _cdecl calls. But under IBM SOM 3.0 all non SOMLINK calls is a Optlink calls. Read some info here: https://github.com/prokushev/SOM-Delphi-Wiki/blob/master/Known%20differences%20between%20SOM%202.1%20and%20SOM%203.0.md Goal of somFree SOM Compiler and Emitter Framework is to provide a possibility to use original IBM SOM emitters as from IBM SOM 2.1 as from IBM SOM 3.0. Another goal is a development of somFree emitters, which can be used on both IBM SOM 2.1 and IBM SOM 3.0 compilers.To achieve above goals somFree provides some solutions: 1. Automatic somc.dll calling convention switching. somFree SOMC.DLL provides automatic switching of IBM SOM 2.1 ABI and IBM SOM 3.0 ABI. Switching occurs on somtload call during loading of emitter. For IBM SOM 3.0 all emitter contains entry point emitSL, so, if loading was success, then somFree handles Optlink calling convention for all non SOMLINK calls. If no such entry (found only emit) then IBM SOM 2.1 ABI used. 2. Support both entry points (emitSL and emit) in emitters. somFree emitters automatically switches to IBM SOM 2.1 ABI on emit call and to IBM SOM 3.0 ABI on emitSL call.

1. Object Management Group, «C Language Mapping Specification 1.0,» [В Интернете]. Available: https://www.omg.org/spec/C/. [Дата обращения: 24 Август 2022].
2. IBM, OS/2 2.0 Technical Library. System Object Model Guide and Reference. First Edition., 1991. https://www.os2museum.com/files/docs/os220tl/os2-2.0-som-1991.pdf