mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
981 lines
31 KiB
981 lines
31 KiB
/****************************************************************************/
|
|
/* */
|
|
/* RCP.C - */
|
|
/* */
|
|
/* Resource Compiler 3.00 - Top Level Parsing routines */
|
|
/* */
|
|
/****************************************************************************/
|
|
|
|
#include "rc.h"
|
|
|
|
|
|
static BOOL fFontDirRead = FALSE;
|
|
|
|
BOOL bExternParse = FALSE;
|
|
|
|
WORD language = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
|
|
LONG version = 0;
|
|
LONG characteristics = 0;
|
|
|
|
static int rowError = 0;
|
|
static int colError = 0;
|
|
static int idError = 0;
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* ParseError2() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
void ParseError2(int id, PWCHAR arg)
|
|
{
|
|
// Don't get caught giving the same error over and over and over...
|
|
if (Nerrors > 0 &&
|
|
idError == id && rowError == token.row && colError == token.col)
|
|
quit("\n");
|
|
|
|
SendError("\n");
|
|
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(id), curFile, token.row, arg);
|
|
SendError(Msg_Text);
|
|
|
|
if (++Nerrors > 25)
|
|
quit("\n");
|
|
|
|
rowError = token.row;
|
|
colError = token.col;
|
|
idError = id;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* ParseError1() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
void ParseError1(int id)
|
|
{
|
|
// Don't get caught giving the same error over and over and over...
|
|
if (Nerrors > 0 &&
|
|
idError == id && rowError == token.row && colError == token.col)
|
|
quit("\n");
|
|
|
|
SendError("\n");
|
|
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(id), curFile, token.row);
|
|
SendError(Msg_Text);
|
|
|
|
if (++Nerrors > 25)
|
|
quit("\n");
|
|
|
|
rowError = token.row;
|
|
colError = token.col;
|
|
idError = id;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* GetFileName() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/* Read in a filename from the RC file. */
|
|
|
|
LONG GetFileName(VOID)
|
|
{
|
|
PFILE fh;
|
|
LONG size;
|
|
CHAR szFilename[_MAX_PATH];
|
|
CHAR buf[_MAX_PATH];
|
|
|
|
WideCharToMultiByte(uiCodePage, 0, tokenbuf, -1, buf, _MAX_PATH, NULL, NULL);
|
|
searchenv(buf, "INCLUDE", szFilename);
|
|
if ( szFilename[0] && ((fh = fopen(szFilename, "rb")) != NULL)) {
|
|
size = MySeek(fh, 0L, SEEK_END); /* find size of file */
|
|
MySeek(fh, 0L, SEEK_SET); /* return to start of file */
|
|
CtlFile(fh);
|
|
return(size);
|
|
}
|
|
else {
|
|
ParseError2(2135, (PWCHAR)buf);
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* AddStringToBin() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/* adds ordinal if non-zero, otherwise adds string. In either case, puts */
|
|
/* it in a field of NCHARS [16] */
|
|
|
|
VOID AddStringToBin(USHORT ord, WCHAR *sz)
|
|
{
|
|
USHORT n1 = 0xFFFF;
|
|
|
|
/* Is this an ordinal type? */
|
|
if (ord) {
|
|
MyWrite(fhBin, (PCHAR)&n1, sizeof(USHORT)); /* 0xFFFF */
|
|
MyWrite(fhBin, (PCHAR)&ord, sizeof(USHORT));
|
|
}
|
|
else {
|
|
MyWrite(fhBin, (PVOID)sz, (wcslen(sz)+1) * sizeof(WCHAR));
|
|
}
|
|
}
|
|
|
|
|
|
PWCHAR pTypeName[] =
|
|
{
|
|
NULL, // 0
|
|
L"CURSOR", // RT_CURSOR
|
|
L"BITMAP", // RT_BITMAP
|
|
L"ICON", // RT_ICON
|
|
L"MENU", // RT_MENU
|
|
L"DIALOG", // RT_DIALOG
|
|
L"STRING", // RT_STRING
|
|
L"FONTDIR", // RT_FONTDIR
|
|
L"FONT", // RT_FONT
|
|
L"ACCELERATOR", // RT_ACCELERATOR
|
|
L"RCDATA", // RT_RCDATA
|
|
L"MESSAGETABLE", // RT_MESSAGETABLE
|
|
L"GROUP_CURSOR", // RT_GROUP_CURSOR
|
|
NULL, // RT_NEWBITMAP -- according to NT
|
|
L"GROUP_ICON", // RT_GROUP_ICON
|
|
NULL, // RT_NAMETABLE
|
|
L"VERSION", // RT_VERSION
|
|
L"DIALOGEX", // RT_DIALOGEX ;internal
|
|
L"DLGINCLUDE", // RT_DLGINCLUDE
|
|
L"PLUGPLAY", // RT_PLUGPLAY
|
|
L"VXD", // RT_VXD
|
|
L"ANIICON", // RT_ANIICON ;internal
|
|
L"ANICURSOR" // RT_ANICURSOR ;internal
|
|
};
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* AddBinEntry() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/* FORMAT: type, name, flags, length, bytes */
|
|
|
|
VOID AddBinEntry(PTYPEINFO pType, PRESINFO pRes, PCHAR Array, int ArrayCount,
|
|
LONG FileCount)
|
|
{
|
|
ULONG hdrSize = sizeof(RESADDITIONAL);
|
|
ULONG t0 = 0;
|
|
ULONG cbPad=0;
|
|
|
|
if (!pRes->size)
|
|
pRes->size = ResourceSize();
|
|
|
|
if (pType->typeord == 0) {
|
|
hdrSize += (wcslen(pType->type) + 1) * sizeof(WCHAR);
|
|
cbPad += (wcslen(pType->type) + 1) * sizeof(WCHAR);
|
|
}
|
|
else
|
|
hdrSize += 2 * sizeof(WORD);
|
|
|
|
if (pRes->nameord == 0) {
|
|
hdrSize += (wcslen(pRes->name) + 1) * sizeof(WCHAR);
|
|
cbPad += (wcslen(pRes->name) + 1) * sizeof(WCHAR);
|
|
}
|
|
else
|
|
hdrSize += 2 * sizeof(WORD);
|
|
|
|
if (cbPad % 4)
|
|
hdrSize += sizeof(WORD); // could only be off by 2
|
|
|
|
if (fVerbose) {
|
|
if (pType->typeord == 0) {
|
|
if (pRes->nameord == 0)
|
|
wsprintfA(Msg_Text, "\nWriting %ws:%ws,\tlang:0x%x,\tsize %d",
|
|
pType->type, pRes->name, pRes->language, pRes->size);
|
|
else
|
|
wsprintfA(Msg_Text, "\nWriting %ws:%d,\tlang:0x%x,\tsize %d",
|
|
pType->type, pRes->nameord, pRes->language, pRes->size);
|
|
}
|
|
else {
|
|
if (pRes->nameord == 0) {
|
|
if (pType->typeord <= (int)RT_LAST)
|
|
wsprintfA(Msg_Text, "\nWriting %ws:%ws,\tlang:0x%x,\tsize %d",
|
|
pTypeName[pType->typeord],
|
|
pRes->name, pRes->language, pRes->size);
|
|
else
|
|
wsprintfA(Msg_Text, "\nWriting %d:%ws,\tlang:0x%x,\tsize %d",
|
|
pType->typeord,
|
|
pRes->name, pRes->language, pRes->size);
|
|
}
|
|
else {
|
|
if (pType->typeord <= (int)RT_LAST)
|
|
wsprintfA(Msg_Text, "\nWriting %ws:%d,\tlang:0x%x,\tsize %d",
|
|
pTypeName[pType->typeord],
|
|
pRes->nameord, pRes->language, pRes->size);
|
|
else
|
|
wsprintfA(Msg_Text, "\nWriting %d:%d,\tlang:0x%x,\tsize %d",
|
|
pType->typeord,
|
|
pRes->nameord, pRes->language, pRes->size);
|
|
}
|
|
}
|
|
printf(Msg_Text);
|
|
}
|
|
|
|
if (fMacRsrcs)
|
|
{
|
|
/* record file location for the resource map and dump out
|
|
resource's size */
|
|
DWORD dwT;
|
|
pRes->BinOffset = (long)MySeek(fhBin,0L,1) - MACDATAOFFSET;
|
|
dwT = SwapLong(pRes->size);
|
|
MyWrite(fhBin, &dwT, 4);
|
|
}
|
|
else
|
|
{
|
|
/* add type, name, flags, and resource length */
|
|
MyWrite(fhBin, (PCHAR)&pRes->size, sizeof(ULONG));
|
|
MyWrite(fhBin, (PCHAR)&hdrSize, sizeof(ULONG));
|
|
|
|
AddStringToBin(pType->typeord, pType->type);
|
|
AddStringToBin(pRes->nameord , pRes->name);
|
|
MyAlign(fhBin);
|
|
|
|
MyWrite(fhBin, (PCHAR)&t0, sizeof(ULONG)); /* data version */
|
|
MyWrite(fhBin, (PCHAR)&pRes->flags, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&pRes->language, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&pRes->version, sizeof(ULONG));
|
|
MyWrite(fhBin, (PCHAR)&pRes->characteristics, sizeof(ULONG));
|
|
|
|
/* record file location for the .EXE construction */
|
|
pRes->BinOffset = (LONG)MySeek(fhBin, 0L, SEEK_CUR);
|
|
}
|
|
|
|
/* write array plus contents of resource source file */
|
|
WriteControl(fhBin, Array, ArrayCount, FileCount);
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* AddResToResFile(pType, pRes, Array, ArrayCount, FileCount) */
|
|
/* */
|
|
/* Parameters: */
|
|
/* pType : Pointer to Res Type */
|
|
/* pRes : Pointer to resource */
|
|
/* Array : Pointer to array from which some data is to be copied into */
|
|
/* the .RES file. */
|
|
/* This is ignored if ArrayCount is zero. */
|
|
/* ArrayCount : This is the number of bytes to be copied from "Array" */
|
|
/* into the .RES file. This is zero if no copy is required*/
|
|
/* FileCount : This specifies the number of bytes to be copied from */
|
|
/* fhCode into fhOut. If this is -1, the complete input */
|
|
/* file is to be copied into fhOut. */
|
|
/* */
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
VOID AddResToResFile(PTYPEINFO pType, PRESINFO pRes, PCHAR Array,
|
|
int ArrayCount, LONG FileCount)
|
|
{
|
|
PRESINFO p;
|
|
|
|
p = pType->pres;
|
|
|
|
/* add resource to end of resource list for this type */
|
|
if (p) {
|
|
while (p->next)
|
|
p = p->next;
|
|
|
|
p->next = pRes;
|
|
}
|
|
else
|
|
pType->pres = pRes;
|
|
|
|
|
|
/* add the resource to the .RES File */
|
|
AddBinEntry(pType, pRes, Array, ArrayCount, FileCount);
|
|
|
|
/* keep track of number of resources and types */
|
|
pType->nres++;
|
|
ResCount++;
|
|
WriteResInfo(pRes, pType, TRUE);
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* AddResType() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
PTYPEINFO AddResType(PWCHAR s, LPWSTR l)
|
|
{
|
|
PTYPEINFO pType;
|
|
|
|
if ((pType = pTypInfo) != 0) {
|
|
for (; ; ) {
|
|
/* search for resource type, return if already exists */
|
|
if ((s && pType->type && !wcscmp(s, pType->type)) ||
|
|
(!s && l && pType->typeord == (USHORT)l))
|
|
return(pType);
|
|
else if (!pType->next)
|
|
break;
|
|
else
|
|
pType = pType->next;
|
|
}
|
|
|
|
/* if not in list, add space for it */
|
|
pType->next = (PTYPEINFO)MyAlloc(sizeof(TYPEINFO));
|
|
pType = pType->next;
|
|
}
|
|
else {
|
|
/* allocate space for resource list */
|
|
pTypInfo = (PTYPEINFO)MyAlloc(sizeof(TYPEINFO));
|
|
pType = pTypInfo;
|
|
}
|
|
|
|
/* fill allocated space with name and ordinal, and clear the resources
|
|
of this type */
|
|
pType->type = MyMakeStr(s);
|
|
pType->typeord = (USHORT)l;
|
|
pType->nres = 0;
|
|
pType->pres = NULL;
|
|
|
|
return(pType);
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* DGetMemFlags() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
int DGetMemFlags (PRESINFO pRes)
|
|
{
|
|
if (token.type == NUMLIT)
|
|
// this is a numeric value, not a mem flag -- this means we're done
|
|
// processing memory flags
|
|
return(FALSE);
|
|
|
|
/* adjust memory flags of resource */
|
|
switch (token.val) {
|
|
case TKMOVEABLE:
|
|
pRes->flags |= NSMOVE;
|
|
break;
|
|
|
|
case TKFIXED:
|
|
pRes->flags &= ~(NSMOVE | NSDISCARD);
|
|
break;
|
|
|
|
case TKPURE :
|
|
pRes->flags |= NSPURE;
|
|
break;
|
|
|
|
case TKIMPURE :
|
|
pRes->flags &= ~(NSPURE | NSDISCARD);
|
|
break;
|
|
|
|
case TKPRELOAD:
|
|
pRes->flags |= NSPRELOAD;
|
|
break;
|
|
|
|
case TKLOADONCALL:
|
|
pRes->flags &= ~NSPRELOAD;
|
|
break;
|
|
|
|
case TKDISCARD:
|
|
pRes->flags |= NSMOVE | NSPURE | NSDISCARD;
|
|
break;
|
|
|
|
case TKEXSTYLE:
|
|
GetToken(FALSE); /* ignore '=' */
|
|
if (token.type != EQUAL)
|
|
ParseError1(2136);
|
|
GetTokenNoComma(TOKEN_NOEXPRESSION);
|
|
GetFullExpression(&pRes->exstyleT, GFE_ZEROINIT);
|
|
break;
|
|
|
|
/* if current token not memory flag, return FALSE to indicate not
|
|
to continue parsing flags */
|
|
default:
|
|
return(FALSE);
|
|
}
|
|
|
|
GetToken(FALSE);
|
|
|
|
/* TRUE ==> found memory flag */
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* AddDefaultTypes() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
VOID AddDefaultTypes(VOID)
|
|
{
|
|
AddResType(L"CURSOR", RT_GROUP_CURSOR);
|
|
AddResType(L"ICON", RT_GROUP_ICON);
|
|
AddResType(L"BITMAP", RT_BITMAP);
|
|
AddResType(L"MENU", RT_MENU);
|
|
AddResType(L"DIALOG", RT_DIALOG);
|
|
AddResType(L"STRINGTABLE", RT_STRING);
|
|
AddResType(L"FONTDIR", RT_FONTDIR);
|
|
AddResType(L"FONT", RT_FONT);
|
|
AddResType(L"ACCELERATORS", RT_ACCELERATOR);
|
|
AddResType(L"RCDATA", RT_RCDATA);
|
|
AddResType(L"MESSAGETABLE", RT_MESSAGETABLE);
|
|
AddResType(L"VERSIONINFO", RT_VERSION);
|
|
AddResType(L"DLGINCLUDE", RT_DLGINCLUDE);
|
|
AddResType(L"MENUEX", RT_MENUEX);
|
|
AddResType(L"DIALOGEX", RT_DIALOGEX);
|
|
AddResType(L"PLUGPLAY", RT_PLUGPLAY);
|
|
AddResType(L"VXD", RT_VXD);
|
|
|
|
// AFX resource types.
|
|
AddResType(L"DLGINIT", RT_DLGINIT);
|
|
AddResType(L"TOOLBAR", RT_TOOLBAR);
|
|
|
|
AddResType(L"ANIICON", RT_ANIICON);
|
|
AddResType(L"ANICURSOR", RT_ANICURSOR);
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* AddFontDir() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
VOID AddFontDir(VOID)
|
|
{
|
|
PRESINFO pRes;
|
|
PTYPEINFO pType;
|
|
PFONTDIR pFont;
|
|
|
|
/* make new resource */
|
|
pRes = (PRESINFO)MyAlloc(sizeof(RESINFO));
|
|
pRes->language = language;
|
|
pRes->version = version;
|
|
pRes->characteristics = characteristics;
|
|
pRes->name = MyMakeStr(L"FONTDIR");
|
|
|
|
/* find or create the type list */
|
|
pType = AddResType(NULL, RT_FONTDIR);
|
|
|
|
CtlInit();
|
|
|
|
WriteWord(nFontsRead);
|
|
|
|
pFont = pFontList;
|
|
|
|
while (pFont) {
|
|
WriteWord(pFont->ordinal);
|
|
WriteBuffer((PCHAR)(pFont + 1), pFont->nbyFont);
|
|
pFont = pFont->next;
|
|
}
|
|
|
|
pRes->flags = NSMOVE | NSPRELOAD;
|
|
|
|
/* write to the .RES file */
|
|
SaveResFile(pType, pRes);
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* ReadRF() - */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
/* top level parsing function: recognizes an RC script */
|
|
|
|
int ReadRF(VOID)
|
|
{
|
|
PRESINFO pRes;
|
|
PTYPEINFO pType;
|
|
ULONG zero=0;
|
|
WORD ffff=0xffff;
|
|
ULONG hdrSize = sizeof(RESADDITIONAL) + 2 * (sizeof(WORD) * 2);
|
|
|
|
ResCount = 0;
|
|
nFontsRead = 0;
|
|
|
|
/* Initialize data structures. */
|
|
AddDefaultTypes();
|
|
|
|
if (!fMacRsrcs)
|
|
{
|
|
/* write 32-bit header for empty resource/signature */
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(ULONG));
|
|
MyWrite(fhBin, (PCHAR)&hdrSize, sizeof(ULONG));
|
|
MyWrite(fhBin, (PCHAR)&ffff, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&ffff, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(ULONG));
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(WORD));
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(ULONG));
|
|
MyWrite(fhBin, (PCHAR)&zero, sizeof(ULONG));
|
|
}
|
|
|
|
CtlAlloc();
|
|
|
|
if (fAFXSymbols) {
|
|
char* pch = inname;
|
|
// write out first HWB resource
|
|
|
|
CtlInit();
|
|
pRes = (PRESINFO)MyAlloc(sizeof(RESINFO));
|
|
pRes->language = language;
|
|
pRes->version = version;
|
|
pRes->characteristics = characteristics;
|
|
|
|
pRes->size = sizeof(DWORD);
|
|
pRes->flags = 0;
|
|
pRes->name = 0;
|
|
pRes->nameord = 1;
|
|
WriteLong(0); /* space for file pointer */
|
|
while (*pch) {
|
|
WriteByte(*pch++);
|
|
pRes->size++;
|
|
}
|
|
WriteByte(0);
|
|
pRes->size++;
|
|
|
|
pType = AddResType(L"HWB", 0);
|
|
SaveResFile(pType, pRes);
|
|
lOffIndex = pRes->BinOffset;
|
|
}
|
|
|
|
/* Process the RC file. */
|
|
do {
|
|
token.sym.name[0] = L'\0';
|
|
token.sym.nID = 0;
|
|
|
|
/* Find the beginning of the next resource. */
|
|
if (!GetNameOrd())
|
|
break;
|
|
|
|
if (!wcscmp(tokenbuf, L"LANGUAGE")) {
|
|
language = GetLanguage();
|
|
continue;
|
|
}
|
|
else if (!wcscmp(tokenbuf, L"VERSION")) {
|
|
GetToken(FALSE);
|
|
if (token.type != NUMLIT)
|
|
ParseError1(2139);
|
|
version = token.longval;
|
|
continue;
|
|
}
|
|
else if (!wcscmp(tokenbuf, L"CHARACTERISTICS")) {
|
|
GetToken(FALSE);
|
|
if (token.type != NUMLIT)
|
|
ParseError1(2140);
|
|
characteristics = token.longval;
|
|
continue;
|
|
}
|
|
|
|
/* Print a dot for each resource processed. */
|
|
if (fVerbose) {
|
|
printf(".");
|
|
}
|
|
|
|
/* Allocate space for the new resources Info structure. */
|
|
pRes = (PRESINFO)MyAlloc(sizeof(RESINFO));
|
|
pRes->language = language;
|
|
pRes->version = version;
|
|
pRes->characteristics = characteristics;
|
|
|
|
if (token.sym.name[0]) {
|
|
/* token has a real symbol associated with it */
|
|
memcpy(&pRes->sym, &token.sym, sizeof(SYMINFO));
|
|
}
|
|
else
|
|
pRes->sym.name[0] = L'\0';
|
|
|
|
if (!token.val) {
|
|
if (wcslen(tokenbuf) > MAXTOKSTR-1) {
|
|
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(4206), curFile, token.row);
|
|
SendError(Msg_Text);
|
|
tokenbuf[MAXTOKSTR-1] = L'\0';
|
|
token.val = MAXTOKSTR-2;
|
|
}
|
|
pRes->name = MyMakeStr(tokenbuf);
|
|
}
|
|
else
|
|
pRes->nameord = token.val;
|
|
|
|
/* If not a string table, find out what kind of resource follows.
|
|
* The StringTable is a special case since the Name field is the
|
|
* string's ID number mod 16.
|
|
*/
|
|
if ((pRes->name == NULL) || wcscmp(pRes->name, L"STRINGTABLE")) {
|
|
if (!GetNameOrd())
|
|
break;
|
|
|
|
if (!token.val) {
|
|
if (wcslen(tokenbuf) > MAXTOKSTR-1) {
|
|
SET_MSG(Msg_Text, sizeof(Msg_Text), GET_MSG(4207), curFile, token.row);
|
|
SendError(Msg_Text);
|
|
tokenbuf[MAXTOKSTR-1] = L'\0';
|
|
token.val = MAXTOKSTR-2;
|
|
}
|
|
pType = AddResType(tokenbuf, MAKEINTRESOURCE(0));
|
|
}
|
|
else
|
|
pType = AddResType(NULL, MAKEINTRESOURCE(token.val));
|
|
|
|
if (!pType)
|
|
return(errorCount == 0);
|
|
|
|
/* Parse any user specified memory flags. */
|
|
GetToken(FALSE);
|
|
|
|
switch ((INT)pType->typeord) {
|
|
/* Calculated resources default to discardable. */
|
|
case (int)RT_ICON:
|
|
case (int)RT_CURSOR:
|
|
case (int)RT_FONT:
|
|
case (int)RT_DIALOG:
|
|
case (int)RT_MENU:
|
|
case (int)RT_DLGINCLUDE:
|
|
case (int)RT_DIALOGEX:
|
|
case (int)RT_MENUEX:
|
|
pRes->flags = NSMOVE | NSPURE | NSDISCARD;
|
|
break;
|
|
|
|
case (int)RT_GROUP_ICON:
|
|
case (int)RT_GROUP_CURSOR:
|
|
pRes->flags = NSMOVE | NSDISCARD;
|
|
break;
|
|
|
|
/* All other resources default to moveable. */
|
|
default:
|
|
pRes->flags = NSMOVE | NSPURE;
|
|
break;
|
|
}
|
|
|
|
/* adjust according to the user's specifications
|
|
*/
|
|
while (DGetMemFlags(pRes))
|
|
;
|
|
|
|
// write out start of new resource
|
|
WriteResInfo(pRes, pType, FALSE);
|
|
}
|
|
else {
|
|
|
|
/* Parse any user specified memory flags. */
|
|
GetToken(FALSE);
|
|
|
|
/* String and Error resources default to discardable. */
|
|
pRes->flags = NSMOVE | NSPURE | NSDISCARD;
|
|
while (DGetMemFlags(pRes))
|
|
;
|
|
|
|
pType = NULL;
|
|
}
|
|
|
|
if (!pType) {
|
|
/* parse the string table, if that's what it is */
|
|
if ((pRes->name != NULL) && (!wcscmp(pRes->name, L"STRINGTABLE"))) {
|
|
if (GetTable(pRes) == NULL)
|
|
break;
|
|
}
|
|
else
|
|
ParseError1(2141);
|
|
}
|
|
else {
|
|
CtlInit();
|
|
pRes->size = 0L;
|
|
|
|
/* call parsing and generating functions specific to the various
|
|
resource types */
|
|
switch ((INT)pType->typeord) {
|
|
case (int)RT_DIALOGEX:
|
|
/* allocate dialog memory */
|
|
pLocDlg = (PDLGHDR) MyAlloc(sizeof(DLGHDR));
|
|
|
|
/* parse dialog box */
|
|
GetDlg(pRes, pLocDlg, TRUE);
|
|
|
|
/* write dialog box */
|
|
SaveResFile(AddResType(L"DIALOG", 0), pRes);
|
|
|
|
/* free dialog memory */
|
|
MyFree(pLocDlg);
|
|
break;
|
|
|
|
case (int)RT_DIALOG:
|
|
/* allocate dialog memory */
|
|
pLocDlg = (PDLGHDR) MyAlloc(sizeof(DLGHDR));
|
|
|
|
/* parse dialog box */
|
|
GetDlg(pRes, pLocDlg, FALSE);
|
|
|
|
/* write dialog box */
|
|
SaveResFile(pType, pRes);
|
|
|
|
/* free dialog memory */
|
|
MyFree(pLocDlg);
|
|
break;
|
|
|
|
case (int)RT_ACCELERATOR:
|
|
GetAccelerators(pRes);
|
|
SaveResFile(pType, pRes);
|
|
break;
|
|
|
|
case (int)RT_MENUEX:
|
|
WriteWord(MENUITEMTEMPLATEVERSIONNUMBER);
|
|
WriteWord(MENUITEMTEMPLATEBYTESINHEADER);
|
|
ParseMenu(FALSE, pRes);
|
|
SaveResFile(AddResType(L"MENU", 0), pRes);
|
|
break;
|
|
|
|
case (int)RT_MENU:
|
|
WriteWord(OLDMENUITEMTEMPLATEVERSIONNUMBER);
|
|
WriteWord(OLDMENUITEMTEMPLATEBYTESINHEADER);
|
|
ParseOldMenu(FALSE, pRes);
|
|
SaveResFile(pType, pRes);
|
|
break;
|
|
|
|
case (int)RT_ICON:
|
|
case (int)RT_CURSOR:
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
pRes->size = GetFileName();
|
|
if (FileIsAnimated(pRes->size))
|
|
goto ani;
|
|
else if (pRes->size) {
|
|
pRes->size = GetIcon(pRes->size);
|
|
SaveResFile(pType, pRes);
|
|
}
|
|
break;
|
|
|
|
ani:
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
pRes->size = GetFileName();
|
|
if (pRes->size) {
|
|
pRes->size = GetAniIconsAniCursors(pRes->size);
|
|
SaveResFile(pType, pRes);
|
|
}
|
|
break;
|
|
|
|
case (int)RT_BITMAP:
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
pRes->size = GetFileName();
|
|
if (pRes->size) {
|
|
/* Bitmap in DIB format */
|
|
pRes ->size = GetNewBitmap();
|
|
SaveResFile(pType, pRes);
|
|
}
|
|
break;
|
|
|
|
case (int)RT_GROUP_ICON:
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
pRes->size = GetFileName();
|
|
if (FileIsAnimated(pRes->size))
|
|
goto ani;
|
|
else if (pRes->size) {
|
|
if (fMacRsrcs)
|
|
GetMacIcon(pType, pRes);
|
|
else
|
|
GetNewIconsCursors(pType, pRes, RT_ICON);
|
|
}
|
|
break;
|
|
|
|
case (int)RT_GROUP_CURSOR:
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
pRes->size = GetFileName();
|
|
if (FileIsAnimated(pRes->size))
|
|
goto ani;
|
|
else if (pRes->size) {
|
|
if (fMacRsrcs)
|
|
GetMacCursor(pType, pRes);
|
|
else
|
|
GetNewIconsCursors(pType, pRes, RT_CURSOR);
|
|
}
|
|
break;
|
|
|
|
case (int)RT_FONT:
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
pRes->size = GetFileName();
|
|
if (pRes->name)
|
|
ParseError1(2143);
|
|
if (AddFontRes(pRes)) {
|
|
nFontsRead++;
|
|
SaveResFile(pType, pRes);
|
|
}
|
|
break;
|
|
|
|
case (int)RT_FONTDIR:
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
fFontDirRead = TRUE;
|
|
pRes->size = GetFileName();
|
|
if (pRes->size) {
|
|
SaveResFile(pType, pRes);
|
|
}
|
|
break;
|
|
|
|
case (int)RT_MESSAGETABLE:
|
|
pRes->size = GetFileName();
|
|
if (pRes->size) {
|
|
SaveResFile(pType, pRes);
|
|
}
|
|
break;
|
|
|
|
case (int)RT_VERSION:
|
|
VersionParse();
|
|
SaveResFile(pType, pRes);
|
|
break;
|
|
|
|
case (int)RT_DLGINCLUDE:
|
|
DlgIncludeParse(pRes);
|
|
SaveResFile(pType, pRes);
|
|
break;
|
|
|
|
case (int)RT_TOOLBAR:
|
|
GetToolbar(pRes);
|
|
SaveResFile(pType, pRes);
|
|
break;
|
|
|
|
case (int)RT_RCDATA:
|
|
case (int)RT_DLGINIT:
|
|
default:
|
|
if (token.type != BEGIN) {
|
|
pRes->size = GetFileName();
|
|
if (pRes->size) {
|
|
WriteFileInfo(pRes, pType, tokenbuf);
|
|
}
|
|
}
|
|
else {
|
|
RESINFO_PARSE rip;
|
|
|
|
bExternParse = FALSE;
|
|
|
|
// Check to see if caller wants to parse this.
|
|
if (lpfnParseCallback != NULL) {
|
|
rip.size = 0L;
|
|
rip.type = pType->type;
|
|
rip.typeord = pType->typeord;
|
|
rip.name = pRes->name;
|
|
rip.nameord = pRes->nameord;
|
|
rip.flags = pRes->flags;
|
|
rip.language = pRes->language;
|
|
rip.version = pRes->version;
|
|
rip.characteristics = pRes->characteristics;
|
|
|
|
bExternParse = (*lpfnParseCallback)(&rip, NULL, NULL);
|
|
}
|
|
|
|
if (!bExternParse)
|
|
GetRCData(pRes);
|
|
else {
|
|
CONTEXTINFO_PARSE cip;
|
|
CHAR mbuff[512]; // REVIEW: Long filenames?? See error.c also.
|
|
|
|
extern PCHAR CodeArray;
|
|
extern int CodeSize;
|
|
extern int CCount;
|
|
|
|
int nBegins = 1;
|
|
int nCountSave; // CCount before END token reached
|
|
|
|
cip.hHeap = hHeap;
|
|
cip.hWndCaller = hWndCaller;
|
|
cip.lpfnMsg = lpfnMessageCallback;
|
|
cip.line = token.row;
|
|
|
|
wsprintfA(mbuff, "%s(%%d) : %%s", curFile);
|
|
cip.format = mbuff;
|
|
|
|
// Collect data for caller to parse.
|
|
while(nBegins > 0) {
|
|
nCountSave = CCount;
|
|
GetToken(FALSE);
|
|
if (token.type == BEGIN)
|
|
nBegins++;
|
|
else if (token.type == END)
|
|
nBegins--;
|
|
}
|
|
|
|
bExternParse = FALSE;
|
|
|
|
if ((rip.size = nCountSave) > 0 &&
|
|
!(*lpfnParseCallback)(&rip, &CodeArray, &cip)) {
|
|
// Assume caller gave error message, and quit.
|
|
quit("\n");
|
|
}
|
|
|
|
pRes->size = CCount = CodeSize = rip.size;
|
|
}
|
|
}
|
|
|
|
SaveResFile(pType, pRes);
|
|
break;
|
|
}
|
|
// write out end of new resource
|
|
WriteResInfo(NULL, NULL, FALSE);
|
|
}
|
|
} while (token.type != EOFMARK);
|
|
|
|
/* if we added fonts without a font directory, add one */
|
|
if (!fFontDirRead && nFontsRead)
|
|
AddFontDir();
|
|
|
|
/* write string table */
|
|
if (pResString != NULL)
|
|
WriteTable(pResString);
|
|
|
|
/* write Mac resource map */
|
|
if (fMacRsrcs)
|
|
WriteMacMap();
|
|
|
|
CtlFree();
|
|
|
|
if (fVerbose) {
|
|
printf("\n");
|
|
}
|
|
return(errorCount == 0);
|
|
}
|
|
|
|
|
|
WORD
|
|
GetLanguage()
|
|
{
|
|
WORD language;
|
|
|
|
GetToken(FALSE);
|
|
if (token.type != NUMLIT) {
|
|
ParseError1(2144);
|
|
return MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
}
|
|
if (token.flongval) {
|
|
ParseError1(2145);
|
|
return MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
}
|
|
language = token.val;
|
|
GetToken(FALSE);
|
|
if (token.type != COMMA) {
|
|
ParseError1(2146);
|
|
return MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
}
|
|
GetToken(FALSE);
|
|
if (token.type != NUMLIT) {
|
|
ParseError1(2147);
|
|
return MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
}
|
|
if (token.flongval) {
|
|
ParseError1(2148);
|
|
return MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
}
|
|
|
|
return MAKELANGID(language, token.val);
|
|
}
|