====== Programmer's reference ======
===== SOM Runtime C library =====
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 =====
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.
==== somtfexists, somtfexistsSL function ====
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.
==== somtsearchFile, somtsearchFileSL function ====
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.
==== somttraverseParents, somttraverseParentsSL function ====
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.
==== somtloadSL function ====
SOMEXTERN EmitFn SOMLINK somtloadSL(char *fileName, char *functionName, void **modHandle);
Load emitter and return pointer to emit or emitSL function and return handle 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.
==== somtfindBaseEp, somtfindBaseEpSL function ====
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.
==== somtgetType, somtgetTypeSL function ====
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.
==== somtokfopen, somtokfopenSL function ====
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.
==== somtokrename, somtokrenameSL function ====
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.
==== somtopenEmitFile, somtopenEmitFileSL function ====
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.
==== somtisDbcs, somtisDbcsSL function ====
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.
==== somtremoveExt, somtremoveExtSL function ====
SOMEXTERN boolean somtremoveExt(char *name, char *ext, char *buf);
SOMEXTERN boolean SOMLINK somtremoveExt(char *name, char *ext, char *buf);
Remove extension from and return to
Note: somtremoveExt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtaddExt, somtaddExtSL function ====
SOMEXTERN char * somtaddExt(char *name, char *ext, char *buf);
SOMEXTERN char * SOMLINK somtaddExtSL(char *name, char *ext, char *buf);
Add extension to filestem and return result in
Note: somtaddExt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtarrayToPtr, somtarrayToPtrSL function ====
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.
==== somtattNormalise, somtattNormaliseSL function ====
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.
==== somtbasename, somtbasenameSL function ====
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.
==== somtctos, somtctosSL function ====
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.
==== somtdbcsPostincr, somtdbcsPostincrSL function ====
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.
==== somtdbcsPreincr, somtdbcsPreincrSL function ====
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.
==== somtdbcsStrchr, somtdbcsStrchrSL function ====
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.
==== somtdbcsStrrchr, somtdbcsStrrchrsL function ====
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.
==== somtdbcsStrstr, somtdbcsStrstrSL function ====
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.
==== somteptotype, somteptotypeSL function ====
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.
==== somtgetDesc, somtgetDescSL function ====
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.
==== somtgetVersion, somtgetVersionSL function ====
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.
==== somtgetgatt, somtgetgattSL function ====
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.
==== somtnextword, somtnextwordSL function ====
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.
==== somtnormaliseDesc, somtnormaliseDescSL function ====
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.
==== somtsatos, somtsatosSL function ====
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.
==== somtsearchFile, somtsearchFileSL function ====
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.
==== somtskipws, somtskipwsSL function ====
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.
==== somtstringFmt, somtstringFmtSL function ====
SOMEXTERN char * somtstringFmtSL(char *fmt, ...)
SOMEXTERN char * SOMLINK somtstringFmtSL(char *fmt, ...)
Allocate buffer for string, format it using and return pointer to buffer.
Note: somtstringFmt version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somttype, somttypeSL function ====
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.
==== somtuniqFmt, somtuniqFmtSL function ====
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.
==== somtargFlag, somtargFlagSL function ====
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.
==== somtattjoin, somtattjoinSL function ====
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.
==== somtdbcsLastChar, somtdbcsLastCharSL function ====
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.
==== somtdbcsScan, somtdbcsScanSL function ====
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.
==== somtdiskFull, somtdiskFullSL function ====
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.
==== somtfclose, somtfcloseSL function ====
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.
==== somtisparent, somtisparentSL function ====
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.
==== somtmget, somtmgetSL function ====
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.
==== somtmopen, somtmopenSL function ====
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.
==== somtmprintf, somtmprintfSL function ====
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.
==== somtokremove, somtokremoveSL function ====
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.
==== somtunload, somtunloadSL function ====
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.
==== somtwriteaccess, somtwriteaccessSL function ====
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.
==== somtsmalloc, somtsmallocSL function ====
SOMEXTERN void * somtsmalloc(size_t nbytes, BYTE clear);
SOMEXTERN void * SOMLINK somtsmallocSL(size_t nbytes, BYTE clear);
Allocate of memory and fill it by zeroes if flag is set.
Note: somtsmalloc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtaddGAtt, somtaddGAttSL function ====
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.
==== somtcalcFileName, somtcalcFileNameSL function ====
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.
==== somtcleanFilesFatal, somtcleanFilesFatalSL function ====
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.
==== somtemitTypes, somtemitTypesSL function ====
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.
==== somterror, somterrorSL function ====
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.
==== somtfatal, somtfatalSL function ====
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.
==== somtinternal, somtinternalSL function ====
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.
==== somtmclose, somtmcloseSL function ====
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.
==== somtmsg, somtmsgSL function ====
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.
==== somtreadDescFile, somtreadDescFileSL function ====
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.
==== somtsetDefaultDesc, somtsetDefaultDescSL function ====
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.
==== somtsetEmitSignals, somtsetEmitSignalsSL function ====
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.
==== somtsetTypeDefn, somtsetTypeDefnSL function ====
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.
==== somtshowVersion, somtshowVersionSL function ====
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.
==== somtsmfree, somtsmfreeSL function ====
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.
==== somtunsetEmitSignals, somtunsetEmitSignalsSL function ====
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.
==== somtwarn, somtwarnSL function ====
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.
==== somtuppercase, somtuppercaseSL function ====
SOMEXTERN char * somtuppercase(char *s, char *buf);
SOMEXTERN char * SOMLINK somtuppercaseSL(char *s, char *buf);
Convert to upper case and return to .
Note: somtuppercase version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtlowercase, somtlowercaseSL function ====
SOMEXTERN char * somtlowercase(char *s, char *buf);
SOMEXTERN char * SOMLINK somtlowercase(char *s, char *buf)
Convert to lower case and return to .
Note: somtlowercase version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtdbcsuppercase, somtdbcsuppercaseSL function ====
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.
==== somtdbcslowercase, somtdbcslowercaseSL function ====
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.
==== somtresetEmitSignals, somtresetEmitSignalsSL function ====
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.
==== somtsizeofEntry, somtsizeofEntrySL function ====
SOMEXTERN size_t somtsizeofEntry(SOMTTypes type);
SOMEXTERN size_t SOMLINK somtsizeofEntrySL(SOMTTypes type);
Return size of Entry structure for 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:
^ Entry type ^ union struct ^ union name ^
| SOMTClassE | Class | c |
| SOMTMetaE | Meta | mt |
| SOMTBaseE | Parent | p |
| SOMTPassthruE | Passthru | pt |
| SOMTNewMethodE | Method_OR_Data | m |
| SOMTOverrideMethodE | Method_OR_Data | m |
| SOMTOverriddenMethodE | Method_OR_Data | m |
| SOMTDataE | Method_OR_Data | m |
| SOMTArgumentE | Method_OR_Data | m |
| SOMTTypedefBE | Method_OR_Data | m |
| SOMTVoidPtrBE | Method_OR_Data | m |
| SOMTStructE | Struct | struc |
| SOMTTyDclE | Typedef | ty |
| SOMTTypedefE | Typedef | ty |
| SOMTUnionE | Union | un |
| SOMTUnionSE | Union | un |
| SOMTEnumE | Enumerator | enumerator |
| SOMTConstE | Const | con |
| SOMTAttE | Att | att |
| SOMTSequenceE | Sequence | seq |
| SOMTSequenceTDE | Sequence | seq |
| SOMTStringE | String | str |
| SOMTEnumBE | EnumName | enumN |
| SOMTModuleE | Module | mod |
==== somtepname, somtepnameSL function ====
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.
==== somtgenSeqName, somtgenSeqNameSL function ====
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.
==== somtmrifatal, somtmrifatalSL function ====
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.
==== somtmriinternal, somtmriinternalSL function ====
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.
==== somtmrierror, somtmrierrorSL function ====
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.
==== somtmrimsg, somtmrimsgSL function ====
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.
==== somtmriwarn, somtmriwarnSL function ====
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.
==== somtsetInternalMessages, somtsetInternalMessagesSL function ====
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.
==== somtisvoid, somtisvoidSL function ====
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.
==== somtreturnsStruct, somtreturnsStructSL function ====
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.
==== somtreturnsPtr, somtreturnsPtrSL function ====
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.
==== somtsimpleName, somtsimpleNameSL function ====
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.
==== somtqualifyNames, somtqualifyNamesSL function ====
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.
==== somtfindBaseEpNonPtr, somtfindBaseEpNonPtrSL function ====
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.
==== somtprocessTraps, somtprocessTrapsSL function ====
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.
==== somtallocMlist, somtallocMlistSL function ====
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.
==== somtmlistend, somtmlistendSL function ====
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.
==== somtisMutRef, somtisMutRefSL function ====
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.
==== somtfreeMlist, somtfreeMlistSL function ====
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.
==== somtdupMlist, somtdupMlistSL function ====
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.
==== somtfreeWorld, somtfreeWorldSL function ====
SOMEXTERN void somtfreeWorld();
SOMEXTERN void SOMLINK somtfreeWorldSL();
==== somtinitMalloc, somtinitMallocSL function ====
SOMEXTERN void somtinitMalloc(BOOL dynamic)
SOMEXTERN void SOMLINK somtinitMallocSL(BOOL dynamic)
Initialize memory allocation/free functions.
Note: flag ignored in somFree version.
Note: somtinitMalloc version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtInitialiseEmitlib. somtInitialiseEmitlibSL function ====
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.
==== somtInitialiseSmmeta, somtInitialiseSmmetaSL function ====
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.
==== somtInitialiseCreatetc, somtInitialiseCreatetcSL function ====
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.
==== somtInitialiseSmtypes, somtInitialiseSmtypesSL function ====
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.
==== somtInitialiseSomc, somtInitialiseSomcSL function ====
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.
==== somtInitialiseSmsmall, somtInitialiseSmsmallSL function ====
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.
==== somtattMap, somtattMapSL function ====
==== somtexit, somtexitSL function ====
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.
==== somtdymain, somtdymainSL function ====
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.
==== somtaddHeader, somtaddHeaderSL function ====
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.
==== somtnthArg, somtnthArgSL function ====
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.
==== somtemitModule, somtemitModuleSL function ====
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.
==== somtallocDataList, somtallocDataListSL function ====
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.
==== somtallocMethodList, somtallocMethodListSL function ====
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.
==== somtclsfilename, somtclsfilenameSL function ====
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.
==== somtclsname, somtclsnameSL function ====
SOMEXTERN char * somtclsname(Entry * cls);
SOMEXTERN char * SOMLINK somtclsnameSL(Entry * cls);
Return name of class .
Note: somclsname version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtfindMethodName, somtfindMethodNameSL function ====
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.
==== somtfullPrototype, somtfullPrototypeSL function ====
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.
==== somtfullTypedef, somtfullTypedefSL function ====
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.
==== somtgetNonRepeatedParent, somtgetNonRepeatedParentSL function ====
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.
==== somtgetatt, somtgetattSL function ====
SOMEXTERN char * somtgetatt(Entry * ep, char *s);
SOMEXTERN char * SOMLINK somtgetattSL(Entry * ep, char *s);
==== somtgetdatt, somtgetdattSL function ====
SOMEXTERN char * somtgetdatt(Entry * ep, char *s);
SOMEXTERN char * SOMLINK somtgetdattSL(Entry * ep, char *s);
==== somtgetAbistyle, somtgetAbistyleSL function ====
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.
==== somtimplicit, somtimplicitSL function ====
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.
==== somtimplicitArgs, somtimplicitArgsSL function ====
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.
==== somtincludeOnce, somtincludeOnceSL function ====
SOMEXTERN char * somtincludeOnceSL(Entry *cls, char *ext, char *buf);
SOMEXTERN char * SOMLINK somtincludeOnceSL(Entry *cls, char *ext, char *buf);
Return token to for once include checks using name of class and extension in form SOM_classname_ext.
Note: somtincludeOnce version uses default compiler calling convention. For IBM SOM 3.0 for NT it is Optlink.
==== somtpclsfilename, somtpclsfilenameSL function ====
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.
==== somtpclsname, somtpclsnameSL function ====
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.
==== somtprefixedPrototype, somtprefixedPrototypeSL function ====
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.
==== somtreplaceDataName, somtreplaceDataNameSL function ====
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.
==== somtrmSelf, somtrmSelfSL function ====
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.
==== somtshortArgList, somtshortArgListSL function ====
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.
==== somtimplicitMeta, somtimplicitMetaSL function ====
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.
==== somtlistAttribute, somtlistAttributeSL function ====
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.
==== somtnewMethodsCount, somtnewMethodsCountSL function ====
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.
==== somtprivateMethodsCount, somtprivateMethodsCountSL function ====
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.
==== somtaddHeader, somtaddHeaderSL function ====
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.
==== somtcleanFiles, somtcleanFilesSL function ====
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.
==== somtdeclareIdlVarargs, somtdeclareIdlVarargsSL function ====
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.
==== somtdymain. somtdymainSL function ====
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.
==== somtemitModuleTypes, somtemitModuleTypesSL function ====
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.
==== somtemitPassthru, somtemitPassthruSL function ====
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.
==== somtfreeDataList, somtfreeDataListSL function ====
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.
==== somtfreeMethodList, somtfreeMethodListSL function ====
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.
==== somtfullComment, somtfullCommentSL function ====
SOMEXTERN void somtfullCommentSL(FILE * fp, char *fmt,...);
SOMEXTERN void SOMLINK somtfullCommentSL(FILE * fp, char *fmt,...);
Outout formatted string 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.
==== somthandleDiskFull, somthandleDiskFullSL function ====
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.
==== somtinitialiseMeta, somtinitialiseMetaSL function ====
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.
==== somtoidlComment, somtoidlCommentSL function ====
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-