/* 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 #include #include #include #include #if EXE386 #include #endif #include #include #include #include #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 EXE386 LOCAL void NEAR SetExpOrds(void); #endif LOCAL void NEAR NewDescription(unsigned char *sbDesc); LOCAL APROPIMPPTR NEAR GetImport(unsigned char *sb); #if EXE386 LOCAL void NEAR NewModule(unsigned char *sbModnam, unsigned char *defaultExt); LOCAL void NEAR DefaultModule(unsigned char *defaultExt); #else LOCAL void NEAR NewModule(unsigned char *sbModnam); LOCAL void NEAR DefaultModule(void); #endif #if AUTOVM BYTE 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 EXE386 LOCAL 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"; #else LOCAL WORD offmask; /* Seg flag bits to turn off */ #endif #if OVERLAYS LOCAL WORD iOvl = NOTIOVL; // Overlay assigned to functions #endif LOCAL char *szSegName; // Segment assigned to functions LOCAL WORD nameFlags; /* Flags associated with exported name */ LOCAL BSTYPE includeDisp[MAX_NEST]; // Include file stack LOCAL short curLevel; // Current include nesting level // Zero means main .DEF file LOCAL 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_ where * is specified in APPLOADER statement. The LOADER_ * 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 . * * 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 EXE386 LOCAL 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 EXE386 LOCAL void NEAR NewModule(BYTE *sbModnam, BYTE *defaultExt) #else LOCAL 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 EXE386 void 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 OVERLAYS extern 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 EXE386 LOCAL void NEAR DefaultModule (unsigned char *defaultExt) #else LOCAL 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 }