static void NewSymbol (const char* SymName, long Val)
/* Define a symbol with a fixed numeric value in the current scope */
{
ExprNode* Expr;
SymEntry* Sym;
/* Convert the name to a string buffer */
StrBuf SymBuf = STATIC_STRBUF_INITIALIZER;
SB_CopyStr (&SymBuf, SymName);
/* Search for the symbol, allocate a new one if it doesn't exist */
Sym = SymFind (CurrentScope, &SymBuf, SYM_ALLOC_NEW);
/* Check if have already a symbol with this name */
if (SymIsDef (Sym)) {
AbEnd ("`%s' is already defined", SymName);
}
/* Generate an expression for the symbol */
Expr = GenLiteralExpr (Val);
/* Mark the symbol as defined */
SymDef (Sym, Expr, ADDR_SIZE_DEFAULT, SF_NONE);
/* Free string buffer memory */
SB_Done (&SymBuf);
}
void AddSubSearchPathFromEnv (SearchPaths* P, const char* EnvVar, const char* SubDir)
/* Add a search path from an environment variable, adding a subdirectory to
** the environment variable value.
*/
{
StrBuf Dir = AUTO_STRBUF_INITIALIZER;
const char* EnvVal = getenv (EnvVar);
if (EnvVal == 0) {
/* Not found */
return;
}
/* Copy the environment variable to the buffer */
SB_CopyStr (&Dir, EnvVal);
/* Add a path separator if necessary */
if (SB_NotEmpty (&Dir)) {
if (SB_LookAtLast (&Dir) != '\\' && SB_LookAtLast (&Dir) != '/') {
SB_AppendChar (&Dir, '/');
}
}
/* Add the subdirectory and terminate the string */
SB_AppendStr (&Dir, SubDir);
SB_Terminate (&Dir);
/* Add the search path */
AddSearchPath (P, SB_GetConstBuf (&Dir));
/* Free the temp buffer */
SB_Done (&Dir);
}
char* SearchFile (const SearchPaths* P, const char* File)
/* Search for a file in a list of directories. Return a pointer to a malloced
** area that contains the complete path, if found, return 0 otherwise.
*/
{
char* Name = 0;
StrBuf PathName = AUTO_STRBUF_INITIALIZER;
/* Start the search */
unsigned I;
for (I = 0; I < CollCount (P); ++I) {
/* Copy the next path element into the buffer */
SB_CopyStr (&PathName, CollConstAt (P, I));
/* Add a path separator and the filename */
if (SB_NotEmpty (&PathName)) {
SB_AppendChar (&PathName, '/');
}
SB_AppendStr (&PathName, File);
SB_Terminate (&PathName);
/* Check if this file exists */
if (access (SB_GetBuf (&PathName), 0) == 0) {
/* The file exists, we're done */
Name = xstrdup (SB_GetBuf (&PathName));
break;
}
}
/* Cleanup and return the result of the search */
SB_Done (&PathName);
return Name;
}
static void OpenDebugFile (const CodeSeg* S)
/* Open the debug file for the given segment if the flag is on */
{
if (DebugOptOutput) {
StrBuf Name = AUTO_STRBUF_INITIALIZER;
if (S->Func) {
SB_CopyStr (&Name, S->Func->Name);
} else {
SB_CopyStr (&Name, "global");
}
SB_AppendStr (&Name, ".opt");
SB_Terminate (&Name);
OpenDebugOutputFile (SB_GetConstBuf (&Name));
SB_Done (&Name);
}
}
static void FileNameOption (const char* Opt, const char* Arg, StrBuf* Name)
/* Handle an option that remembers a file name for later */
{
/* Cannot have the option twice */
if (SB_NotEmpty (Name)) {
AbEnd ("Cannot use option `%s' twice", Opt);
}
/* Remember the file name for later */
SB_CopyStr (Name, Arg);
SB_Terminate (Name);
}
static void DoPragma (void)
/* Handle a #pragma line by converting the #pragma preprocessor directive into
* the _Pragma() compiler operator.
*/
{
/* Skip blanks following the #pragma directive */
SkipWhitespace (0);
/* Copy the remainder of the line into MLine removing comments and ws */
SB_Clear (MLine);
Pass1 (Line, MLine);
/* Convert the directive into the operator */
SB_CopyStr (Line, "_Pragma (");
SB_Reset (MLine);
Stringize (MLine, Line);
SB_AppendChar (Line, ')');
/* Initialize reading from line */
SB_Reset (Line);
InitLine (Line);
}
static void FuncSPrintF (void)
/* Handle the .SPRINTF function */
{
StrBuf Format = STATIC_STRBUF_INITIALIZER; /* User supplied format */
StrBuf R = STATIC_STRBUF_INITIALIZER; /* Result string */
StrBuf F1 = STATIC_STRBUF_INITIALIZER; /* One format spec from F */
StrBuf R1 = STATIC_STRBUF_INITIALIZER; /* One result */
char C;
int Done;
long IVal; /* Integer value */
/* Skip the .SPRINTF token */
NextTok ();
/* Left paren expected */
ConsumeLParen ();
/* First argument is a format string. Remember and skip it */
if (!LookAtStrCon ()) {
return;
}
SB_Copy (&Format, &CurTok.SVal);
NextTok ();
/* Walk over the format string, generating the function result in R */
while (1) {
/* Get the next char from the format string and check for EOS */
if (SB_Peek (&Format) == '\0') {
break;
}
/* Check for a format specifier */
if (SB_Peek (&Format) != '%') {
/* No format specifier, just copy */
SB_AppendChar (&R, SB_Get (&Format));
continue;
}
SB_Skip (&Format);
if (SB_Peek (&Format) == '%') {
/* %% */
SB_AppendChar (&R, '%');
SB_Skip (&Format);
continue;
}
if (SB_Peek (&Format) == '\0') {
InvalidFormatString ();
break;
}
/* Since a format specifier follows, we do expect anotehr argument for
* the .sprintf function.
*/
ConsumeComma ();
/* We will copy the format spec into F1 checking for the things we
* support, and later use xsprintf to do the actual formatting. This
* is easier than adding another printf implementation...
*/
SB_Clear (&F1);
SB_AppendChar (&F1, '%');
/* Check for flags */
Done = 0;
while ((C = SB_Peek (&Format)) != '\0' && !Done) {
switch (C) {
case '-': /* FALLTHROUGH */
case '+': /* FALLTHROUGH */
case ' ': /* FALLTHROUGH */
case '#': /* FALLTHROUGH */
case '0': SB_AppendChar (&F1, SB_Get (&Format)); break;
default: Done = 1; break;
}
}
/* We do only support a numerical width field */
while (IsDigit (SB_Peek (&Format))) {
SB_AppendChar (&F1, SB_Get (&Format));
}
/* Precision - only positive numerical fields supported */
if (SB_Peek (&Format) == '.') {
SB_AppendChar (&F1, SB_Get (&Format));
while (IsDigit (SB_Peek (&Format))) {
SB_AppendChar (&F1, SB_Get (&Format));
}
}
/* Length modifiers aren't supported, so read the conversion specs */
switch (SB_Peek (&Format)) {
case 'd':
case 'i':
case 'o':
case 'u':
case 'X':
case 'x':
/* Our ints are actually longs, so we use the 'l' modifier when
* calling xsprintf later. Terminate the format string.
*/
SB_AppendChar (&F1, 'l');
SB_AppendChar (&F1, SB_Get (&Format));
SB_Terminate (&F1);
/* The argument must be a constant expression */
IVal = ConstExpression ();
/* Format this argument according to the spec */
SB_Printf (&R1, SB_GetConstBuf (&F1), IVal);
/* Append the formatted argument to the result */
SB_Append (&R, &R1);
break;
case 's':
/* Add the format spec and terminate the format */
SB_AppendChar (&F1, SB_Get (&Format));
SB_Terminate (&F1);
/* The argument must be a string constant */
if (!LookAtStrCon ()) {
/* Make it one */
SB_CopyStr (&CurTok.SVal, "**undefined**");
}
/* Format this argument according to the spec */
SB_Printf (&R1, SB_GetConstBuf (&F1), SB_GetConstBuf (&CurTok.SVal));
/* Skip the string constant */
NextTok ();
/* Append the formatted argument to the result */
SB_Append (&R, &R1);
break;
case 'c':
/* Add the format spec and terminate the format */
SB_AppendChar (&F1, SB_Get (&Format));
SB_Terminate (&F1);
/* The argument must be a constant expression */
IVal = ConstExpression ();
/* Check for a valid character range */
if (IVal <= 0 || IVal > 255) {
Error ("Char argument out of range");
IVal = ' ';
}
/* Format this argument according to the spec. Be sure to pass
* an int as the char value.
*/
SB_Printf (&R1, SB_GetConstBuf (&F1), (int) IVal);
/* Append the formatted argument to the result */
SB_Append (&R, &R1);
break;
default:
Error ("Invalid format string");
SB_Skip (&Format);
break;
}
}
/* Terminate the result string */
SB_Terminate (&R);
/* We expect a closing parenthesis, but will not skip it but replace it
* by the string token just created.
*/
if (CurTok.Tok != TOK_RPAREN) {
Error ("`)' expected");
} else {
CurTok.Tok = TOK_STRCON;
SB_Copy (&CurTok.SVal, &R);
SB_Terminate (&CurTok.SVal);
}
/* Delete the string buffers */
SB_Done (&Format);
SB_Done (&R);
SB_Done (&F1);
SB_Done (&R1);
}
Bitmap* ReadPCXFile (const Collection* A)
/* Read a bitmap from a PCX file */
{
PCXHeader* P;
Bitmap* B;
unsigned char* L;
Pixel* Px;
unsigned MaxIdx = 0;
unsigned X, Y;
/* Get the file name */
const char* Name = NeedAttrVal (A, "name", "read pcx file");
/* Open the file */
FILE* F = fopen (Name, "rb");
if (F == 0) {
Error ("Cannot open PCX file `%s': %s", Name, strerror (errno));
}
/* Read the PCX header */
P = ReadPCXHeader (F, Name);
/* Dump the header if requested */
if (Verbosity > 0) {
DumpPCXHeader (P, Name);
}
/* Create the bitmap */
B = NewBitmap (P->Width, P->Height);
/* Copy the name */
SB_CopyStr (&B->Name, Name);
/* Allocate memory for the scan line */
L = xmalloc (P->Width);
/* Read the pixel data */
Px = B->Data;
if (P->Planes == 1) {
/* This is either monochrome or indexed */
if (P->BPP == 1) {
/* Monochrome */
for (Y = 0, Px = B->Data; Y < P->Height; ++Y) {
unsigned I;
unsigned char Mask;
/* Read the plane */
ReadPlane (F, P, L);
/* Create pixels */
for (X = 0, I = 0, Mask = 0x01; X < P->Width; ++Px) {
Px->Index = (L[I] & Mask) != 0;
if (Mask == 0x80) {
Mask = 0x01;
++I;
} else {
Mask <<= 1;
}
}
}
} else {
/* One plane with 8bpp is indexed */
for (Y = 0, Px = B->Data; Y < P->Height; ++Y) {
/* Read the plane */
ReadPlane (F, P, L);
/* Create pixels */
for (X = 0; X < P->Width; ++X, ++Px) {
if (L[X] > MaxIdx) {
MaxIdx = L[X];
}
Px->Index = L[X];
}
}
}
/* One plane means we have a palette which is either part of the header
** or follows.
*/
if (P->PalInfo == 0) {
/* Create the monochrome palette */
B->Pal = NewMonochromePalette ();
} else {
unsigned Count;
unsigned I;
unsigned char Palette[256][3];
unsigned long EndPos;
/* Determine the current file position */
unsigned long CurPos = FileGetPos (F);
/* Seek to the end of the file */
(void) fseek (F, 0, SEEK_END);
/* Get this position */
EndPos = FileGetPos (F);
/* There's a palette if the old location is 769 bytes from the end */
if (EndPos - CurPos == sizeof (Palette) + 1) {
/* Seek back */
FileSetPos (F, CurPos);
/* Check for palette marker */
if (Read8 (F) != 0x0C) {
Error ("Invalid palette marker in PCX file `%s'", Name);
}
} else if (EndPos == CurPos) {
/* The palette is in the header */
FileSetPos (F, 16);
/* Check the maximum index for safety */
if (MaxIdx > 15) {
Error ("PCX file `%s' contains more than 16 indexed colors "
"but no extra palette", Name);
}
} else {
Error ("Error in PCX file `%s': %lu bytes at end of pixel data",
Name, EndPos - CurPos);
}
/* Read the palette. We will just read what we need. */
Count = MaxIdx + 1;
ReadData (F, Palette, Count * sizeof (Palette[0]));
/* Create the palette from the data */
B->Pal = NewPalette (Count);
for (I = 0; I < Count; ++I) {
B->Pal->Entries[I].R = Palette[I][0];
B->Pal->Entries[I].G = Palette[I][1];
B->Pal->Entries[I].B = Palette[I][2];
B->Pal->Entries[I].A = 0;
}
}
} else {
/* 3 or 4 planes are RGB or RGBA (don't know if this exists) */
for (Y = 0, Px = B->Data; Y < P->Height; ++Y) {
/* Read the R plane and move the data */
ReadPlane (F, P, L);
for (X = 0; X < P->Width; ++X, ++Px) {
Px->C.R = L[X];
}
/* Read the G plane and move the data */
ReadPlane (F, P, L);
for (X = 0; X < P->Width; ++X, ++Px) {
Px->C.G = L[X];
}
/* Read the B plane and move the data */
ReadPlane (F, P, L);
for (X = 0; X < P->Width; ++X, ++Px) {
Px->C.B = L[X];
}
/* Either read the A plane or clear it */
if (P->Planes == 4) {
ReadPlane (F, P, L);
for (X = 0; X < P->Width; ++X, ++Px) {
Px->C.A = L[X];
}
} else {
for (X = 0; X < P->Width; ++X, ++Px) {
Px->C.A = 0;
}
}
}
}
/* Close the file */
fclose (F);
/* Free memory for the scan line */
xfree (L);
/* Free the PCX header */
FreePCXHeader (P);
/* Return the bitmap */
return B;
}
void CfgNextTok (void)
/* Read the next token from the input stream */
{
Again:
/* Skip whitespace */
while (isspace (C)) {
NextChar ();
}
/* Remember the current position */
CfgErrorPos = InputPos;
/* Identifier? */
if (C == '_' || IsAlpha (C)) {
/* Read the identifier */
SB_Clear (&CfgSVal);
while (C == '_' || IsAlNum (C)) {
SB_AppendChar (&CfgSVal, C);
NextChar ();
}
SB_Terminate (&CfgSVal);
CfgTok = CFGTOK_IDENT;
return;
}
/* Hex number? */
if (C == '$') {
NextChar ();
if (!isxdigit (C)) {
CfgError (&CfgErrorPos, "Hex digit expected");
}
CfgIVal = 0;
while (isxdigit (C)) {
CfgIVal = CfgIVal * 16 + DigitVal (C);
NextChar ();
}
CfgTok = CFGTOK_INTCON;
return;
}
/* Decimal number? */
if (isdigit (C)) {
CfgIVal = 0;
while (isdigit (C)) {
CfgIVal = CfgIVal * 10 + DigitVal (C);
NextChar ();
}
CfgTok = CFGTOK_INTCON;
return;
}
/* Other characters */
switch (C) {
case '-':
NextChar ();
CfgTok = CFGTOK_MINUS;
break;
case '+':
NextChar ();
CfgTok = CFGTOK_PLUS;
break;
case '*':
NextChar ();
CfgTok = CFGTOK_MUL;
break;
case '/':
NextChar ();
CfgTok = CFGTOK_DIV;
break;
case '(':
NextChar ();
CfgTok = CFGTOK_LPAR;
break;
case ')':
NextChar ();
CfgTok = CFGTOK_RPAR;
break;
case '{':
NextChar ();
CfgTok = CFGTOK_LCURLY;
break;
case '}':
NextChar ();
CfgTok = CFGTOK_RCURLY;
break;
case ';':
NextChar ();
CfgTok = CFGTOK_SEMI;
break;
case '.':
NextChar ();
CfgTok = CFGTOK_DOT;
break;
case ',':
NextChar ();
CfgTok = CFGTOK_COMMA;
break;
case '=':
NextChar ();
CfgTok = CFGTOK_EQ;
break;
case ':':
NextChar ();
CfgTok = CFGTOK_COLON;
break;
case '\"':
StrVal ();
break;
case '#':
/* Comment */
while (C != '\n' && C != EOF) {
NextChar ();
}
if (C != EOF) {
goto Again;
}
CfgTok = CFGTOK_EOF;
break;
case '%':
NextChar ();
switch (C) {
case 'O':
NextChar ();
if (OutputName) {
SB_CopyStr (&CfgSVal, OutputName);
} else {
SB_Clear (&CfgSVal);
}
SB_Terminate (&CfgSVal);
OutputNameUsed = 1;
CfgTok = CFGTOK_STRCON;
break;
case 'S':
NextChar ();
CfgIVal = StartAddr;
CfgTok = CFGTOK_INTCON;
break;
default:
CfgError (&CfgErrorPos, "Invalid format specification");
}
break;
case EOF:
CfgTok = CFGTOK_EOF;
break;
default:
CfgError (&CfgErrorPos, "Invalid character `%c'", C);
}
}
