|
|
/* DEF file syntax - yacc */%token T_FALIAS%token T_KCLASS%token T_KNAME%token T_KLIBRARY%token T_KBASE%token T_KDEVICE%token T_KPHYSICAL%token T_KVIRTUAL%token T_ID%token T_NUMBER%token T_KDESCRIPTION%token T_KHEAPSIZE%token T_KSTACKSIZE%token T_KMAXVAL%token T_KCODE%token T_KCONSTANT%token <_wd> T_FDISCARDABLE T_FNONDISCARDABLE%token T_FEXEC%token <_wd> T_FFIXED%token <_wd> T_FMOVABLE%token T_FSWAPPABLE%token T_FSHARED%token T_FMIXED%token <_wd> T_FNONSHARED%token <_wd> T_FPRELOAD%token <_wd> T_FINVALID%token <_wd> T_FLOADONCALL%token <_wd> T_FRESIDENT%token <_wd> T_FPERM%token <_wd> T_FCONTIG%token <_wd> T_FDYNAMIC%token T_FNONPERM%token T_KDATA%token <_wd> T_FNONE%token <_wd> T_FSINGLE%token <_wd> T_FMULTIPLE%token T_KSEGMENTS%token T_KOBJECTS%token T_KSECTIONS%token T_KSTUB%token T_KEXPORTS%token T_KEXETYPE%token T_KSUBSYSTEM%token T_FDOS%token T_FOS2%token T_FUNKNOWN%token T_FWINDOWS%token T_FDEV386%token T_FMACINTOSH%token T_FWINDOWSNT%token T_FWINDOWSCHAR%token T_FPOSIX%token T_FNT%token T_FUNIX%token T_KIMPORTS%token <_wd> T_KNODATA%token T_KOLD%token T_KCONFORM%token T_KNONCONFORM%token T_KEXPANDDOWN T_KNOEXPANDDOWN%token T_EQ%token T_AT%token T_KRESIDENTNAME%token T_KNONAME%token T_STRING%token T_DOT%token T_COLON%token T_COMA%token T_ERROR%token T_FHUGE T_FIOPL T_FNOIOPL%token T_PROTMODE%token <_wd> T_FEXECREAD T_FRDWR%token T_FRDONLY%token T_FINITGLOB T_FINITINST T_FTERMINST%token T_FWINAPI T_FWINCOMPAT T_FNOTWINCOMPAT T_FPRIVATE T_FNEWFILES%token T_REALMODE%token T_FUNCTIONS%token T_APPLOADER%token T_OVL%token T_KVERSION
%{ /* SCCSID = %W% %E% */#include <minlit.h>#include <bndtrn.h>#include <bndrel.h>#include <lnkio.h>#include <newexe.h>#if EXE386#include <exe386.h>#endif#include <lnkmsg.h>#include <extern.h>#include <string.h>#include <impexp.h>
#define YYS_WD(x) (x)._wd /* Access macro */#define YYS_BP(x) (x)._bp /* Access macro */#define INCLUDE_DIR 0xffff /* Include directive for the lexer */#define MAX_NEST 7#define IO_BUF_SIZE 512
/* * FUNCTION PROTOTYPES */
LOCAL int NEAR lookup(void);LOCAL int NEAR yylex(void);LOCAL void NEAR yyerror(char *str);LOCAL void NEAR ProcNamTab(long lfa,unsigned short cb,unsigned short fres);LOCAL void NEAR NewProc(char *szName);#if NOT EXE386LOCAL void NEAR SetExpOrds(void);#endifLOCAL void NEAR NewDescription(unsigned char *sbDesc);LOCAL APROPIMPPTR NEAR GetImport(unsigned char *sb);#if EXE386LOCAL void NEAR NewModule(unsigned char *sbModnam, unsigned char *defaultExt);LOCAL void NEAR DefaultModule(unsigned char *defaultExt);#elseLOCAL void NEAR NewModule(unsigned char *sbModnam);LOCAL void NEAR DefaultModule(void);#endif#if AUTOVMBYTE FAR * NEAR FetchSym1(RBTYPE rb, WORD Dirty);#define FETCHSYM FetchSym1#define PROPSYMLOOKUP EnterName#else#define FETCHSYM FetchSym#define PROPSYMLOOKUP EnterName#endif
int yylineno = -1; /* Line number */LOCAL FTYPE fFileNameExpected;LOCAL FTYPE fMixed;LOCAL FTYPE fNoExeVer;LOCAL FTYPE fHeapSize;LOCAL BYTE *sbOldver; /* Old version of the .EXE */LOCAL FTYPE vfAutodata;LOCAL FTYPE vfShrattr;LOCAL BYTE cDigits;#if EXE386LOCAL DWORD offmask; /* Seg flag bits to turn off */LOCAL BYTE fUserVersion = 0;LOCAL WORD expOtherFlags = 0;LOCAL BYTE moduleEXE[] = "\007A:\\.exe";LOCAL BYTE moduleDLL[] = "\007A:\\.dll";#elseLOCAL WORD offmask; /* Seg flag bits to turn off */#endif#if OVERLAYSLOCAL WORD iOvl = NOTIOVL; // Overlay assigned to functions#endifLOCAL char *szSegName; // Segment assigned to functionsLOCAL WORD nameFlags; /* Flags associated with exported name */LOCAL BSTYPE includeDisp[MAX_NEST]; // Include file stackLOCAL short curLevel; // Current include nesting level // Zero means main .DEF fileLOCAL char *keywds[] = /* Keyword array */ { "ALIAS", (char *) T_FALIAS, "APPLOADER", (char *) T_APPLOADER, "BASE", (char *) T_KBASE, "CLASS", (char *) T_KCLASS, "CODE", (char *) T_KCODE, "CONFORMING", (char *) T_KCONFORM, "CONSTANT", (char *) T_KCONSTANT, "CONTIGUOUS", (char *) T_FCONTIG, "DATA", (char *) T_KDATA, "DESCRIPTION", (char *) T_KDESCRIPTION, "DEV386", (char *) T_FDEV386, "DEVICE", (char *) T_KDEVICE, "DISCARDABLE", (char *) T_FDISCARDABLE, "DOS", (char *) T_FDOS, "DYNAMIC", (char *) T_FDYNAMIC, "EXECUTE-ONLY", (char *) T_FEXEC, "EXECUTEONLY", (char *) T_FEXEC, "EXECUTEREAD", (char *) T_FEXECREAD, "EXETYPE", (char *) T_KEXETYPE, "EXPANDDOWN", (char *) T_KEXPANDDOWN, "EXPORTS", (char *) T_KEXPORTS, "FIXED", (char *) T_FFIXED, "FUNCTIONS", (char *) T_FUNCTIONS, "HEAPSIZE", (char *) T_KHEAPSIZE, "HUGE", (char *) T_FHUGE, "IMPORTS", (char *) T_KIMPORTS, "IMPURE", (char *) T_FNONSHARED, "INCLUDE", (char *) INCLUDE_DIR, "INITGLOBAL", (char *) T_FINITGLOB, "INITINSTANCE", (char *) T_FINITINST, "INVALID", (char *) T_FINVALID, "IOPL", (char *) T_FIOPL, "LIBRARY", (char *) T_KLIBRARY, "LOADONCALL", (char *) T_FLOADONCALL, "LONGNAMES", (char *) T_FNEWFILES, "MACINTOSH", (char *) T_FMACINTOSH, "MAXVAL", (char *) T_KMAXVAL, "MIXED1632", (char *) T_FMIXED, "MOVABLE", (char *) T_FMOVABLE, "MOVEABLE", (char *) T_FMOVABLE, "MULTIPLE", (char *) T_FMULTIPLE, "NAME", (char *) T_KNAME, "NEWFILES", (char *) T_FNEWFILES, "NODATA", (char *) T_KNODATA, "NOEXPANDDOWN", (char *) T_KNOEXPANDDOWN, "NOIOPL", (char *) T_FNOIOPL, "NONAME", (char *) T_KNONAME, "NONCONFORMING", (char *) T_KNONCONFORM, "NONDISCARDABLE", (char *) T_FNONDISCARDABLE, "NONE", (char *) T_FNONE, "NONPERMANENT", (char *) T_FNONPERM, "NONSHARED", (char *) T_FNONSHARED, "NOTWINDOWCOMPAT", (char *) T_FNOTWINCOMPAT, "NT", (char *) T_FNT, "OBJECTS", (char *) T_KOBJECTS, "OLD", (char *) T_KOLD, "OS2", (char *) T_FOS2, "OVERLAY", (char *) T_OVL, "OVL", (char *) T_OVL, "PERMANENT", (char *) T_FPERM, "PHYSICAL", (char *) T_KPHYSICAL, "POSIX", (char *) T_FPOSIX, "PRELOAD", (char *) T_FPRELOAD, "PRIVATE", (char *) T_FPRIVATE, "PRIVATELIB", (char *) T_FPRIVATE, "PROTMODE", (char *) T_PROTMODE, "PURE", (char *) T_FSHARED, "READONLY", (char *) T_FRDONLY, "READWRITE", (char *) T_FRDWR, "REALMODE", (char *) T_REALMODE, "RESIDENT", (char *) T_FRESIDENT, "RESIDENTNAME", (char *) T_KRESIDENTNAME, "SECTIONS", (char *) T_KSECTIONS, "SEGMENTS", (char *) T_KSEGMENTS, "SHARED", (char *) T_FSHARED, "SINGLE", (char *) T_FSINGLE, "STACKSIZE", (char *) T_KSTACKSIZE, "STUB", (char *) T_KSTUB, "SUBSYSTEM", (char *) T_KSUBSYSTEM, "SWAPPABLE", (char *) T_FSWAPPABLE, "TERMINSTANCE", (char *) T_FTERMINST, "UNIX", (char *) T_FUNIX, "UNKNOWN", (char *) T_FUNKNOWN, "VERSION", (char *) T_KVERSION, "VIRTUAL", (char *) T_KVIRTUAL, "WINDOWAPI", (char *) T_FWINAPI, "WINDOWCOMPAT", (char *) T_FWINCOMPAT, "WINDOWS", (char *) T_FWINDOWS, "WINDOWSCHAR", (char *) T_FWINDOWSCHAR, "WINDOWSNT", (char *) T_FWINDOWSNT, NULL };%}
%union{#if EXE386 DWORD _wd;#else WORD _wd;#endif BYTE *_bp;}
%type <_bp> T_ID%type <_bp> T_STRING%type <_bp> Idname%type <_bp> Internal%type <_bp> Class%type <_wd> T_NUMBER%type <_wd> Codeflaglist%type <_wd> Codeflag%type <_wd> Dataflaglist%type <_wd> Dataflag%type <_wd> Exportflags%type <_wd> Exportopts%type <_wd> Nodata%type <_wd> Segflags%type <_wd> Segflag%type <_wd> Segflaglist%type <_wd> Baseflag%type <_wd> Dataonly%type <_wd> Codeonly%type <_wd> MajorVer%type <_wd> MinorVer%type <_wd> Overlay%type <_wd> ImportFlags
%%
Definitions : Name Options | Name | {#if EXE386 DefaultModule(moduleEXE);#else DefaultModule();#endif } Options ;
Name : T_KNAME Idname Apptype OtherFlags VirtBase {#if EXE386 NewModule($2, moduleEXE);#else NewModule($2);#endif } | T_KNAME Apptype OtherFlags VirtBase {#if EXE386 DefaultModule(moduleEXE);#else DefaultModule();#endif } | T_KLIBRARY Idname Libflags OtherFlags VirtBase {#if EXE386 SetDLL(vFlags); NewModule($2, moduleDLL);#else vFlags = NENOTP | (vFlags & ~NEINST) | NESOLO; dfData |= NSSHARED; NewModule($2);#endif } | T_KLIBRARY Libflags OtherFlags VirtBase {#if EXE386 SetDLL(vFlags); DefaultModule(moduleDLL);#else vFlags = NENOTP | (vFlags & ~NEINST) | NESOLO; dfData |= NSSHARED; DefaultModule();#endif } | T_KPHYSICAL T_KDEVICE Idname Libflags VirtBase {#if EXE386 SetDLL(vFlags); NewModule($3, moduleDLL);#endif } | T_KPHYSICAL T_KDEVICE Libflags VirtBase {#if EXE386 SetDLL(vFlags); DefaultModule(moduleDLL);#endif } | T_KVIRTUAL T_KDEVICE Idname Libflags VirtBase {#if EXE386 SetDLL(vFlags); NewModule($3, moduleDLL);#endif } | T_KVIRTUAL T_KDEVICE Libflags VirtBase {#if EXE386 SetDLL(vFlags); DefaultModule(moduleDLL);#endif } ;
Libflags : T_FINITGLOB {#if EXE386 dllFlags &= ~E32_PROCINIT;#else vFlags &= ~NEPPLI;#endif } | T_FPRIVATE { vFlags |= NEPRIVLIB; } | InstanceFlags | ;
InstanceFlags : InstanceFlags InstanceFlag | InstanceFlag ;
InstanceFlag : T_FINITINST {#if EXE386 SetINSTINIT(dllFlags);#else vFlags |= NEPPLI;#endif } | T_FTERMINST {#if EXE386 SetINSTTERM(dllFlags);#endif } ;
VirtBase : T_KBASE T_EQ T_NUMBER {#if EXE386 virtBase = $3; virtBase = RoundTo64k(virtBase);#endif } | { } ;
Apptype : T_FWINAPI {#if EXE386 SetGUI(TargetSubsys);#else vFlags |= NEWINAPI;#endif } | T_FWINCOMPAT {#if EXE386 SetGUICOMPAT(TargetSubsys);#else vFlags |= NEWINCOMPAT;#endif } | T_FNOTWINCOMPAT {#if EXE386 SetNOTGUI(TargetSubsys);#else vFlags |= NENOTWINCOMPAT;#endif
} | T_FPRIVATE { vFlags |= NEPRIVLIB; } | { } ;OtherFlags : T_FNEWFILES {#if NOT EXE386 vFlagsOthers |= NENEWFILES;#endif } | { } ;Options : Options Option | Option ;
Option : T_KDESCRIPTION T_STRING { NewDescription($2); } | T_KOLD T_STRING { if(sbOldver == NULL) sbOldver = _strdup(bufg); } | T_KSTUB T_FNONE { if(rhteStub == RHTENIL) fStub = (FTYPE) FALSE; } | T_KSTUB T_STRING { if(fStub && rhteStub == RHTENIL) { PROPSYMLOOKUP($2,ATTRNIL, TRUE); rhteStub = vrhte; } } | T_KHEAPSIZE { fHeapSize = (FTYPE) TRUE; } SizeSpec | T_KSTACKSIZE { fHeapSize = (FTYPE) FALSE; } SizeSpec | T_PROTMODE {#if NOT EXE386 vFlags |= NEPROT;#endif } | T_REALMODE { fRealMode = (FTYPE) TRUE; vFlags &= ~NEPROT; } | T_APPLOADER Idname {#if NOT EXE386 AppLoader($2);#endif } | Codeflags | Dataflags | Segments | Exports | Imports | ExeType | SubSystem | ProcOrder | UserVersion ;
SizeSpec : T_NUMBER T_COMA T_NUMBER { if (fHeapSize) { cbHeap = $1;#if EXE386 cbHeapCommit = $3;#endif } else { if(cbStack) OutWarn(ER_stackdb, $1); cbStack = $1;#if EXE386 cbStackCommit = $3;#endif } } | T_NUMBER { if (fHeapSize) { cbHeap = $1;#if EXE386 cbHeapCommit = cbHeap;#endif } else { if(cbStack) OutWarn(ER_stackdb, $1); cbStack = $1;#if EXE386 cbStackCommit = cbStack;#endif } } | T_KMAXVAL { if (fHeapSize) fHeapMax = (FTYPE) TRUE; } ;
Codeflags : T_KCODE Codeflaglist { // Set dfCode to specified flags; for any unspecified attributes // use the defaults. Then reset offmask.
dfCode = $2 | (dfCode & ~offmask); offmask = 0; vfShrattr = (FTYPE) FALSE; /* Reset for DATA */ } ;Codeflaglist : Codeflaglist Codeflag { $$ |= $2; } | Codeflag ;Codeflag : Baseflag | Codeonly ;Codeonly : T_FEXEC {#if EXE386 $$ = OBJ_EXEC;#else $$ = NSEXRD;#endif } | T_FEXECREAD | T_FDISCARDABLE {#if EXE386 offmask |= OBJ_RESIDENT;#else $$ = NSDISCARD | NSMOVE;#endif } | T_FNONDISCARDABLE {#if EXE386#else offmask |= NSDISCARD;#endif } | T_KCONFORM {#if EXE386#else $$ = NSCONFORM;#endif } | T_KNONCONFORM {#if EXE386#else offmask |= NSCONFORM;#endif } ;Dataflags : T_KDATA Dataflaglist { // Set dfData to specified flags; for any unspecified // attribute use the defaults. Then reset offmask.
#if EXE386 dfData = ($2 | (dfData & ~offmask));#else dfData = $2 | (dfData & ~offmask);#endif offmask = 0;
#if NOT EXE386 if (vfShrattr && !vfAutodata) { // If share-attribute and no autodata attribute, share- // attribute controls autodata.
if ($2 & NSSHARED) vFlags = (vFlags & ~NEINST) | NESOLO; else vFlags = (vFlags & ~NESOLO) | NEINST; } else if(!vfShrattr) { // Else if no share-attribute, autodata attribute // controls share-attribute.
if (vFlags & NESOLO) dfData |= NSSHARED; else if(vFlags & NEINST) dfData &= ~NSSHARED; }#endif } ;Dataflaglist : Dataflaglist Dataflag { $$ |= $2; } | Dataflag ;Dataflag : Baseflag | Dataonly | T_FNONE {#if NOT EXE386 vFlags &= ~(NESOLO | NEINST);#endif } | T_FSINGLE {#if NOT EXE386 vFlags = (vFlags & ~NEINST) | NESOLO;#endif vfAutodata = (FTYPE) TRUE; } | T_FMULTIPLE {#if NOT EXE386 vFlags = (vFlags & ~NESOLO) | NEINST;#endif vfAutodata = (FTYPE) TRUE; } | T_FDISCARDABLE {#if NOT EXE386 // This ONLY for compatibility with JDA IBM LINK $$ = NSDISCARD | NSMOVE;#endif } | T_FNONDISCARDABLE {#if NOT EXE386 // This ONLY for compatibility with JDA IBM LINK offmask |= NSDISCARD;#endif } ;Dataonly : T_FRDONLY {#if EXE386 $$ = OBJ_READ; offmask |= OBJ_WRITE;#else $$ = NSEXRD;#endif } | T_FRDWR | T_KEXPANDDOWN {#if FALSE AND NOT EXE386 $$ = NSEXPDOWN;#endif } | T_KNOEXPANDDOWN {#if FALSE AND NOT EXE386 offmask |= NSEXPDOWN;#endif } ;Segments : T_KSEGMENTS Segattrlist | T_KSEGMENTS | T_KOBJECTS Segattrlist | T_KOBJECTS | T_KSECTIONS Segattrlist | T_KSECTIONS ;
Segattrlist : Segattrlist Segattr | Segattr ;Segattr : Idname Class Overlay Segflags { NewSeg($1, $2, $3, $4); } ;Class : T_KCLASS T_STRING { $$ = _strdup($2); } | { $$ = _strdup("\004CODE"); } ;Overlay : T_OVL T_COLON T_NUMBER { $$ = $3; } | {#if OVERLAYS $$ = NOTIOVL;#endif } ;Segflag : Baseflag | Codeonly | Dataonly ;
Segflaglist : Segflaglist Segflag { $$ |= $2; } | Segflag ;Segflags : Segflaglist { $$ = $1; } | { $$ = 0; } ;Baseflag : T_FSHARED {#if EXE386 $$ = OBJ_SHARED;#else $$ = NSSHARED;#endif vfShrattr = (FTYPE) TRUE; } | T_FNONSHARED { vfShrattr = (FTYPE) TRUE;#if EXE386 offmask |= OBJ_SHARED;#else offmask |= NSSHARED;#endif } | T_FINVALID {#if EXE386#endif } | T_FIOPL {#if EXE386#else $$ = (2 << SHIFTDPL) | NSMOVE; offmask |= NSDPL;#endif } | T_FNOIOPL {#if EXE386#else $$ = (3 << SHIFTDPL);#endif } | T_FFIXED {#if NOT EXE386 offmask |= NSMOVE | NSDISCARD;#endif } | T_FMOVABLE {#if NOT EXE386 $$ = NSMOVE;#endif } | T_FPRELOAD {#if NOT EXE386 $$ = NSPRELOAD;#endif } | T_FLOADONCALL {#if NOT EXE386 offmask |= NSPRELOAD;#endif } | T_FHUGE { } | T_FSWAPPABLE { } | T_FRESIDENT { } | T_FALIAS { } | T_FMIXED { } | T_FNONPERM { } | T_FPERM { } | T_FCONTIG { } | T_FDYNAMIC { } ;Exports : T_KEXPORTS Exportlist | T_KEXPORTS ;Exportlist : Exportlist Export | Export ;Export : Idname Internal Exportopts Exportflags ExportOtherFlags ScopeFlag { NewExport($1,$2,$3,$4); } ;Internal : T_EQ Idname { $$ = $2; } | { $$ = NULL; } ;Exportopts : T_AT T_NUMBER T_KRESIDENTNAME { $$ = $2; nameFlags |= RES_NAME; } | T_AT T_NUMBER T_KNONAME { $$ = $2; nameFlags |= NO_NAME; } | T_AT T_NUMBER { $$ = $2; } | { $$ = 0; } ;Exportflags : Nodata Parmwds { $$ = $1 | 1; } ;Nodata : T_KNODATA { /* return 0 */ } | { $$ = 2; } ;Parmwds : T_NUMBER { } | { } ;ExportOtherFlags: T_KCONSTANT {#if EXE386 expOtherFlags |= 0x1;#endif } | { } ;
ScopeFlag : T_FPRIVATE | ;
Imports : T_KIMPORTS Importlist | T_KIMPORTS ;Importlist : Importlist Import | Import ;Import : Idname Internal T_DOT Idname ImportFlags/* * We'd like to have something like "Alias Idname T_DOT Idname" instead * of using Internal, since Internal looks for =internal and we're * looking for internal=. However, that would make this rule ambiguous * with the next rule, and the 2nd would never be reduced. So we use * Internal here as a kludge. */ { if($2 != NULL) {#if EXE386 NewImport($4,0,$2,$1,$5);#else NewImport($4,0,$2,$1);#endif free($2); } else#if EXE386 NewImport($4,0,$1,$4,$5);#else NewImport($4,0,$1,$4);#endif free($1); free($4); } | Idname Internal T_DOT T_NUMBER ImportFlags { if ($2 == NULL) Fatal(ER_dfimport);#if EXE386 NewImport(NULL,$4,$2,$1,$5);#else NewImport(NULL,$4,$2,$1);#endif free($1); free($2); } ;
Idname : T_ID { $$ = _strdup(bufg); } | T_STRING { $$ = _strdup(bufg); } ;
ImportFlags : T_KCONSTANT { $$ = 1; } | { $$ = 0; } ;
ExeType : T_KEXETYPE {#if EXE386 fUserVersion = (FTYPE) FALSE;#endif } ExeFlags ExeVersion ;
ExeFlags : T_FDOS { TargetOs = NE_DOS;#if ODOS3EXE fNewExe = FALSE;#endif } | T_FOS2 { TargetOs = NE_OS2; } | T_FUNKNOWN { TargetOs = NE_UNKNOWN; } | T_FWINDOWS {#if EXE386 TargetSubsys = E32_SSWINGUI;#endif TargetOs = NE_WINDOWS;// PROTMODE is default for WINDOWS fRealMode = (FTYPE) FALSE;#if NOT EXE386 vFlags |= NEPROT;#endif } | T_FDEV386 { TargetOs = NE_DEV386; } | T_FNT {#if EXE386 TargetSubsys = E32_SSWINGUI;#endif } | T_FUNIX {#if EXE386 TargetSubsys = E32_SSPOSIXCHAR;#endif } | T_FMACINTOSH T_FSWAPPABLE {#if O68K iMacType = MAC_SWAP; f68k = fTBigEndian = fNewExe = (FTYPE) TRUE;
/* If we are packing code to the default value, change the default. */ if (fPackSet && packLim == LXIVK - 36) packLim = LXIVK / 2;#endif } | T_FMACINTOSH {#if O68K iMacType = MAC_NOSWAP; f68k = fTBigEndian = fNewExe = (FTYPE) TRUE;
/* If we are packing code to the default value, change the default. */ if (fPackSet && packLim == LXIVK - 36) packLim = LXIVK / 2;#endif } ;
ExeVersion : MajorVer T_DOT MinorVer {#if EXE386 if (fUserVersion) { UserMajorVer = (BYTE) $1; UserMinorVer = (BYTE) $3; } else#endif { ExeMajorVer = (BYTE) $1; ExeMinorVer = (BYTE) $3; } } | MajorVer {#if EXE386 if (fUserVersion) { UserMajorVer = (BYTE) $1; UserMinorVer = 0; } else#endif { ExeMajorVer = (BYTE) $1; if(fNoExeVer) ExeMinorVer = DEF_EXETYPE_WINDOWS_MINOR; else ExeMinorVer = 0; } } ;
MajorVer : T_NUMBER { $$ = $1; } | { $$ = ExeMajorVer; fNoExeVer = TRUE; } ;
MinorVer : T_NUMBER { if (cDigits >= 2) $$ = $1; else $$ = 10 * $1; } | { $$ = ExeMinorVer; } ;
UserVersion : T_KVERSION {#if EXE386 fUserVersion = (FTYPE) TRUE;#endif } ExeVersion ;
SubSystem : T_KSUBSYSTEM SubSystemFlags ;
SubSystemFlags : T_FUNKNOWN {#if EXE386 TargetSubsys = E32_SSUNKNOWN;#endif } | T_FWINDOWSNT {#if EXE386 TargetSubsys = E32_SSNATIVE;#endif } | T_FOS2 {#if EXE386 TargetSubsys = E32_SSOS2CHAR;#endif } | T_FWINDOWS {#if EXE386 TargetSubsys = E32_SSWINGUI;#endif } | T_FWINDOWSCHAR {#if EXE386 TargetSubsys = E32_SSWINCHAR;#endif } | T_FPOSIX {#if EXE386 TargetSubsys = E32_SSPOSIXCHAR;#endif } ;
ProcOrder : T_FUNCTIONS { if (szSegName != NULL) { free(szSegName); szSegName = NULL; }#if OVERLAYS iOvl = NOTIOVL;#endif } SegOrOvl ProcList ;
SegOrOvl : T_COLON NameOrNumber | ;
NameOrNumber : Idname { if (szSegName == NULL) szSegName = $1;#if OVERLAYS iOvl = NOTIOVL;#endif } | T_NUMBER {#if OVERLAYS iOvl = $1; fOverlays = (FTYPE) TRUE; fNewExe = FALSE; TargetOs = NE_DOS;#endif } ;
ProcList : ProcList ProcName | ProcName ;
ProcName : Idname { NewProc($1); } ;
%%
LOCAL int NEAR GetChar(void){ int c; /* A character */
c = GetTxtChr(bsInput); if ((c == EOF || c == CTRL_Z) && curLevel > 0) { free(bsInput->_base); fclose(bsInput); bsInput = includeDisp[curLevel]; curLevel--; c = GetChar(); } return(c);}
LOCAL int NEAR lookup() /* Keyword lookup */{ char **pcp; /* Pointer to character pointer */ int i; /* Comparison value */
for(pcp = keywds; *pcp != NULL; pcp += 2) { /* Look through keyword table */ /* If found, return token type */ if(!(i = _stricmp(&bufg[1],*pcp))) { YYS_WD(yylval) = 0; return((int) (__int64) pcp[1]); } if(i < 0) break; /* Break if we've gone too far */ } return(T_ID); /* Just your basic identifier */}
LOCAL int NEAR yylex() /* Lexical analyzer */{ int c; /* A character */ int StrBegChr; /* What kind of quotte found at the begin of string */#if EXE386 DWORD x; /* Numeric token value */#else WORD x; /* Numeric token value */#endif int state; /* State variable */ BYTE *cp; /* Character pointer */ BYTE *sz; /* Zero-terminated string */ static int lastc = 0; /* Previous character */ char *fileBuf; FTYPE fFileNameSave; static int NameLineNo;
state = 0; /* Assume we're not in a comment */ c = '\0';
/* Loop to skip white space */
for(;;) { lastc = c; if (((c = GetChar()) == EOF) || c == '\032' || c == '\377') return(EOF); /* Get a character */ if (c == ';') state = TRUE; /* If comment, set flag */ else if(c == '\n') /* If end of line */ { state = FALSE; /* End of comment */ if(!curLevel) ++yylineno; /* Increment line number count */ } else if (state == FALSE && c != ' ' && c != '\t' && c != '\r') break; /* Break on non-white space */ }
/* Handle one-character tokens */
switch(c) { case '.': /* Name separator */ if (fFileNameExpected) break; return(T_DOT);
case '@': /* Ordinal specifier */ /* * Require that whitespace precede '@' if introducing an * ordinal, to allow '@' in identifiers. */ if (lastc == ' ' || lastc == '\t' || lastc == '\r') return(T_AT); break;
case '=': /* Name assignment */ return(T_EQ);
case ':': return(T_COLON);
case ',': return(T_COMA); }
/* See if token is a number */
if (c >= '0' && c <= '9' && !fFileNameExpected) { /* If token is a number */ x = c - '0'; /* Get first digit */ c = GetChar(); /* Get next character */ if(x == 0) /* If octal or hex */ { if(c == 'x' || c == 'X') /* If it is an 'x' */ { state = 16; /* Base is hexadecimal */ c = GetChar(); /* Get next character */ } else state = 8; /* Else octal */ cDigits = 0; } else { state = 10; /* Else decimal */ cDigits = 1; } for(;;) { if(c >= '0' && c <= '9' && c < (state + '0')) c -= '0'; else if(state == 16 && c >= 'A' && c <= 'F') c -= 'A' - 10; else if(state == 16 && c >= 'a' && c <= 'f') c -= 'a' - 10; else break; cDigits++; x = x*state + c; c = (BYTE) GetChar(); } ungetc(c,bsInput); YYS_WD(yylval) = x; return(T_NUMBER); }
/* See if token is a string */
if (c == '\'' || c == '"') /* If token is a string */ { StrBegChr = c; sz = &bufg[1]; /* Initialize */ for(state = 0; state != 2;) /* State machine loop */ { if ((c = GetChar()) == EOF) return(EOF); /* Check for EOF */ if (sz >= &bufg[sizeof(bufg)]) Fatal(ER_dflinemax, sizeof(bufg));
switch(state) /* Transitions */ { case 0: /* Inside quote */ if ((c == '\'' || c == '"') && c == StrBegChr) state = 1; /* Change state if quote found */ else *sz++ = (BYTE) c; /* Else save character */ break;
case 1: /* Inside quote with quote */ if ((c == '\'' || c == '"')) { /* If consecutive quotes */ *sz++ = (BYTE) c; /* Quote inside string */ state = 0; /* Back to state 0 */ } else state = 2; /* Else end of string */ break; } } ungetc(c,bsInput); /* Put back last character */ *sz = '\0'; /* Null-terminate the string */ x = (WORD)(sz - &bufg[1]); if (x >= SBLEN) /* Set length of string */ { bufg[0] = 0xff; bufg[0x100] = '\0'; OutWarn(ER_dfnamemax, &bufg[1]); } else bufg[0] = (BYTE) x; YYS_BP(yylval) = bufg; /* Save ptr. to identifier */ return(T_STRING); /* String found */ }
/* Assume we have identifier */
sz = &bufg[1]; /* Initialize */ if (fFileNameExpected && NameLineNo && NameLineNo != yylineno) { NameLineNo = 0; /* To avoid interference with INCLUDE */ fFileNameExpected = FALSE; } for(;;) /* Loop to get i.d.'s */ { if (fFileNameExpected) cp = " \t\r\n\f"; else cp = " \t\r\n:.=';\032"; while (*cp && *cp != (BYTE) c) ++cp; /* Check for end of identifier */ if(*cp) break; /* Break if end of identifier found */ if (sz >= &bufg[sizeof(bufg)]) Fatal(ER_dflinemax, sizeof(bufg)); *sz++ = (BYTE) c; /* Save the character */ if ((c = GetChar()) == EOF) break; /* Get next character */ } ungetc(c,bsInput); /* Put character back */ *sz = '\0'; /* Null-terminate the string */ x = (WORD)(sz - &bufg[1]); if (x >= SBLEN) /* Set length of string */ { bufg[0] = 0xff; bufg[0x100] = '\0'; OutWarn(ER_dfnamemax, &bufg[1]); } else bufg[0] = (BYTE) x; YYS_BP(yylval) = bufg; /* Save ptr. to identifier */ state = lookup();
if (state == T_KNAME || state == T_KLIBRARY) { fFileNameExpected = TRUE; NameLineNo = yylineno; }
if (state == INCLUDE_DIR) { // Process include directive
fFileNameSave = fFileNameExpected; fFileNameExpected = (FTYPE) TRUE; state = yylex(); fFileNameExpected = fFileNameSave; if (state == T_ID || state == T_STRING) { if (curLevel < MAX_NEST - 1) { curLevel++; includeDisp[curLevel] = bsInput;
// Because LINK uses customized version of stdio // for every file we have not only open the file // but also allocate i/o buffer.
bsInput = fopen(&bufg[1], RDBIN); if (bsInput == NULL) Fatal(ER_badinclopen, &bufg[1], strerror(errno)); fileBuf = GetMem(IO_BUF_SIZE);#if OSMSDOS setvbuf(bsInput, fileBuf, _IOFBF, IO_BUF_SIZE);#endif return(yylex()); } else Fatal(ER_toomanyincl); } else Fatal(ER_badinclname); } else return(state);}
LOCAL void NEAR yyerror(str)char *str;{ Fatal(ER_dfsyntax, str);}
#if NOT EXE386/*** AppLoader - define aplication specific loader** Purpose:* Define application specific loader. Feature available only under* Windows. Linker will create logical segment LOADER_<name> where* <name> is specified in APPLOADER statement. The LOADER_<name>* segment forms separate physical segment, which is placed by the linker* as the first segment in the .EXE file. Whithin the loader segment,* the linker will create an EXTDEF of the name <name>.** Input:* - sbName - pointer to lenght prefixed loader name** Output:* No explicit value is returned. As a side effect the SEGDEF and* EXTDEF definitions are entered into linker symbol table.** Exceptions:* None.** Notes:* None.**************************************************************************/
LOCAL void NEAR AppLoader(char *sbName){ APROPSNPTR apropSn; APROPUNDEFPTR apropUndef; SBTYPE segName; WORD strLen;
// Create loader segment name
strcpy(&segName[1], "LOADER_"); strcat(&segName[1], &sbName[1]); strLen = strlen(&segName[1]); if (strLen >= SBLEN) { segName[0] = SBLEN - 1; segName[SBLEN] = '\0'; OutWarn(ER_dfnamemax, &segName[1]); } else segName[0] = (BYTE) strLen;
// Define loader logical segment and remember its GSN
apropSn = GenSeg(segName, "\004CODE", GRNIL, (FTYPE) TRUE); gsnAppLoader = apropSn->as_gsn; apropSn->as_flags = dfCode | NSMOVE | NSPRELOAD; MARKVP();
// Define EXTDEF
apropUndef = (APROPUNDEFPTR ) PROPSYMLOOKUP(sbName, ATTRUND, TRUE); vpropAppLoader = vrprop; apropUndef->au_flags |= STRONGEXT; apropUndef->au_len = -1L; MARKVP(); free(sbName);}#endif
/*** NewProc - fill in the COMDAT descriptor for ordered procedure** Purpose:* Fill in the linkers symbol table COMDAT descriptor. This function* is called for new descriptors generated by FUNCTIONS list in the .DEF* file. All COMDAT descriptors entered by this function form one* list linked via ac_order field. The head of this list is global* variable procOrder;** Input:* szName - pointer to procedure name* iOvl - overlay number - global variable* szSegName - segment name - global variable** Output:* No explicit value is returned. As a side effect symbol table entry* is updated.** Exceptions:* Procedure already known - warning** Notes:* None.**************************************************************************/
LOCAL void NEAR NewProc(char *szName){ RBTYPE vrComdat; // Virtual pointer to COMDAT symbol table entry APROPCOMDATPTR apropComdat; // Real pointer to COMDAT symbol table descriptor static RBTYPE lastProc; // Last procedure on the list APROPSNPTR apropSn;
apropComdat = (APROPCOMDATPTR ) PROPSYMLOOKUP(szName, ATTRCOMDAT, FALSE); if ((apropComdat != NULL) && (apropComdat->ac_flags & ORDER_BIT)) OutWarn(ER_duporder, &szName[1]); else { apropComdat = (APROPCOMDATPTR ) PROPSYMLOOKUP(szName, ATTRCOMDAT, TRUE); vrComdat = vrprop;
// Fill in the COMDAT descriptor
apropComdat->ac_flags = ORDER_BIT;#if OVERLAYS apropComdat->ac_iOvl = iOvl;
// Set the maximum overlay index
if (iOvl != NOTIOVL) { fOverlays = (FTYPE) TRUE; fNewExe = FALSE; if (iOvl >= iovMac) iovMac = iOvl + 1; }#endif
if (szSegName != NULL) { apropSn = GenSeg(szSegName, "\004CODE", GRNIL, (FTYPE) TRUE); apropSn->as_flags = dfCode;
// Allocate COMDAT in the segment
apropComdat->ac_gsn = apropSn->as_gsn; apropComdat->ac_selAlloc = PICK_FIRST | EXPLICIT; AttachComdat(vrComdat, apropSn->as_gsn); } else apropComdat->ac_selAlloc = ALLOC_UNKNOWN;
MARKVP(); // Page has been changed
// Attach this COMDAT to the ordered procedure list
if (procOrder == VNIL) procOrder = vrComdat; else { apropComdat = (APROPCOMDATPTR ) FETCHSYM(lastProc, TRUE); apropComdat->ac_order = vrComdat; } lastProc = vrComdat; } free(szName);}
LOCAL void NEAR ProcNamTab(lfa,cb,fres)long lfa; /* Table starting address */WORD cb; /* Length of table */WORD fres; /* Resident name flag */{ SBTYPE sbExport; /* Exported symbol name */ WORD ordExport; /* Export ordinal */ APROPEXPPTR exp; /* Export symbol table entry */
fseek(bsInput,lfa,0); /* Seek to start of table */ for(cbRec = cb; cbRec != 0; ) /* Loop through table */ { sbExport[0] = (BYTE) getc(bsInput);/* Get length of name */ fread(&sbExport[1], sizeof(char), B2W(sbExport[0]), bsInput); /* Get export name */ ordExport = getc(bsInput) | (getc(bsInput) << BYTELN); if (ordExport == 0) continue; /* Skip if no ordinal assigned */ exp = (APROPEXPPTR ) PROPSYMLOOKUP(sbExport, ATTREXP, FALSE); /* Look the export up */ if(exp == PROPNIL || exp->ax_ord != 0) continue; /* Must exist and be unassigned */ exp->ax_ord = ordExport; /* Assign ordinal */ if (fres) exp->ax_nameflags |= RES_NAME; /* Set flag if from resident table */ MARKVP(); /* Page has been changed */ }}
#if NOT EXE386LOCAL void NEAR SetExpOrds(void)/* Set export ordinals */{ struct exe_hdr ehdr; /* Old .EXE header */ struct new_exe hdr; /* New .EXE header */ long lfahdr; /* File offset of header */
if((bsInput = LinkOpenExe(sbOldver)) == NULL) { /* If old version can't be opened */ /* Error message and return */ OutWarn(ER_oldopn); return; } SETRAW(bsInput); /* Dec 20 hack */ xread(&ehdr,CBEXEHDR,1,bsInput); /* Read old header */ if(E_MAGIC(ehdr) == EMAGIC) /* If old header found */ { if(E_LFARLC(ehdr) != sizeof(struct exe_hdr)) { /* If no new .EXE in this file */ /* Error message and return */ OutWarn(ER_oldbad); return; } lfahdr = E_LFANEW(ehdr); /* Get file address of new header */ } else lfahdr = 0L; /* Else no old header */ fseek(bsInput,lfahdr,0); /* Seek to new header */ xread(&hdr,CBNEWEXE,1,bsInput); /* Read the header */ if(NE_MAGIC(hdr) == NEMAGIC) /* If correct magic number */ { ProcNamTab(lfahdr+NE_RESTAB(hdr),(WORD)(NE_MODTAB(hdr) - NE_RESTAB(hdr)),(WORD)TRUE); /* Process Resident Name table */ ProcNamTab(NE_NRESTAB(hdr),NE_CBNRESTAB(hdr),FALSE); /* Process Non-resident Name table */ } else OutWarn(ER_oldbad); fclose(bsInput); /* Close old file */}#endif
LOCAL void NEAR NewDescription(BYTE *sbDesc){#if NOT EXE386 if (NonResidentName.byteMac > 3) Fatal(ER_dfdesc); /* Should be first time */ AddName(&NonResidentName, sbDesc, 0); /* Description 1st in non-res table */#endif}
#if EXE386LOCAL void NEAR NewModule(BYTE *sbModnam, BYTE *defaultExt)#elseLOCAL void NEAR NewModule(BYTE *sbModnam)#endif{ WORD length; /* Length of symbol */#if EXE386 SBTYPE sbModule; BYTE *pName;#endif
if(rhteModule != RHTENIL) Fatal(ER_dfname); /* Check for redefinition */ PROPSYMLOOKUP(sbModnam, ATTRNIL, TRUE); /* Create hash table entry */ rhteModule = vrhte; /* Save virtual hash table address */#if EXE386 memcpy(sbModule, sbModnam, sbModnam[0] + 1); if (sbModule[sbModule[0]] == '.') { sbModule[sbModule[0]] = '\0'; length = sbModule[0]; pName = &sbModule[1]; } else { UpdateFileParts(sbModule, defaultExt); length = sbModule[0] - 2; pName = &sbModule[4]; } if (TargetOs == NE_WINDOWS) SbUcase(sbModule); /* Make upper case */ vmmove(length, pName, AREAEXPNAME, TRUE); /* Module name 1st in Export Name Table */ cbExpName = length;#else if (TargetOs == NE_WINDOWS) SbUcase(sbModnam); /* Make upper case */ AddName(&ResidentName, sbModnam, 0);/* Module name 1st in resident table */#endif fFileNameExpected = (FTYPE) FALSE;}
void NewExport(sbEntry,sbInternal,ordno,flags)BYTE *sbEntry; /* Entry name */BYTE *sbInternal; /* Internal name */WORD ordno; /* Ordinal number */WORD flags; /* Flag byte */{ APROPEXPPTR export; /* Export record */ APROPUNDEFPTR undef; /* Undefined symbol */ APROPNAMEPTR PubName; /* Defined name */ BYTE *sb; /* Internal name */ BYTE ParWrds; /* # of parameter words */ RBTYPE rbSymdef; /* Virtual addr of symbol definition */#if EXE386 RBTYPE vExport; /* Virtual pointer to export descriptor */ APROPNAMEPTR public; /* Matching public symbol */#endif
#if DEBUG fprintf(stdout,"\r\nEXPORT: "); OutSb(stdout,sbEntry); NEWLINE(stdout); if(sbInternal != NULL) { fprintf(stdout,"INTERNAL NAME: "); OutSb(stdout,sbInternal); NEWLINE(stdout); } fprintf(stdout, " ordno %u, flags %u ", (unsigned)ordno, (unsigned)flags); fflush(stdout);#endif sb = (sbInternal != NULL)? sbInternal: sbEntry; /* Get pointer to internal name */ PubName = (APROPNAMEPTR ) PROPSYMLOOKUP(sb, ATTRPNM, FALSE);#if NOT EXE386 if(PubName != PROPNIL && !fDrivePass) /* If internal name already exists as a public symbol * and we are parsing definition file, issue * export internal name conflict warning. */ OutWarn(ER_expcon,sbEntry+1,sb+1); else /* Else if no conflict */ {#endif if (PubName == PROPNIL) /* If no matching name exists */ undef = (APROPUNDEFPTR ) PROPSYMLOOKUP(sb,ATTRUND, TRUE); /* Make undefined symbol entry */#if TCE#if TCE_DEBUG fprintf(stdout, "\r\nNewExport adds UNDEF %s ", 1+GetPropName(undef));#endif undef->au_fAlive = TRUE; /* all exports are potential entry points */#endif rbSymdef = vrprop; /* Save virtual address */ if (PubName == PROPNIL) /* If this is a new symbol */ undef->au_len = -1L; /* Make no type assumptions */ export = (APROPEXPPTR ) PROPSYMLOOKUP(sbEntry,ATTREXP, TRUE); /* Create export record */#if EXE386 vExport = vrprop;#endif if(vfCreated) /* If this is a new entry */ { export->ax_symdef = rbSymdef; /* Save virt addr of symbol def */ export->ax_ord = ordno; /* Save ordinal number */ if (nameFlags & RES_NAME) export->ax_nameflags |= RES_NAME; /* Remember if resident */ else if (nameFlags & NO_NAME) export->ax_nameflags |= NO_NAME; /* Remember to discard name */ export->ax_flags = (BYTE) flags; /* Save flags */ ++expMac; /* One more exported symbol */ } else { if (!fDrivePass) /* Else if parsing definition file */ /* multiple definitions */ OutWarn(ER_expmul,sbEntry + 1); /* Output error message */ else { /* We were called for EXPDEF object */ /* record, so we merge information */ ParWrds = (BYTE) (export->ax_flags & 0xf8); if (ParWrds && (ParWrds != (BYTE) (flags & 0xf8))) Fatal(ER_badiopl); /* If the iopl_parmwords field in the */ /* .DEF file is not 0 and does not match */ /* value in the EXPDEF exactly issue error */ else if (!ParWrds) { /* Else set value from EXPDEF record */ ParWrds = (BYTE) (flags & 0xf8); export->ax_flags |= ParWrds; } } }#if EXE386 if (PubName != NULL) { if (expOtherFlags & 0x1) { export->ax_nameflags |= CONSTANT; expOtherFlags = 0; } }#endif
#if NOT EXE386 }#endif if(!(flags & 0x8000)) { free(sbEntry); /* Free space */ if(sbInternal != NULL) free(sbInternal); } /* Free space */ nameFlags = 0;}
LOCAL APROPIMPPTR NEAR GetImport(sb) /* Get name in Imported Names Table */BYTE *sb; /* Length-prefixed names */{ APROPIMPPTR import; /* Pointer to imported name */#if EXE386 DWORD cbTemp; /* Temporary value */#else WORD cbTemp; /* Temporary value */#endif RBTYPE rprop; /* Property cell virtual address */
import = (APROPIMPPTR ) PROPSYMLOOKUP(sb,ATTRIMP, TRUE); /* Look up module name */ if(vfCreated) /* If no offset assigned yet */ { rprop = vrprop; /* Save the virtual address */ /* * WARNING: We must store name in virtual memory now, otherwise * if an EXTDEF was seen first, fIgnoreCase is false, and the * cases do not match between the imported name and the EXTDEF, * then the name will not go in the table exactly as given. */ import = (APROPIMPPTR) FETCHSYM(rprop,TRUE); /* Retrieve from symbol table */ import->am_offset = AddImportedName(sb); /* Save offset */ } return(import); /* Return offset in table */}
#if NOT EXE386void NewImport(sbEntry,ordEntry,sbModule,sbInternal)BYTE *sbEntry; /* Entry point name */WORD ordEntry; /* Entry point ordinal */BYTE *sbModule; /* Module name */BYTE *sbInternal; /* Internal name */{ APROPNAMEPTR public; /* Public symbol */ APROPIMPPTR import; /* Imported symbol */ BYTE *sb; /* Symbol pointer */ WORD module; /* Module name offset */ FTYPE flags; /* Import flags */ WORD modoff; /* module name offset */ WORD entry; /* Entry name offset */ BYTE *cp; /* Char pointer */ RBTYPE rpropundef; /* Address of undefined symbol */ char buf[32]; /* Buffer for error sgring */
#if DEBUG fprintf(stderr,"\r\nIMPORT: "); OutSb(stderr,sbModule); fputc('.',stderr); if(!ordEntry) { OutSb(stderr,sbEntry); } else fprintf(stderr,"%u",ordEntry); if(sbInternal != sbEntry) { fprintf(stderr," ALIAS: "); OutSb(stderr,sbInternal); } fprintf(stdout," ordEntry %u ", (unsigned)ordEntry); fflush(stdout);#endif if((public = (APROPNAMEPTR ) PROPSYMLOOKUP(sbInternal, ATTRUND, FALSE)) != PROPNIL && !fDrivePass) /* If internal names conflict */ { if(sbEntry != NULL) sb = sbEntry; else { sprintf(buf + 1,"%u",ordEntry); sb = buf; } OutWarn(ER_impcon,sbModule + 1,sb + 1,sbInternal + 1); } else /* Else if no conflicts */ { rpropundef = vrprop; /* Save virtual address of extern */ flags = FIMPORT; /* We have an imported symbol */ if (TargetOs == NE_WINDOWS) SbUcase(sbModule); /* Force module name to upper case */ import = GetImport(sbModule); /* Get pointer to import record */ if((module = import->am_mod) == 0) { // If not in Module Reference Table
import->am_mod = WordArrayPut(&ModuleRefTable, import->am_offset) + 1; /* Save offset of name in table */ module = import->am_mod;
}
if(vrhte == rhteModule) /* If importing from this module */ { if(sbEntry != NULL) sb = sbEntry; else { sprintf(buf+1,"%u",ordEntry); sb = buf; } if (TargetOs == NE_OS2) OutWarn(ER_impself,sbModule + 1,sb + 1,sbInternal + 1); else OutError(ER_impself,sbModule + 1,sb + 1,sbInternal + 1); }
if(sbEntry == NULL) /* If entry by ordinal */ { flags |= FIMPORD; /* Set flag bit */ entry = ordEntry; /* Get ordinal number */ } else /* Else if import by name */ { if(fIgnoreCase) SbUcase(sbEntry); /* Upper case the name if flag set */ import = GetImport(sbEntry); entry = import->am_offset; /* Get offset of name in table */ } if(public == PROPNIL) /* If no undefined symbol */ { public = (APROPNAMEPTR ) PROPSYMLOOKUP(sbInternal,ATTRPNM, TRUE); /* Make a public symbol */ if(!vfCreated) /* If not new */ /* Output error message */ OutWarn(ER_impmul,sbInternal + 1); else ++pubMac; /* Else increment public count */ } else /* Else if symbol is undefined */ { public = (APROPNAMEPTR ) FETCHSYM(rpropundef,TRUE); /* Look up external symbol */ ++pubMac; /* Increment public symbol count */ } flags |= FPRINT; /* Symbol is printable */ public->an_attr = ATTRPNM; /* This is a public symbol */ public->an_gsn = SNNIL; /* Not a segment member */ public->an_ra = 0; /* No known offset */ public->an_ggr = GRNIL; /* Not a group member */ public->an_flags = flags; /* Set flags */ public->an_entry = entry; /* Save entry specification */ public->an_module = module; /* Save Module Reference Table index */#if SYMDEB AND FALSE if (fSymdeb) /* If debugger support on */ { if (flags & FIMPORD) import = GetImport(sbInternal); else /* Add internal name to Imported Name Table */ import = GetImport(sbEntry); import->am_public = public; /* Remember public symbol */ if (cbImpSeg < LXIVK-1) cbImpSeg += sizeof(CVIMP);
}#endif }}#endif
#if OVERLAYSextern void NEAR GetName(AHTEPTR ahte, BYTE *pBuf);#endif
/*** NewSeg - new segment definition** Purpose:* Create new segment definition based on the module definition* file segment description. Check for duplicate definitions and* overlay index inconsistency between attached COMDATs (if any)* and segment itself.** Input:* sbName - segment name* sbClass - segment class* iOvl - segment overlay index* flags - segment attributes** Output:* No explicit value is returned. The segment descriptor in* symbol table is created or updated.** Exceptions:* Multiple segment definitions - warning and continue* Change in overlay index - warning and continue** Notes:* None.**************************************************************************/
void NEAR NewSeg(BYTE *sbName, BYTE *sbClass, WORD iOvl,#if EXE386 DWORD flags)#else WORD flags)#endif{ APROPSNPTR apropSn; // Pointer to segment descriptor#if OVERLAYS RBTYPE vrComdat; // Virtual pointer to COMDAT descriptor APROPCOMDATPTR apropComdat; // Symbol table entry for COMDAT symbol SBTYPE sbComdat; // Name buffer#endif
// Set segment attributes based on the class
if (SbSuffix(sbClass,"\004CODE",TRUE)) flags |= dfCode & ~offmask; else flags |= dfData & ~offmask;#if O68K if (f68k) flags |= NS32BIT;#endif#if OVERLAYS if (iOvl != NOTIOVL) { fOverlays = (FTYPE) TRUE; fNewExe = FALSE; if (iOvl >= iovMac) // Set the maximum overlay index iovMac = iOvl + 1; }#endif
// Generate new segment definition
apropSn = GenSeg(sbName, sbClass, GRNIL, (FTYPE) TRUE); if (vfCreated) { apropSn->as_flags = (WORD) flags; // Save flags mpgsndra[apropSn->as_gsn] = 0; // Initialize#if OVERLAYS apropSn->as_iov = iOvl; // Save overlay index if (fOverlays) CheckOvl(apropSn, iOvl);#endif apropSn->as_fExtra |= (BYTE) FROM_DEF_FILE; // Remember defined in def file if (fMixed) { apropSn->as_fExtra |= (BYTE) MIXED1632; fMixed = (FTYPE) FALSE; } } else { apropSn = CheckClass(apropSn, apropSn->as_rCla); // Check if previous definition had the same class OutWarn(ER_segdup,sbName + 1); // Warn about multiple definition#if OVERLAYS if (fOverlays && apropSn->as_iov != iOvl) { if (apropSn->as_iov != NOTIOVL) OutWarn(ER_badsegovl, 1 + GetPropName(apropSn), apropSn->as_iov, iOvl); apropSn->as_iov = iOvl; // Save new overlay index CheckOvl(apropSn, iOvl);
// Check if segment has any COMDATs and if it has // then check theirs overlay numbers
for (vrComdat = apropSn->as_ComDat; vrComdat != VNIL; vrComdat = apropComdat->ac_sameSeg) { apropComdat = (APROPCOMDATPTR ) FetchSym(vrComdat, FALSE); if (apropComdat->ac_iOvl != NOTIOVL && apropComdat->ac_iOvl != iOvl) { GetName((AHTEPTR) apropComdat, sbComdat); OutWarn(ER_badcomdatovl, &sbComdat[1], apropComdat->ac_iOvl, iOvl); } apropComdat->ac_iOvl = iOvl; } }#endif }
free(sbClass); // Free class name free(sbName); // Free segment name offmask = 0;
// Unless packing limit already set, disable default code packing
if (!fPackSet) { fPackSet = (FTYPE) TRUE; // Remember packLim was set packLim = 0L; }}
/* * Assign module name to be default, which is run file name. * * SIDE EFFECTS * Assigns rhteModule */
#if EXE386LOCAL void NEAR DefaultModule (unsigned char *defaultExt)#elseLOCAL void NEAR DefaultModule (void)#endif{ SBTYPE sbModname; /* Module name */ AHTEPTR ahte; /* Pointer to hash table entry */#if OSXENIX int i;#endif
ahte = (AHTEPTR ) FETCHSYM(rhteRunfile,FALSE); /* Get executable file name */#if OSMSDOS memcpy(sbModname,GetFarSb(ahte->cch),B2W(ahte->cch[0]) + 1); /* Copy file name */#if EXE386 NewModule(sbModname, defaultExt); /* Use run file name as module name */#else UpdateFileParts(sbModname,"\005A:\\.X"); /* Force path, ext with known length */ sbModname[0] -= 2; /* Remove extension from name */ sbModname[3] = (BYTE) (sbModname[0] - 3); /* Remove path and drive from name */ NewModule(&sbModname[3]); /* Use run file name as module name */#endif#endif#if OSXENIX for(i = B2W(ahte->cch[0]); i > 0 && ahte->cch[i] != '/'; i--) sbModname[0] = B2W(ahte->cch[0]) - i; memcpy(sbModname+1,&GetFarSb(ahte->cch)[i+1],B2W(sbModname[0])); for(i = B2W(ahte->cch[0]); i > 1 && sbModname[i] != '.'; i--); if(i > 1) sbModname[0] = i - 1; NewModule(sbModname); /* Use run file name as module name */#endif}
void ParseDeffile(void){ SBTYPE sbDeffile; /* Definitions file name */ AHTEPTR ahte; /* Pointer to hash table entry */#if OSMSDOS char buf[512]; /* File buffer */#endif
if(rhteDeffile == RHTENIL) /* If no definitions file */#if EXE386 DefaultModule(moduleEXE);#else DefaultModule();#endif else /* Else if there is a file to parse */ {#if ODOS3EXE fNewExe = (FTYPE) TRUE; /* Def file forces new-format exe */#endif ahte = (AHTEPTR ) FETCHSYM(rhteDeffile,FALSE); /* Fetch file name */ memcpy(sbDeffile,GetFarSb(ahte->cch),B2W(ahte->cch[0]) + 1); /* Copy file name */ sbDeffile[B2W(sbDeffile[0]) + 1] = '\0'; /* Null-terminate the name */ if((bsInput = fopen(&sbDeffile[1],RDTXT)) == NULL) { /* If open fails */ Fatal(ER_opndf, &sbDeffile[1]);/* Fatal error */ }#if OSMSDOS setvbuf(bsInput,buf,_IOFBF,sizeof(buf));#endif includeDisp[0] = bsInput; // Initialize include stack sbOldver = NULL; /* Assume no old version */ yylineno = 1; fFileNameExpected = (FTYPE) FALSE;
// HACK ALERT !!! // Don't allocate to much page buffers
yyparse(); /* Parse the definitions file */ yylineno = -1; fclose(bsInput); /* Close the definitions file */#if NOT EXE386 if(sbOldver != NULL) /* If old version given */ { SetExpOrds(); /* Use old version to set ordinals */ free(sbOldver); /* Release the space */ }#endif }#if OSMSDOS
#endif /* OSMSDOS */#if NOT EXE386 if (NonResidentName.byteMac == 0) { ahte = (AHTEPTR ) FETCHSYM(rhteRunfile,FALSE); /* Get executable file name */ memcpy(sbDeffile,GetFarSb(ahte->cch),B2W(ahte->cch[0]) + 1); /* Copy file name */#if OSXENIX SbUcase(sbDeffile); /* For identical executables */#endif if ((vFlags & NENOTP) && TargetOs == NE_OS2) UpdateFileParts(sbDeffile, sbDotDll); else UpdateFileParts(sbDeffile, sbDotExe); NewDescription(sbDeffile); /* Use run file name as description */ }#endif}
|
