583 lines
15 KiB
Plaintext
583 lines
15 KiB
Plaintext
%{
|
|
#include "rsys/common.h"
|
|
#include "rsys/options.h"
|
|
#include "rsys/prefs.h"
|
|
#include "rsys/crc.h"
|
|
#include "rsys/parse.h"
|
|
#include "rsys/parseopt.h"
|
|
#include "rsys/gestalt.h"
|
|
#include "rsys/launch.h"
|
|
#include "rsys/print.h"
|
|
#include "rsys/version.h"
|
|
|
|
/* Copyright 1992 - 2000 by Abacus Research and Development, Inc.
|
|
* All rights reserved.
|
|
*/
|
|
|
|
#if !defined (OMIT_RCSID_STRINGS)
|
|
char ROMlib_rcsid_parse[] =
|
|
"$Id: parse.y,v 2.26 2000/02/12 05:31:08 ctm Exp $";
|
|
#endif
|
|
|
|
static long yylex( void );
|
|
static void freestring( char *string );
|
|
char validblock = 1;
|
|
char *ROMlib_win32_token = 0;
|
|
char *ROMlib_WindowName = 0;
|
|
char *ROMlib_DongleFamily = 0;
|
|
char *ROMlib_Comments = 0;
|
|
char *ROMlib_new_printer_name = 0;
|
|
char *ROMlib_new_label = 0;
|
|
static char *ROMlib_mac_cdrom;
|
|
pair_t ROMlib_ScreenSize = { INITIALPAIRVALUE, INITIALPAIRVALUE };
|
|
pair_t ROMlib_MacSize = { INITIALPAIRVALUE, INITIALPAIRVALUE };
|
|
pair_t ROMlib_ScreenLocation = { INITIALPAIRVALUE, INITIALPAIRVALUE };
|
|
unsigned short crcval;
|
|
int ROMlib_AppleChar = 0;
|
|
int ROMlib_right_button_modifier = 0;
|
|
|
|
void yyerror(const char *str);
|
|
%}
|
|
|
|
%start configuration
|
|
|
|
%union { long number; char *cptr; char **cptrptr; pair_t *pptr; int *iptr;
|
|
unsigned long rtype;};
|
|
|
|
%token STRINGCONSTANT /* ptr points to null-terminated string */
|
|
%token HEXCONSTANT /* number */
|
|
%token INTEGERCONSTANT /* number */
|
|
%token CHAR4CONSTANT
|
|
%token OPTIONSCONSTANT /* number */
|
|
%token WINDOWNAME /* ptr points to null-terminated string */
|
|
%token DONGLEFAMILY /* ptr points to null-terminated string */
|
|
%token SYSTEMVERSION
|
|
%token COMMENTS
|
|
%token RDELAY
|
|
%token SCREENSIZE
|
|
%token MACSIZE
|
|
%token SCREENLOCATION
|
|
%token REFRESHNUMBER
|
|
%token CRC
|
|
%token OPTIONS
|
|
%token CACHEPROBLEMS
|
|
%token BITSNUMBER
|
|
%token APPLECHAR
|
|
%token PRINTERNAME
|
|
%token PRINTERTYPELABEL
|
|
%token WIN32TOKEN
|
|
%token MACCDROM
|
|
%token RIGHT_BUTTON_MODIFIER
|
|
%token GESTALT
|
|
%token APP_VERSION
|
|
%token PRVERSION
|
|
|
|
%type <cptr> STRINGCONSTANT
|
|
%type <number> HEXCONSTANT INTEGERCONSTANT OPTIONSCONSTANT
|
|
%type <rtype> CHAR4CONSTANT
|
|
%type <cptrptr> stringvar
|
|
%type <iptr> optionsvar
|
|
%type <iptr> numervar
|
|
%type <number> number optionvalues
|
|
%type <pptr> pairvar
|
|
%type <number> blockbegin /* holds previous validblock */
|
|
%type <number> gestalt_entry
|
|
|
|
%%
|
|
|
|
configuration: /* empty */
|
|
| assignmentsandblocks
|
|
;
|
|
|
|
assignmentsandblocks: assignment
|
|
| block
|
|
| assignmentsandblocks assignment
|
|
| assignmentsandblocks block
|
|
;
|
|
|
|
assignment: stringassignment
|
|
| arrayassignment
|
|
| optionsassignment
|
|
| numerassignment
|
|
| sysversassignment
|
|
| prversassignment
|
|
;
|
|
|
|
block: blockbegin '{' assignments '}' ';'
|
|
{
|
|
validblock = $1;
|
|
}
|
|
;
|
|
|
|
assignments: assignment
|
|
| assignments assignment
|
|
;
|
|
|
|
blockbegin: CRC '(' CHAR4CONSTANT ',' INTEGERCONSTANT ')' ':' HEXCONSTANT
|
|
{
|
|
$$ = validblock;
|
|
crcval = getthecrc($3, $5);
|
|
validblock = $8 == crcval;
|
|
if (ROMlib_options & ROMLIB_DEBUG_BIT)
|
|
printf("CRC('%c%c%c%c', %d) = 0x%04lx\n", (int) $3>>24,
|
|
(int) $3>>16, (int) $3>>8, (int) $3, (int) $5, (long) crcval);
|
|
}
|
|
| APP_VERSION '(' HEXCONSTANT ')' ':' HEXCONSTANT
|
|
{
|
|
$$ = validblock;
|
|
validblock = (ROMlib_version_long & $3) == $6;
|
|
}
|
|
;
|
|
|
|
stringassignment: stringvar '=' STRINGCONSTANT ';'
|
|
{
|
|
if (validblock)
|
|
{
|
|
if (*$1)
|
|
free (*$1);
|
|
*$1 = strdup ($3);
|
|
freestring ($3);
|
|
}
|
|
else
|
|
freestring($3);
|
|
}
|
|
;
|
|
|
|
sysversassignment: SYSTEMVERSION '=' number ';'
|
|
{
|
|
if (validblock)
|
|
ROMlib_set_system_version
|
|
(CREATE_SYSTEM_VERSION ($3, 0, 0));
|
|
}
|
|
|
|
|
SYSTEMVERSION '=' number '.' number ';'
|
|
{
|
|
if (validblock)
|
|
ROMlib_set_system_version
|
|
(CREATE_SYSTEM_VERSION ($3, $5, 0));
|
|
}
|
|
|
|
|
SYSTEMVERSION '=' number '.' number '.' number ';'
|
|
{
|
|
if (validblock)
|
|
ROMlib_set_system_version
|
|
(CREATE_SYSTEM_VERSION ($3, $5, $7));
|
|
}
|
|
;
|
|
|
|
|
|
prversassignment: PRVERSION '=' number ';'
|
|
{
|
|
if (validblock)
|
|
ROMlib_PrDrvrVers = $3 * 10;
|
|
}
|
|
|
|
|
PRVERSION '=' number '.' number ';'
|
|
{
|
|
if (validblock)
|
|
ROMlib_PrDrvrVers = $3 * 10 + $5;
|
|
}
|
|
;
|
|
|
|
|
|
numerassignment: numervar '=' number ';'
|
|
{
|
|
if (validblock)
|
|
*$1 = $3;
|
|
}
|
|
;
|
|
|
|
stringvar: WINDOWNAME
|
|
{ $$ = &ROMlib_WindowName; }
|
|
| COMMENTS
|
|
{ $$ = &ROMlib_Comments; }
|
|
| DONGLEFAMILY
|
|
{ $$ = &ROMlib_DongleFamily; }
|
|
| PRINTERNAME
|
|
{ $$ = &ROMlib_new_printer_name; }
|
|
| PRINTERTYPELABEL
|
|
{ $$ = &ROMlib_new_label; }
|
|
| WIN32TOKEN
|
|
{ $$ = &ROMlib_win32_token; }
|
|
| MACCDROM
|
|
{ $$ = &ROMlib_mac_cdrom;
|
|
warning_unexpected ("MacCDROM no longer supported "
|
|
"in configuration files"); }
|
|
;
|
|
|
|
numervar: RDELAY
|
|
{ $$ = &ROMlib_delay; }
|
|
| REFRESHNUMBER
|
|
{ $$ = &ROMlib_refresh; }
|
|
| BITSNUMBER
|
|
{ $$ = &ROMlib_desired_bpp; }
|
|
| APPLECHAR
|
|
{ $$ = &ROMlib_AppleChar; }
|
|
| RIGHT_BUTTON_MODIFIER
|
|
{ $$ = &ROMlib_right_button_modifier; }
|
|
;
|
|
|
|
optionvalues: optionvalues ',' OPTIONSCONSTANT
|
|
{ $$ = $1 | $3; }
|
|
| OPTIONSCONSTANT
|
|
{ $$ = $1; }
|
|
;
|
|
|
|
optionsvar: OPTIONS
|
|
{
|
|
if (validblock)
|
|
{
|
|
$$ = &ROMlib_options;
|
|
ROMlib_options = 0;
|
|
}
|
|
}
|
|
;
|
|
|
|
optionsassignment: optionsvar '=' '{' optionvalues '}' ';'
|
|
{ if (validblock)
|
|
*$1 = $4;
|
|
}
|
|
| optionsvar '=' '{' '}' ';'
|
|
{
|
|
if (validblock)
|
|
*$1 = 0;
|
|
}
|
|
| optionsvar '=' '{' optionvalues ',' '}' ';'
|
|
{
|
|
if (validblock)
|
|
*$1 = $4;
|
|
}
|
|
;
|
|
|
|
arrayassignment: pairassignment
|
|
| unboundedassignment
|
|
| gestaltassignment
|
|
;
|
|
|
|
pairassignment: pairvar '=' '{' number ',' number '}' ';'
|
|
{
|
|
if (validblock)
|
|
{
|
|
$1->first = $4;
|
|
$1->second = $6;
|
|
}
|
|
}
|
|
;
|
|
|
|
gestaltassignment: gestalt_entry '=' '{' number ',' number '}' ';'
|
|
{ if (validblock)
|
|
ROMlib_add_to_gestalt_list ($1, $4, $6);
|
|
}
|
|
;
|
|
|
|
number: HEXCONSTANT
|
|
{ $$ = $1; }
|
|
| INTEGERCONSTANT
|
|
{ $$ = $1; }
|
|
| '-' number
|
|
{ $$ = - $2; }
|
|
;
|
|
|
|
gestalt_entry: GESTALT '(' CHAR4CONSTANT ')'
|
|
{ $$ = $3; }
|
|
| GESTALT '(' HEXCONSTANT ')'
|
|
{ $$ = $3; }
|
|
;
|
|
|
|
pairvar: SCREENSIZE
|
|
{ $$ = &ROMlib_ScreenSize; }
|
|
| SCREENLOCATION
|
|
{ $$ = &ROMlib_ScreenLocation; }
|
|
| MACSIZE
|
|
{ $$ = &ROMlib_MacSize; }
|
|
;
|
|
|
|
unboundedassignment: unboundedvar '=' '{' numberlist '}' ';'
|
|
| unboundedvar '=' '{' numberlist ',' '}' ';'
|
|
| unboundedvar '=' '{' '}' ';'
|
|
;
|
|
|
|
unboundedvar: CACHEPROBLEMS
|
|
;
|
|
|
|
/* NOTE: numberlist is expected only to be used for CacheProblems
|
|
so the reduction directly calls a cache specific routine */
|
|
numberlist: numberlist ',' number
|
|
{ if (validblock)
|
|
/* addtocache($3); */{};
|
|
}
|
|
| number
|
|
{ if (validblock)
|
|
/* addtocache($1); */{};
|
|
}
|
|
;
|
|
|
|
%%
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
struct namevaluestr {
|
|
char *name;
|
|
long value;
|
|
long lval;
|
|
} reserved[] =
|
|
{ /* NOTE: these are sorted so we can use a binary search */
|
|
{ "Accelerated", OPTIONSCONSTANT, ROMLIB_ACCELERATED_BIT },
|
|
{ "AppleChar", APPLECHAR, 0 },
|
|
{ "BitsPerPixel", BITSNUMBER, 0 },
|
|
{ "BlitAtTrapEnd", OPTIONSCONSTANT, ROMLIB_BLIT_TRAP_BIT },
|
|
{ "BlitInOSEvent", OPTIONSCONSTANT, ROMLIB_BLIT_OS_BIT },
|
|
{ "BlitOften", OPTIONSCONSTANT, ROMLIB_BLIT_OFTEN_BIT },
|
|
{ "CRC", CRC, 0 },
|
|
{ "CacheProblems", CACHEPROBLEMS, 0 },
|
|
{ "CloseIsQuit", OPTIONSCONSTANT, ROMLIB_CLOSE_IS_QUIT_BIT },
|
|
{ "Comments", COMMENTS, 0 },
|
|
{ "Debug", OPTIONSCONSTANT, ROMLIB_DEBUG_BIT },
|
|
{ "Delay", RDELAY, 0 },
|
|
{ "DirectDiskAccess", OPTIONSCONSTANT, ROMLIB_DIRECTDISKACCESS_BIT },
|
|
{ "DirtyVariant", OPTIONSCONSTANT, ROMLIB_DIRTY_VARIANT_BIT },
|
|
{ "DisposHandleHack", OPTIONSCONSTANT, ROMLIB_DISPOSHANDLE_HACK_BIT },
|
|
{ "DongleFamily", DONGLEFAMILY, 0 },
|
|
{ "FlushOften", OPTIONSCONSTANT, ROMLIB_FLUSHOFTEN_BIT },
|
|
{ "Gestalt", GESTALT, 0 },
|
|
{ "MacCDROM", MACCDROM, 0 },
|
|
{ "MacSize", MACSIZE, 0 },
|
|
{ "NewLineToCR", OPTIONSCONSTANT, ROMLIB_NEWLINETOCR_BIT },
|
|
{ "NoClock", OPTIONSCONSTANT, ROMLIB_NOCLOCK_BIT },
|
|
{ "NoLower", OPTIONSCONSTANT, ROMLIB_NOLOWER_BIT },
|
|
{ "NoPrefPanel", OPTIONSCONSTANT, ROMLIB_NOPREFS_BIT },
|
|
{ "NoSuspend", OPTIONSCONSTANT, ROMLIB_NOSUSPEND_BIT },
|
|
{ "NoWarn32", OPTIONSCONSTANT, ROMLIB_NOWARN32_BIT },
|
|
{ "Options", OPTIONS, 0 },
|
|
{ "PassPostscript", OPTIONSCONSTANT, ROMLIB_PASSPOSTSCRIPT_BIT },
|
|
{ "PretendAlias", OPTIONSCONSTANT, ROMLIB_PRETEND_ALIAS_BIT },
|
|
{ "PretendEdition", OPTIONSCONSTANT, ROMLIB_PRETEND_EDITION_BIT },
|
|
{ "PretendHelp", OPTIONSCONSTANT, ROMLIB_PRETEND_HELP_BIT },
|
|
{ "PretendScript", OPTIONSCONSTANT, ROMLIB_PRETEND_SCRIPT_BIT },
|
|
{ "PretendSound", OPTIONSCONSTANT, ROMLIB_PRETENDSOUND_BIT },
|
|
{ "PrinterName", PRINTERNAME, 0, },
|
|
{ "PrinterTypeLabel", PRINTERTYPELABEL, 0, },
|
|
{ "PrintingHack", OPTIONSCONSTANT, ROMLIB_PRINTING_HACK_BIT },
|
|
{ "PrVers", PRVERSION, 0, },
|
|
{ "RectScreen", OPTIONSCONSTANT, ROMLIB_RECT_SCREEN_BIT },
|
|
{ "Refresh", OPTIONSCONSTANT, ROMLIB_REFRESH_BIT },
|
|
{ "RefreshNumber", REFRESHNUMBER, 0 },
|
|
{ "RightButtonModifier", RIGHT_BUTTON_MODIFIER, 0 },
|
|
{ "ScreenLocation", SCREENLOCATION, 0 },
|
|
{ "ScreenSize", SCREENSIZE, 0 },
|
|
{ "SoundOff", OPTIONSCONSTANT, ROMLIB_SOUNDOFF_BIT },
|
|
{ "SoundOn", OPTIONSCONSTANT, ROMLIB_SOUNDON_BIT },
|
|
{ "StripAddress", OPTIONSCONSTANT, ROMLIB_STRIPADDRESSHACK_BIT },
|
|
{ "SystemVersion", SYSTEMVERSION, 0 },
|
|
{ "TextDisableHack", OPTIONSCONSTANT, ROMLIB_TEXT_DISABLE_BIT },
|
|
{ "Version", APP_VERSION, 0 },
|
|
{ "Win32Token", WIN32TOKEN, 0 },
|
|
{ "WindowName", WINDOWNAME, 0 },
|
|
};
|
|
|
|
#define RELOAD (-2)
|
|
#define STRINGSPACE 1024
|
|
|
|
long binfind(char *tofind, struct namevaluestr table[], short nentries)
|
|
{
|
|
short low, mid, high;
|
|
int cmpret;
|
|
|
|
for (low = -1, high = nentries; high - low > 1;) {
|
|
mid = (high + low) / 2;
|
|
cmpret = strcmp(tofind, table[mid].name);
|
|
if (cmpret < 0)
|
|
high = mid;
|
|
else if (cmpret == 0) {
|
|
yylval.number = table[mid].lval;
|
|
/*-->*/ return table[mid].value;
|
|
} else /* cmpret > 0 */
|
|
low = mid;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static char charspace[STRINGSPACE];
|
|
static char *freechar = charspace, *endchar = charspace + STRINGSPACE;
|
|
|
|
/*
|
|
* NOTE: call freestring only if you know no strings have been assigned
|
|
* after the one you are freeing.
|
|
*/
|
|
|
|
static void freestring( char *string )
|
|
{
|
|
freechar = string;
|
|
}
|
|
|
|
static long linecount = 1;
|
|
|
|
static int
|
|
cmp (const void *p1, const void *p2)
|
|
{
|
|
int retval;
|
|
const char *str1;
|
|
const char *str2;
|
|
|
|
str1 = ((struct namevaluestr *)p1)->name;
|
|
str2 = ((struct namevaluestr *)p2)->name;
|
|
retval = strcmp (str1, str2);
|
|
return retval;
|
|
}
|
|
|
|
static long yylex( void ) {
|
|
static short c = RELOAD;
|
|
char *tempp;
|
|
long retval;
|
|
int i;
|
|
|
|
if (c == RELOAD)
|
|
c = getc(configfile);
|
|
|
|
for (;;) {
|
|
switch (c) {
|
|
|
|
/* NOTE: if you mess with the '"' code, make sure to adjust clean()
|
|
in toolevent.c. */
|
|
|
|
case '"':
|
|
yylval.cptr = freechar;
|
|
while (freechar < endchar && ((c = getc(configfile)) != '"'))
|
|
*freechar++ = c;
|
|
if (freechar == endchar)
|
|
warning_unexpected ("out of string space parsing configuration file (line %ld)", linecount);
|
|
else
|
|
*freechar++ = 0;
|
|
c = getc(configfile);
|
|
return STRINGCONSTANT;
|
|
break;
|
|
|
|
case '0':
|
|
if ((c = getc(configfile)) == 'x') {
|
|
yylval.number = 0;
|
|
while (isalnum(c = getc(configfile))) {
|
|
if (yylval.number & 0xF0000000)
|
|
warning_unexpected ("hex constant too long parsing configuration file (line %ld)", linecount);
|
|
if (c >= '0' && c <= '9')
|
|
yylval.number = (yylval.number << 4) + c - '0';
|
|
else if (c >= 'a' && c <= 'f')
|
|
yylval.number = (yylval.number << 4) + c - 'a' + 10;
|
|
else if (c >= 'A' && c <= 'F')
|
|
yylval.number = (yylval.number << 4) + c - 'A' + 10;
|
|
else
|
|
warning_unexpected ("bad character in hex constant parsing configuration file (line %ld)", linecount);
|
|
}
|
|
return HEXCONSTANT;
|
|
break;
|
|
}
|
|
/* We just ate a 0 that should be part of a decimal integer
|
|
(we don't support octal). It is a leading zero, so we can
|
|
forget about it and fall through */
|
|
ungetc(c, configfile);
|
|
c = '0';
|
|
/* FALL THROUGH */
|
|
case '1': case '2': case '3':
|
|
case '4': case '5': case '6':
|
|
case '7': case '8': case '9':
|
|
yylval.number = c - '0';
|
|
while (isdigit(c = getc(configfile))) {
|
|
yylval.number = yylval.number * 10 + c - '0';
|
|
if (yylval.number < 0)
|
|
warning_unexpected ("integer overflow parsing configuration file (line %ld)", linecount);
|
|
}
|
|
return INTEGERCONSTANT;
|
|
break;
|
|
case ' ':
|
|
case '\r':
|
|
case '\n':
|
|
case '\t':
|
|
case '\f':
|
|
do
|
|
if (c == '\n')
|
|
linecount++;
|
|
while (isspace(c = getc(configfile)));
|
|
break;
|
|
case '/':
|
|
if ((c = getc(configfile)) == '/') {
|
|
while ((c = getc(configfile)) != '\n')
|
|
;
|
|
linecount++;
|
|
c = getc(configfile);
|
|
} else
|
|
warning_unexpected ("single '/' parsing configuration file (line %ld)", linecount);
|
|
break;
|
|
case '\'':
|
|
yylval.rtype = 0;
|
|
for (i = 0 ; i < 4 ; i++) {
|
|
c = getc(configfile);
|
|
yylval.rtype = (unsigned long)yylval.rtype * 256 + c;
|
|
}
|
|
if ((c = getc(configfile)) != '\'')
|
|
warning_unexpected ("missing \' parsing configuration file (line %ld)", linecount);
|
|
c = getc(configfile);
|
|
return CHAR4CONSTANT;
|
|
break;
|
|
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
|
|
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
|
|
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
|
|
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
|
|
case 'y': case 'z':
|
|
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
|
|
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
|
|
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
|
|
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
|
|
case 'Y': case 'Z':
|
|
tempp = freechar;
|
|
if (tempp < endchar)
|
|
do
|
|
*tempp++ = c;
|
|
while (tempp < endchar && isalnum(c = getc(configfile)));
|
|
if (tempp == endchar)
|
|
warning_unexpected ("out of string space while looking up keyword parsing configuration file (line %ld)", linecount);
|
|
else
|
|
*tempp++ = 0;
|
|
{
|
|
static boolean_t sorted = 0;
|
|
|
|
if (!sorted)
|
|
{
|
|
qsort (reserved, NELEM (reserved), sizeof reserved[0], cmp);
|
|
sorted = 1;
|
|
}
|
|
}
|
|
retval = binfind(freechar, reserved, NELEM (reserved));
|
|
if (!retval)
|
|
warning_unexpected ("unknown reserved word parsing configuration file (line %ld)", linecount);
|
|
return retval;
|
|
break;
|
|
case '{':
|
|
case '}':
|
|
case '(':
|
|
case ')':
|
|
case '=':
|
|
case ':':
|
|
case ',':
|
|
case ';':
|
|
case '-':
|
|
case '.':
|
|
retval = c;
|
|
c = getc(configfile);
|
|
return retval;
|
|
break;
|
|
case EOF:
|
|
c = RELOAD; /* for the next time around */
|
|
linecount = 1;
|
|
validblock = 1;
|
|
return EOF;
|
|
break;
|
|
default:
|
|
warning_unexpected ("unknown character parsing configuration file (line %ld)", linecount);
|
|
}
|
|
}
|
|
}
|
|
|
|
void yyerror(const char *str)
|
|
{
|
|
warning_unexpected ("configuration file parse error (line %ld): %s", linecount, str);
|
|
}
|