mirror of https://github.com/tongzx/nt5src
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.
1102 lines
30 KiB
1102 lines
30 KiB
/************************************************************************/
|
|
/* */
|
|
/* RCPP - Resource Compiler Pre-Processor for NT system */
|
|
/* */
|
|
/* SCANNER.C - Routines for token scanning */
|
|
/* */
|
|
/* 29-Nov-90 w-BrianM Update for NT from PM SDK RCPP */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
#include "rc.h"
|
|
|
|
|
|
#define ABS(x) ((x > 0) ? x : -1 * x)
|
|
|
|
|
|
#define ALERT_CHAR L'\007' /* ANSI alert character is ASCII BEL */
|
|
|
|
ULONG lCPPTotalLinenumber = 0;
|
|
|
|
extern int vfCurrFileType; //- Added for 16-bit file support.
|
|
|
|
|
|
/************************************************************************/
|
|
/* Local Function Prototypes */
|
|
/************************************************************************/
|
|
token_t c_size(long);
|
|
int ctoi(int);
|
|
int escape(int);
|
|
token_t get_real(PWCHAR);
|
|
token_t l_size(long);
|
|
long matol(PWCHAR, int);
|
|
token_t uc_size(long);
|
|
token_t ul_size(long);
|
|
void skip_1comment(void);
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* local_c_hash */
|
|
/************************************************************************/
|
|
hash_t
|
|
local_c_hash(
|
|
REG WCHAR *name
|
|
)
|
|
{
|
|
REG hash_t i;
|
|
|
|
i = 0;
|
|
while(*name) {
|
|
i += (*name & HASH_MASK);
|
|
name++;
|
|
}
|
|
return(i);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
* GETID - Get an identifier or keyword.
|
|
* (we know that we're given at least 1 id char)
|
|
* in addition, we'll hash the value using 'c'.
|
|
************************************************************************/
|
|
void
|
|
getid(
|
|
REG UINT c
|
|
)
|
|
{
|
|
REG WCHAR *p;
|
|
|
|
p = Reuse_W;
|
|
*p++ = (WCHAR)c;
|
|
c &= HASH_MASK;
|
|
|
|
repeat:
|
|
while(LXC_IS_IDENT(*p = GETCH())) { /* while it's an id char . . . */
|
|
c += (*p & HASH_MASK); /* hash it */
|
|
p++;
|
|
}
|
|
if(*p != EOS_CHAR) {
|
|
if((*p == L'\\') && (checknl())) {
|
|
goto repeat;
|
|
}
|
|
UNGETCH();
|
|
if(p >= LIMIT(Reuse_W)) {
|
|
strcpy (Msg_Text, GET_MSG (1067));
|
|
fatal(1067);
|
|
}
|
|
if( ((p - Reuse_W) > LIMIT_ID_LENGTH) && ( ! Prep )) {
|
|
p = Reuse_W + LIMIT_ID_LENGTH;
|
|
*p++ = L'\0';
|
|
c = local_c_hash(Reuse_W);
|
|
Msg_Temp = GET_MSG (4011);
|
|
SET_MSG (Msg_Text, sizeof(Msg_Text), Msg_Temp, Reuse_W);
|
|
warning(4011); /* id truncated */
|
|
} else {
|
|
*p++ = L'\0';
|
|
}
|
|
Reuse_W_hash = (hash_t)c;
|
|
Reuse_W_length = (UINT)(p - Reuse_W);
|
|
return;
|
|
}
|
|
if(io_eob()) { /* end of file in middle of id */
|
|
strcpy (Msg_Text, GET_MSG (1004));
|
|
fatal(1004);
|
|
}
|
|
goto repeat;
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** prep_string : outputs char/string constants when preprocessing only
|
|
************************************************************************/
|
|
void
|
|
prep_string(
|
|
REG WCHAR c
|
|
)
|
|
{
|
|
REG WCHAR *p_buf;
|
|
int term_char;
|
|
|
|
p_buf = Reuse_W;
|
|
|
|
term_char = c;
|
|
|
|
*p_buf++ = c; /* save the open quote */
|
|
|
|
for(;;) {
|
|
switch(CHARMAP(c = GETCH())) {
|
|
case LX_DQUOTE:
|
|
case LX_SQUOTE:
|
|
if(c == (WCHAR)term_char) {
|
|
*p_buf++ = (WCHAR)term_char;/* save the terminating quote */
|
|
goto out_of_loop;
|
|
}
|
|
break;
|
|
case LX_BACKSLASH:
|
|
*p_buf++ = c;
|
|
break;
|
|
case LX_CR:
|
|
continue;
|
|
case LX_NL:
|
|
UNGETCH();
|
|
goto out_of_loop;
|
|
case LX_EOS:
|
|
if(c == L'\\') {
|
|
*p_buf++ = c;
|
|
c = get_non_eof();
|
|
break;
|
|
}
|
|
handle_eos();
|
|
continue;
|
|
}
|
|
*p_buf++ = c;
|
|
if(p_buf >= &Reuse_W[MED_BUFFER - 1]) {
|
|
*p_buf = L'\0';
|
|
myfwrite(Reuse_W, (size_t)(p_buf - Reuse_W) * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
p_buf = Reuse_W;
|
|
}
|
|
}
|
|
|
|
out_of_loop:
|
|
*p_buf = L'\0';
|
|
myfwrite(Reuse_W, (size_t)(p_buf - Reuse_W) * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** char_const : gather up a character constant
|
|
** we're called after finding the openning single quote.
|
|
************************************************************************/
|
|
token_t
|
|
char_const(
|
|
void
|
|
)
|
|
{
|
|
REG WCHAR c;
|
|
value_t value;
|
|
token_t tok;
|
|
|
|
tok = (token_t)(Jflag ? L_CUNSIGNED : L_CINTEGER);
|
|
|
|
first_switch:
|
|
|
|
switch(CHARMAP(c = GETCH())) {
|
|
case LX_BACKSLASH:
|
|
break;
|
|
case LX_SQUOTE:
|
|
strcpy (Msg_Text, GET_MSG (2137)); //"empty character constant"
|
|
error(2137);
|
|
value.v_long = 0;
|
|
UNGETCH();
|
|
break;
|
|
case LX_EOS: /* ??? assumes i/o buffering > 1 char */
|
|
if(handle_eos() != BACKSLASH_EOS) {
|
|
goto first_switch;
|
|
}
|
|
value.v_long = escape(get_non_eof());
|
|
if( tok == L_CUNSIGNED ) { /* don't sign extend */
|
|
value.v_long &= 0xff;
|
|
}
|
|
break;
|
|
case LX_NL:
|
|
/* newline in character constant */
|
|
strcpy (Msg_Text, GET_MSG (2001));
|
|
error (2001);
|
|
UNGETCH();
|
|
/*
|
|
** FALLTHROUGH
|
|
*/
|
|
default:
|
|
value.v_long = c;
|
|
break;
|
|
}
|
|
|
|
if((c = get_non_eof()) != L'\'') {
|
|
strcpy (Msg_Text, GET_MSG (2015));
|
|
error (2015); /* too many chars in constant */
|
|
do {
|
|
if(c == L'\n') {
|
|
strcpy (Msg_Text, GET_MSG (2016));
|
|
error(2016); /* missing closing ' */
|
|
break;
|
|
}
|
|
} while((c = get_non_eof()) != L'\'');
|
|
}
|
|
yylval.yy_tree = build_const(tok, &value);
|
|
return(tok);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** str_const : gather up a string constant
|
|
************************************************************************/
|
|
void
|
|
str_const(
|
|
VOID
|
|
)
|
|
{
|
|
REG WCHAR c;
|
|
REG PWCHAR p_buf;
|
|
int not_warned_yet = TRUE;
|
|
|
|
p_buf = yylval.yy_string.str_ptr = Macro_buffer;
|
|
/*
|
|
** Is it possible that reading this string during a rescan will
|
|
** overwrite the expansion being rescanned? No, because a macro
|
|
** expansion is limited to the top half of Macro_buffer.
|
|
** For Macro_depth > 0, this is like copying the string from
|
|
** somewhere in the top half of Macro_buffer to the bottom half
|
|
** of Macro_buffer.
|
|
** Note that the restriction on the size of an expanded macro is
|
|
** stricter than the limit on an L_STRING length. An expanded
|
|
** macro is limited to around 1019 bytes, but an L_STRING is
|
|
** limited to 2043 bytes.
|
|
*/
|
|
for(;;) {
|
|
switch(CHARMAP(c = GETCH())) {
|
|
case LX_NL:
|
|
UNGETCH();
|
|
strcpy (Msg_Text, GET_MSG (2001));
|
|
error(2001);
|
|
/*
|
|
** FALLTHROUGH
|
|
*/
|
|
case LX_DQUOTE:
|
|
*p_buf++ = L'\0';
|
|
yylval.yy_string.str_len = (USHORT)(p_buf-yylval.yy_string.str_ptr);
|
|
return;
|
|
break;
|
|
case LX_EOS:
|
|
if(handle_eos() != BACKSLASH_EOS) {
|
|
continue;
|
|
}
|
|
if(InInclude) {
|
|
break;
|
|
}
|
|
else {
|
|
c = (WCHAR)escape(get_non_eof()); /* process escaped char */
|
|
}
|
|
break;
|
|
}
|
|
if(p_buf - Macro_buffer > LIMIT_STRING_LENGTH) {
|
|
if( not_warned_yet ) {
|
|
strcpy (Msg_Text, GET_MSG (4009));
|
|
warning(4009); /* string too big, truncating */
|
|
not_warned_yet = FALSE;
|
|
}
|
|
} else {
|
|
*p_buf++ = c;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** do_newline : does work after a newline has been found.
|
|
************************************************************************/
|
|
|
|
void
|
|
do_newline(
|
|
void
|
|
)
|
|
{
|
|
++Linenumber;
|
|
for(;;) {
|
|
switch(CHARMAP(GETCH())) {
|
|
case LX_BOM: // ignore Byte Order Mark
|
|
break;
|
|
case LX_CR:
|
|
break;
|
|
case LX_POUND:
|
|
preprocess();
|
|
break;
|
|
case LX_SLASH:
|
|
if( ! skip_comment()) {
|
|
goto leave_do_newline;
|
|
}
|
|
break;
|
|
case LX_NL:
|
|
if ((lCPPTotalLinenumber++ & RC_PREPROCESS_UPDATE) == 0)
|
|
UpdateStatus(1, lCPPTotalLinenumber);
|
|
Linenumber++;
|
|
// must manually write '\r' with '\n' when writing 16-bit strings
|
|
if( Prep ) { /* preprocessing only */
|
|
myfwrite(L"\r", sizeof(WCHAR), 1, OUTPUTFILE);
|
|
}
|
|
/*
|
|
** FALLTHROUGH
|
|
*/
|
|
case LX_WHITE:
|
|
if( Prep ) { /* preprocessing only, output whitespace */
|
|
myfwrite(&(PREVCH()), sizeof(WCHAR), 1, OUTPUTFILE);
|
|
} else {
|
|
do {
|
|
;
|
|
} while(LXC_IS_WHITE(GETCH()));
|
|
UNGETCH();
|
|
}
|
|
break;
|
|
case LX_EOS:
|
|
if(PREVCH() == EOS_CHAR || PREVCH() == CONTROL_Z) {
|
|
if(io_eob()) { /* leaves us pointing at a valid char */
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if(checknl()) {
|
|
continue;
|
|
}
|
|
/* it's a backslash */
|
|
/*
|
|
** FALLTHROUGH
|
|
*/
|
|
default: /* first non-white is not a '#', leave */
|
|
|
|
leave_do_newline:
|
|
|
|
UNGETCH();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
* GETNUM - Get a number from the input stream.
|
|
*
|
|
* ARGUMENTS
|
|
* radix - the radix of the number to be accumulated. Can only be 8, 10,
|
|
* or 16
|
|
* pval - a pointer to a VALUE union to be filled in with the value
|
|
*
|
|
* RETURNS - type of the token (L_CINTEGER or L_CFLOAT)
|
|
*
|
|
* SIDE EFFECTS -
|
|
* does push back on the input stream.
|
|
* writes into pval by reference
|
|
* uses buffer Reuse_W
|
|
*
|
|
* DESCRIPTION -
|
|
* Accumulate the number according to the rules for each radix.
|
|
* Set up the format string according to the radix (or distinguish
|
|
* integer from float if radix is 10) and convert to binary.
|
|
*
|
|
* AUTHOR - Ralph Ryan, Sept. 8, 1982
|
|
*
|
|
* MODIFICATIONS - none
|
|
*
|
|
************************************************************************/
|
|
token_t
|
|
getnum(
|
|
REG WCHAR c
|
|
)
|
|
{
|
|
REG WCHAR *p;
|
|
WCHAR *start;
|
|
int radix;
|
|
token_t tok;
|
|
value_t value;
|
|
|
|
tok = L_CINTEGER;
|
|
start = (Tiny_lexer_nesting ? Exp_ptr : Reuse_W);
|
|
p = start;
|
|
if( c == L'0' ) {
|
|
c = get_non_eof();
|
|
if( IS_X(c) ) {
|
|
radix = 16;
|
|
if( Prep ) {
|
|
*p++ = L'0';
|
|
*p++ = L'x';
|
|
}
|
|
for(c = get_non_eof(); LXC_IS_XDIGIT(c); c = get_non_eof()) {
|
|
/* no check for overflow? */
|
|
*p++ = c;
|
|
}
|
|
if((p == Reuse_W) && (Tiny_lexer_nesting == 0)) {
|
|
strcpy (Msg_Text, GET_MSG (2153));
|
|
error(2153);
|
|
}
|
|
goto check_suffix;
|
|
} else {
|
|
radix = 8;
|
|
*p++ = L'0'; /* for preprocessing or 0.xxx case */
|
|
}
|
|
} else {
|
|
radix = 10;
|
|
}
|
|
|
|
while( LXC_IS_DIGIT((WCHAR)c) ) {
|
|
*p++ = c;
|
|
c = get_non_eof();
|
|
}
|
|
|
|
if( IS_DOT(c) || IS_E(c) ) {
|
|
UNGETCH();
|
|
return(get_real(p));
|
|
}
|
|
|
|
check_suffix:
|
|
if( IS_EL(c) ) {
|
|
if( Prep ) {
|
|
*p++ = c;
|
|
}
|
|
c = get_non_eof();
|
|
if( IS_U(c) ) {
|
|
if(Prep) {
|
|
*p++ = c;
|
|
}
|
|
tok = L_LONGUNSIGNED;
|
|
} else {
|
|
tok = L_LONGINT;
|
|
UNGETCH();
|
|
}
|
|
} else if( IS_U(c) ) {
|
|
if( Prep ) {
|
|
*p++ = c;
|
|
}
|
|
c = get_non_eof();
|
|
if( IS_EL(c) ) {
|
|
if( Prep ) {
|
|
*p++ = c;
|
|
}
|
|
tok = L_LONGUNSIGNED;
|
|
} else {
|
|
tok = L_CUNSIGNED;
|
|
UNGETCH();
|
|
}
|
|
} else {
|
|
UNGETCH();
|
|
}
|
|
*p = L'\0';
|
|
if( start == Exp_ptr ) {
|
|
Exp_ptr = p;
|
|
return(L_NOTOKEN);
|
|
} else if( Prep ) {
|
|
myfwrite( Reuse_W, (size_t)(p - Reuse_W) * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
return(L_NOTOKEN);
|
|
}
|
|
value.v_long = matol(Reuse_W,radix);
|
|
switch(tok) {
|
|
case L_CINTEGER:
|
|
tok = (radix == 10)
|
|
? c_size(value.v_long)
|
|
: uc_size(value.v_long)
|
|
;
|
|
break;
|
|
case L_LONGINT:
|
|
tok = l_size(value.v_long);
|
|
break;
|
|
case L_CUNSIGNED:
|
|
tok = ul_size(value.v_long);
|
|
break;
|
|
}
|
|
yylval.yy_tree = build_const(tok, &value);
|
|
return(tok);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** get_real : gathers the real part/exponent of a real number.
|
|
** Input : ptr to the null terminator of the whole part
|
|
** pointer to receive value.
|
|
** Output : L_CFLOAT
|
|
**
|
|
** ASSUMES whole part is either at Exp_ptr or Reuse_W.
|
|
************************************************************************/
|
|
token_t
|
|
get_real(
|
|
REG PWCHAR p
|
|
)
|
|
{
|
|
REG int c;
|
|
token_t tok;
|
|
|
|
c = get_non_eof();
|
|
if(Cross_compile && (Tiny_lexer_nesting == 0)) {
|
|
strcpy (Msg_Text, GET_MSG (4012));
|
|
warning(4012); /* float constant in cross compilation */
|
|
Cross_compile = FALSE; /* only one msg per file */
|
|
}
|
|
/*
|
|
** if the next char is a digit, then we've been called after
|
|
** finding a '.'. if this is true, then
|
|
** we want to find the fractional part of the number.
|
|
** if it's a '.', then we've been called after finding
|
|
** a whole part, and we want the fraction.
|
|
*/
|
|
if( LXC_IS_DIGIT((WCHAR)c) || IS_DOT(c) ) {
|
|
do {
|
|
*p++ = (WCHAR)c;
|
|
c = (int)get_non_eof();
|
|
} while( LXC_IS_DIGIT((WCHAR)c) );
|
|
}
|
|
if( IS_E((WCHAR)c) ) { /* now have found the exponent */
|
|
*p++ = (WCHAR)c; /* save the 'e' */
|
|
c = (WCHAR)get_non_eof(); /* skip it */
|
|
if( IS_SIGN(c) ) { /* optional sign */
|
|
*p++ = (WCHAR)c; /* save the sign */
|
|
c = (int)get_non_eof();
|
|
}
|
|
if( ! LXC_IS_DIGIT((WCHAR)c)) {
|
|
if( ! Rflag ) {
|
|
if(Tiny_lexer_nesting == 0) {
|
|
Msg_Temp = GET_MSG (2021);
|
|
SET_MSG (Msg_Text, sizeof(Msg_Text), Msg_Temp, c);
|
|
error(2021); /* missing or malformed exponent */
|
|
}
|
|
*p++ = L'0';
|
|
}
|
|
} else {
|
|
do { /* gather the exponent */
|
|
*p++ = (WCHAR)c;
|
|
c = (int)get_non_eof();
|
|
} while( LXC_IS_DIGIT((WCHAR)c) );
|
|
}
|
|
}
|
|
if( IS_F((WCHAR)c) ) {
|
|
tok = L_CFLOAT;
|
|
if( Prep ) {
|
|
*p++ = (WCHAR)c;
|
|
}
|
|
} else if( IS_EL((WCHAR)c) ) {
|
|
tok = L_CLDOUBLE;
|
|
if( Prep ) {
|
|
*p++ = (WCHAR)c;
|
|
}
|
|
} else {
|
|
UNGETCH();
|
|
tok = L_CDOUBLE;
|
|
}
|
|
*p = L'\0';
|
|
if( Tiny_lexer_nesting > 0 ) {
|
|
Exp_ptr = p;
|
|
return(L_NOTOKEN);
|
|
}
|
|
else if( Prep ) {
|
|
myfwrite( Reuse_W, (size_t)(p - Reuse_W) * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
return(L_NOTOKEN);
|
|
}
|
|
/*
|
|
** reals aren't used during preprocessing
|
|
*/
|
|
return(tok);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** matol : ascii to long, given a radix.
|
|
************************************************************************/
|
|
long
|
|
matol(
|
|
REG PWCHAR p_start,
|
|
REG int radix
|
|
)
|
|
{
|
|
long result, old_result;
|
|
unsigned int i;
|
|
|
|
old_result = result = 0;
|
|
while(*p_start) {
|
|
result *= radix;
|
|
i = ctoi(*p_start);
|
|
if( ((int)i >= radix) && (! Prep) ) {
|
|
Msg_Temp = GET_MSG (2020);
|
|
SET_MSG (Msg_Text, sizeof(Msg_Text), Msg_Temp, *p_start, radix);
|
|
error(2020); /* illegal digit % for base % */
|
|
}
|
|
result += i;
|
|
p_start++;
|
|
if(radix == 10) {
|
|
if(result < old_result) {
|
|
p_start--; /* fix the string ptr since we have overflowed */
|
|
break;
|
|
}
|
|
} else if(*p_start) {
|
|
/*
|
|
** the loop is not finished.
|
|
** we will multiply by the radix again
|
|
** check the upper bits. if they're on, then
|
|
** that mult will overflow the value
|
|
*/
|
|
if(radix == 8) {
|
|
if(result & 0xe0000000) {
|
|
break;
|
|
}
|
|
} else if(result & 0xf0000000) {
|
|
break;
|
|
}
|
|
}
|
|
old_result = result;
|
|
}
|
|
if(*p_start) {
|
|
strcpy (Msg_Text, GET_MSG (2177));
|
|
error(2177); /* constant too big */
|
|
result = 0;
|
|
}
|
|
return(result);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** uc_size : returns 'int' or 'long' (virtual unsigned).
|
|
** if their are no bits in the upper part of the value,
|
|
** then it's an int. otherwise, it's a long.
|
|
** this is valid too if target sizeof(int) != sizeof(long).
|
|
** then L_CINTEGER and L_LONGINT are synonymous.
|
|
************************************************************************/
|
|
token_t
|
|
uc_size(
|
|
long value
|
|
)
|
|
{
|
|
return((token_t)((value > INT_MAX) ? L_CUNSIGNED : L_CINTEGER));
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** c_size : returns 'int' or 'long' for signed numbers.
|
|
** if the sign bit of the lower word is on or any bits
|
|
** in the upper word are on, then we must use 'long'.
|
|
************************************************************************/
|
|
token_t
|
|
c_size(
|
|
long value
|
|
)
|
|
{
|
|
return((token_t)((ABS(value) > INT_MAX) ? L_LONGINT : L_CINTEGER));
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** l_size : returns 'longint' or 'longunsigned' for long numbers.
|
|
** if the sign bit of the high word is on this is 'longunsigned';
|
|
************************************************************************/
|
|
token_t
|
|
l_size(
|
|
long value
|
|
)
|
|
{
|
|
return((token_t)((value > LONG_MAX) ? L_LONGUNSIGNED : L_LONGINT));
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** ul_size : returns 'unsigned' or 'longunsigned' for unsigned numbers.
|
|
** if the number can't be represented as unsigned, it is promoted to
|
|
** unsignedlong.
|
|
************************************************************************/
|
|
token_t
|
|
ul_size(
|
|
long value
|
|
)
|
|
{
|
|
return((token_t)((ABS(value) > UINT_MAX-1) ? L_LONGUNSIGNED : L_CUNSIGNED));
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** ctoi : character to int.
|
|
************************************************************************/
|
|
int
|
|
ctoi(
|
|
int c
|
|
)
|
|
{
|
|
if(LXC_IS_DIGIT((WCHAR)c)) {
|
|
return(c - L'0');
|
|
} else {
|
|
return(towupper((WCHAR)c) - towupper(L'A') + 10);
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
* ESCAPE - get an escaped character
|
|
*
|
|
* ARGUMENTS - none
|
|
*
|
|
* RETURNS - value of escaped character
|
|
*
|
|
* SIDE EFFECTS - may push back input
|
|
*
|
|
* DESCRIPTION - An escape ( '\' ) was discovered in the input. Translate
|
|
* the next symbol or symbols into an escape sequence.
|
|
*
|
|
* AUTHOR - Ralph Ryan, Sept. 7, 1982
|
|
*
|
|
* MODIFICATIONS - none
|
|
*
|
|
************************************************************************/
|
|
int
|
|
escape(
|
|
REG int c
|
|
)
|
|
{
|
|
REG int value;
|
|
int cnt;
|
|
|
|
escape_again:
|
|
|
|
if( LXC_IS_ODIGIT((WCHAR)c) ) {/* \ooo is an octal number, must fit into a byte */
|
|
cnt = 1;
|
|
for(value = ctoi(c), c = get_non_eof();
|
|
(cnt < 3) && LXC_IS_ODIGIT((WCHAR)c);
|
|
cnt++, c = get_non_eof()
|
|
) {
|
|
value *= 8;
|
|
value += ctoi(c);
|
|
}
|
|
if( ! Prep ) {
|
|
if(value > 255) {
|
|
Msg_Temp = GET_MSG (2022);
|
|
SET_MSG (Msg_Text, sizeof(Msg_Text), Msg_Temp, value);
|
|
error (2022);
|
|
}
|
|
}
|
|
UNGETCH();
|
|
return((char)value);
|
|
}
|
|
switch( c ) {
|
|
case L'a':
|
|
return(ALERT_CHAR);
|
|
break;
|
|
case L'b':
|
|
return(L'\b');
|
|
break;
|
|
case L'f':
|
|
return(L'\f');
|
|
break;
|
|
case L'n':
|
|
return fMacRsrcs ? (L'\r') : (L'\n');
|
|
break;
|
|
case L'r':
|
|
return fMacRsrcs ? (L'\n') : (L'\r');
|
|
break;
|
|
case L't':
|
|
return(L'\t');
|
|
break;
|
|
case L'v':
|
|
return(L'\v');
|
|
break;
|
|
case L'x':
|
|
cnt = 0;
|
|
value = 0;
|
|
c = get_non_eof();
|
|
while((cnt < 3) && LXC_IS_XDIGIT((WCHAR)c)) {
|
|
value *= 16;
|
|
value += ctoi(c);
|
|
c = get_non_eof();
|
|
cnt++;
|
|
}
|
|
if(cnt == 0) {
|
|
strcpy (Msg_Text, GET_MSG (2153));
|
|
error (2153);
|
|
}
|
|
UNGETCH();
|
|
return((char)value); /* cast to get sign extend */
|
|
default:
|
|
if(c != L'\\') {
|
|
return(c);
|
|
} else {
|
|
if(checknl()) {
|
|
c = get_non_eof();
|
|
goto escape_again;
|
|
} else {
|
|
return(c);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
* CHECKOP - Check whether the next input character matches the argument.
|
|
*
|
|
* ARGUMENTS
|
|
* short op - the character to be checked against
|
|
*
|
|
* RETURNS
|
|
* TRUE or FALSE
|
|
*
|
|
* SIDE EFFECTS
|
|
* Will push character back onto the input if there is no match.
|
|
*
|
|
* DESCRIPTION
|
|
* If the next input character matches op, return TRUE. Otherwise
|
|
* push it back onto the input.
|
|
*
|
|
* AUTHOR - Ralph Ryan, Sept. 9, 1982
|
|
*
|
|
* MODIFICATIONS - none
|
|
*
|
|
************************************************************************/
|
|
int
|
|
checkop(
|
|
int op
|
|
)
|
|
{
|
|
if(op == (int)get_non_eof()) {
|
|
return(TRUE);
|
|
}
|
|
UNGETCH();
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** DumpSlashComment : while skipping a comment, output it.
|
|
************************************************************************/
|
|
void
|
|
DumpSlashComment(
|
|
VOID
|
|
)
|
|
{
|
|
if( ! Cflag ) {
|
|
skip_NLonly();
|
|
return;
|
|
}
|
|
myfwrite(L"//", 2 * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
for(;;) {
|
|
WCHAR c;
|
|
|
|
switch(CHARMAP(c = GETCH())) {
|
|
// must manually write '\r' with '\n' when writing 16-bit strings
|
|
//case LX_CR:
|
|
// continue;
|
|
case LX_EOS:
|
|
handle_eos();
|
|
continue;
|
|
case LX_NL:
|
|
UNGETCH();
|
|
return;
|
|
}
|
|
myfwrite(&c, sizeof(WCHAR), 1, OUTPUTFILE);
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** dump_comment : while skipping a comment, output it.
|
|
************************************************************************/
|
|
void
|
|
dump_comment(
|
|
void
|
|
)
|
|
{
|
|
if( ! Cflag ) {
|
|
skip_1comment();
|
|
return;
|
|
}
|
|
myfwrite(L"/*", 2 * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
for(;;) {
|
|
WCHAR c;
|
|
|
|
switch(CHARMAP(c = GETCH())) {
|
|
case LX_STAR:
|
|
if(checkop(L'/')) {
|
|
myfwrite(L"*/", 2 * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
return;
|
|
}
|
|
break;
|
|
case LX_EOS:
|
|
handle_eos();
|
|
continue;
|
|
case LX_NL:
|
|
Linenumber++;
|
|
break; /* output below */
|
|
// must manually write '\r' with '\n' when writing 16-bit strings
|
|
//case LX_CR:
|
|
// continue;
|
|
}
|
|
myfwrite(&c, sizeof(WCHAR), 1, OUTPUTFILE);
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* skip_comment() */
|
|
/************************************************************************/
|
|
int
|
|
skip_comment(
|
|
void
|
|
)
|
|
{
|
|
if(checkop(L'*')) {
|
|
skip_1comment();
|
|
return(TRUE);
|
|
} else if(checkop(L'/')) {
|
|
skip_NLonly();
|
|
return(TRUE);
|
|
} else {
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** skip_1comment : we're called when we're already in a comment.
|
|
** we're looking for the comment close. we also count newlines
|
|
** and output them if we're preprocessing.
|
|
************************************************************************/
|
|
void
|
|
skip_1comment(
|
|
void
|
|
)
|
|
{
|
|
UINT c;
|
|
|
|
for(;;) {
|
|
c = GETCH();
|
|
if(c == L'*') {
|
|
recheck:
|
|
c = GETCH();
|
|
if(c == L'/') { /* end of comment */
|
|
return;
|
|
} else if(c == L'*') {
|
|
/*
|
|
** if we get another '*' go back and check for a slash
|
|
*/
|
|
goto recheck;
|
|
} else if(c == EOS_CHAR) {
|
|
handle_eos();
|
|
goto recheck;
|
|
}
|
|
}
|
|
/*
|
|
** note we fall through here. we know this baby is not a '*'
|
|
** we used to unget the char and continue. since we check for
|
|
** another '*' inside the above test, we can fall through here
|
|
** without ungetting/getting and checking again.
|
|
*/
|
|
if(c <= L'\n') {
|
|
/*
|
|
** hopefully, the above test is less expensive than doing two tests
|
|
*/
|
|
if(c == L'\n') {
|
|
Linenumber++;
|
|
if(Prep) {
|
|
myfwrite(L"\r\n", 2 * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
}
|
|
} else if(c == EOS_CHAR) {
|
|
handle_eos();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** skip_cwhite : while the current character is whitespace or a comment.
|
|
** a newline is NOT whitespace.
|
|
************************************************************************/
|
|
WCHAR
|
|
skip_cwhite(
|
|
void
|
|
)
|
|
{
|
|
REG WCHAR c;
|
|
|
|
skip_cwhite_again:
|
|
while((c = GETCH()) <= L'/') { /* many chars are above this */
|
|
if(c == L'/') {
|
|
if( ! skip_comment()) {
|
|
return(L'/');
|
|
}
|
|
} else if(c > L' ') { /* char is between '!' and '.' */
|
|
return(c);
|
|
} else {
|
|
switch(CHARMAP(c)) {
|
|
case LX_EOS:
|
|
handle_eos();
|
|
break;
|
|
case LX_WHITE:
|
|
continue;
|
|
break;
|
|
case LX_CR:
|
|
continue;
|
|
break;
|
|
default:
|
|
return(c);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if((c == L'\\') && (checknl())) {
|
|
goto skip_cwhite_again;
|
|
}
|
|
return(c);
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** checknl : check for newline, skipping carriage return if there is one.
|
|
** also increments Linenumber, so this should be used by routines which
|
|
** will not push the newline back in such a way that rawtok() will be invoked,
|
|
** find the newline and do another increment.
|
|
************************************************************************/
|
|
int
|
|
checknl(
|
|
void
|
|
)
|
|
{
|
|
REG WCHAR c;
|
|
|
|
for(;;) {
|
|
c = GETCH();
|
|
if(c > L'\r') {
|
|
UNGETCH();
|
|
return(FALSE);
|
|
}
|
|
switch(c) {
|
|
case L'\n':
|
|
Linenumber++;
|
|
// must manually write '\r' with '\n' when writing 16-bit strings
|
|
if( Prep ) {
|
|
myfwrite(L"\r\n", 2 * sizeof(WCHAR), 1, OUTPUTFILE);
|
|
}
|
|
return(TRUE);
|
|
break;
|
|
case L'\r':
|
|
continue;
|
|
break;
|
|
case EOS_CHAR:
|
|
handle_eos();
|
|
PREVCH() = L'\\'; /* M00HACK - needs pushback */
|
|
continue;
|
|
break;
|
|
default:
|
|
UNGETCH();
|
|
return(FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************************
|
|
** get_non_eof : get a real char.
|
|
************************************************************************/
|
|
WCHAR
|
|
get_non_eof(
|
|
void
|
|
)
|
|
{
|
|
WCHAR c;
|
|
|
|
get_non_eof_again:
|
|
while((c = GETCH()) <= L'\r') {
|
|
if(c == L'\r') {
|
|
continue;
|
|
} else if(c != EOS_CHAR) {
|
|
break;
|
|
}
|
|
if(Tiny_lexer_nesting > 0) {
|
|
break;
|
|
}
|
|
handle_eos();
|
|
}
|
|
if((c == L'\\') && (checknl())) {
|
|
goto get_non_eof_again;
|
|
}
|
|
return(c);
|
|
}
|