static void DefineMacro (void)
/* Handle a macro definition. */
{
ident Ident;
Macro* M;
Macro* Existing;
int C89;
/* Read the macro name */
SkipWhitespace (0);
if (!MacName (Ident)) {
return;
}
/* Remember if we're in C89 mode */
C89 = (IS_Get (&Standard) == STD_C89);
/* Get an existing macro definition with this name */
Existing = FindMacro (Ident);
/* Create a new macro definition */
M = NewMacro (Ident);
/* Check if this is a function like macro */
if (CurC == '(') {
/* Skip the left paren */
NextChar ();
/* Set the marker that this is a function like macro */
M->ArgCount = 0;
/* Read the formal parameter list */
while (1) {
/* Skip white space and check for end of parameter list */
SkipWhitespace (0);
if (CurC == ')') {
break;
}
/* The next token must be either an identifier, or - if not in
* C89 mode - the ellipsis.
*/
if (!C89 && CurC == '.') {
/* Ellipsis */
NextChar ();
if (CurC != '.' || NextC != '.') {
PPError ("`...' expected");
ClearLine ();
return;
}
NextChar ();
NextChar ();
/* Remember that the macro is variadic and use __VA_ARGS__ as
* the argument name.
*/
AddMacroArg (M, "__VA_ARGS__");
M->Variadic = 1;
} else {
/* Must be macro argument name */
if (MacName (Ident) == 0) {
return;
}
/* __VA_ARGS__ is only allowed in C89 mode */
if (!C89 && strcmp (Ident, "__VA_ARGS__") == 0) {
PPWarning ("`__VA_ARGS__' can only appear in the expansion "
"of a C99 variadic macro");
}
/* Add the macro argument */
AddMacroArg (M, Ident);
}
/* If we had an ellipsis, or the next char is not a comma, we've
* reached the end of the macro argument list.
*/
SkipWhitespace (0);
if (M->Variadic || CurC != ',') {
break;
}
NextChar ();
}
/* Check for a right paren and eat it if we find one */
if (CurC != ')') {
PPError ("`)' expected");
ClearLine ();
return;
}
NextChar ();
}
/* Skip whitespace before the macro replacement */
SkipWhitespace (0);
/* Insert the macro into the macro table and allocate the ActualArgs array */
InsertMacro (M);
/* Remove whitespace and comments from the line, store the preprocessed
* line into the macro replacement buffer.
*/
Pass1 (Line, &M->Replacement);
/* Remove whitespace from the end of the line */
while (IsSpace (SB_LookAtLast (&M->Replacement))) {
SB_Drop (&M->Replacement, 1);
}
#if 0
printf ("%s: <%.*s>\n", M->Name, SB_GetLen (&M->Replacement), SB_GetConstBuf (&M->Replacement));
#endif
/* If we have an existing macro, check if the redefinition is identical.
* Print a diagnostic if not.
*/
if (Existing && MacroCmp (M, Existing) != 0) {
PPError ("Macro redefinition is not identical");
}
}
static void MacroArgSubst (MacroExp* E)
/* Argument substitution according to ISO/IEC 9899:1999 (E), 6.10.3.1ff */
{
ident Ident;
int ArgIdx;
StrBuf* OldSource;
StrBuf* Arg;
int HaveSpace;
/* Remember the current input and switch to the macro replacement. */
int OldIndex = SB_GetIndex (&E->M->Replacement);
SB_Reset (&E->M->Replacement);
OldSource = InitLine (&E->M->Replacement);
/* Argument handling loop */
while (CurC != '\0') {
/* If we have an identifier, check if it's a macro */
if (IsSym (Ident)) {
/* Check if it's a macro argument */
if ((ArgIdx = FindMacroArg (E->M, Ident)) >= 0) {
/* A macro argument. Get the corresponding actual argument. */
Arg = ME_GetActual (E, ArgIdx);
/* Copy any following whitespace */
HaveSpace = SkipWhitespace (0);
/* If a ## operator follows, we have to insert the actual
* argument as is, otherwise it must be macro replaced.
*/
if (CurC == '#' && NextC == '#') {
/* ### Add placemarker if necessary */
SB_Append (&E->Replacement, Arg);
} else {
/* Replace the formal argument by a macro replaced copy
* of the actual.
*/
SB_Reset (Arg);
MacroReplacement (Arg, &E->Replacement);
/* If we skipped whitespace before, re-add it now */
if (HaveSpace) {
SB_AppendChar (&E->Replacement, ' ');
}
}
} else {
/* An identifier, keep it */
SB_AppendStr (&E->Replacement, Ident);
}
} else if (CurC == '#' && NextC == '#') {
/* ## operator. */
NextChar ();
NextChar ();
SkipWhitespace (0);
/* Since we need to concatenate the token sequences, remove
* any whitespace that was added to target, since it must come
* from the input.
*/
while (IsSpace (SB_LookAtLast (&E->Replacement))) {
SB_Drop (&E->Replacement, 1);
}
/* If the next token is an identifier which is a macro argument,
* replace it, otherwise do nothing.
*/
if (IsSym (Ident)) {
/* Check if it's a macro argument */
if ((ArgIdx = FindMacroArg (E->M, Ident)) >= 0) {
/* Get the corresponding actual argument and add it. */
SB_Append (&E->Replacement, ME_GetActual (E, ArgIdx));
} else {
/* Just an ordinary identifier - add as is */
SB_AppendStr (&E->Replacement, Ident);
}
}
} else if (CurC == '#' && E->M->ArgCount >= 0) {
/* A # operator within a macro expansion of a function like
* macro. Read the following identifier and check if it's a
* macro parameter.
*/
NextChar ();
SkipWhitespace (0);
if (!IsSym (Ident) || (ArgIdx = FindMacroArg (E->M, Ident)) < 0) {
PPError ("`#' is not followed by a macro parameter");
} else {
/* Make a valid string from Replacement */
Arg = ME_GetActual (E, ArgIdx);
SB_Reset (Arg);
Stringize (Arg, &E->Replacement);
}
} else if (IsQuote (CurC)) {
CopyQuotedString (&E->Replacement);
} else {
SB_AppendChar (&E->Replacement, CurC);
NextChar ();
}
}
#if 0
/* Remove whitespace from the end of the line */
while (IsSpace (SB_LookAtLast (&E->Replacement))) {
SB_Drop (&E->Replacement, 1);
}
#endif
/* Switch back the input */
InitLine (OldSource);
SB_SetIndex (&E->M->Replacement, OldIndex);
}
static void IFNextChar (CharSource* S)
/* Read the next character from the input file */
{
/* Check for end of line, read the next line if needed */
while (SB_GetIndex (&S->V.File.Line) >= SB_GetLen (&S->V.File.Line)) {
unsigned Len;
/* End of current line reached, read next line */
SB_Clear (&S->V.File.Line);
while (1) {
int N = fgetc (S->V.File.F);
if (N == EOF) {
/* End of file. Accept files without a newline at the end */
if (SB_NotEmpty (&S->V.File.Line)) {
break;
}
/* No more data - add an empty line to the listing. This
** is a small hack needed to keep the PC output in sync.
*/
NewListingLine (&EmptyStrBuf, S->V.File.Pos.Name, FCount);
C = EOF;
return;
/* Check for end of line */
} else if (N == '\n') {
/* End of line */
break;
/* Collect other stuff */
} else {
/* Append data to line */
SB_AppendChar (&S->V.File.Line, N);
}
}
/* If we come here, we have a new input line. To avoid problems
** with strange line terminators, remove all whitespace from the
** end of the line, then add a single newline.
*/
Len = SB_GetLen (&S->V.File.Line);
while (Len > 0 && IsSpace (SB_AtUnchecked (&S->V.File.Line, Len-1))) {
--Len;
}
SB_Drop (&S->V.File.Line, SB_GetLen (&S->V.File.Line) - Len);
SB_AppendChar (&S->V.File.Line, '\n');
/* Terminate the string buffer */
SB_Terminate (&S->V.File.Line);
/* One more line */
S->V.File.Pos.Line++;
/* Remember the new line for the listing */
NewListingLine (&S->V.File.Line, S->V.File.Pos.Name, FCount);
}
/* Set the column pointer */
S->V.File.Pos.Col = SB_GetIndex (&S->V.File.Line);
/* Return the next character from the buffer */
C = SB_Get (&S->V.File.Line);
}
static void ReadMacroArgs (MacroExp* E)
/* Identify the arguments to a macro call */
{
unsigned Parens; /* Number of open parenthesis */
StrBuf Arg = STATIC_STRBUF_INITIALIZER;
/* Read the actual macro arguments */
Parens = 0;
while (1) {
if (CurC == '(') {
/* Nested parenthesis */
SB_AppendChar (&Arg, CurC);
NextChar ();
++Parens;
} else if (IsQuote (CurC)) {
/* Quoted string - just copy */
CopyQuotedString (&Arg);
} else if (CurC == ',' || CurC == ')') {
if (Parens) {
/* Comma or right paren inside nested parenthesis */
if (CurC == ')') {
--Parens;
}
SB_AppendChar (&Arg, CurC);
NextChar ();
} else if (CurC == ',' && ME_ArgIsVariadic (E)) {
/* It's a comma, but we're inside a variadic macro argument, so
* just copy it and proceed.
*/
SB_AppendChar (&Arg, CurC);
NextChar ();
} else {
/* End of actual argument. Remove whitespace from the end. */
while (IsSpace (SB_LookAtLast (&Arg))) {
SB_Drop (&Arg, 1);
}
/* If this is not the single empty argument for a macro with
* an empty argument list, remember it.
*/
if (CurC != ')' || SB_NotEmpty (&Arg) || E->M->ArgCount > 0) {
ME_AppendActual (E, &Arg);
}
/* Check for end of macro param list */
if (CurC == ')') {
NextChar ();
break;
}
/* Start the next param */
NextChar ();
SB_Clear (&Arg);
}
} else if (SkipWhitespace (1)) {
/* Squeeze runs of blanks within an arg */
if (SB_NotEmpty (&Arg)) {
SB_AppendChar (&Arg, ' ');
}
} else if (CurC == '/' && NextC == '*') {
if (SB_NotEmpty (&Arg)) {
SB_AppendChar (&Arg, ' ');
}
OldStyleComment ();
} else if (IS_Get (&Standard) >= STD_C99 && CurC == '/' && NextC == '/') {
if (SB_NotEmpty (&Arg)) {
SB_AppendChar (&Arg, ' ');
}
NewStyleComment ();
} else if (CurC == '\0') {
/* End of input inside macro argument list */
PPError ("Unterminated argument list invoking macro `%s'", E->M->Name);
ClearLine ();
break;
} else {
/* Just copy the character */
SB_AppendChar (&Arg, CurC);
NextChar ();
}
}
/* Deallocate string buf resources */
SB_Done (&Arg);
}
int NextLine (void)
/* Get a line from the current input. Returns 0 on end of file. */
{
AFile* Input;
/* Clear the current line */
ClearLine ();
/* If there is no file open, bail out, otherwise get the current input file */
if (CollCount (&AFiles) == 0) {
return 0;
}
Input = CollLast (&AFiles);
/* Read characters until we have one complete line */
while (1) {
/* Read the next character */
int C = fgetc (Input->F);
/* Check for EOF */
if (C == EOF) {
/* Accept files without a newline at the end */
if (SB_NotEmpty (Line)) {
++Input->Line;
break;
}
/* Leave the current file */
CloseIncludeFile ();
/* If there is no file open, bail out, otherwise get the
* previous input file and start over.
*/
if (CollCount (&AFiles) == 0) {
return 0;
}
Input = CollLast (&AFiles);
continue;
}
/* Check for end of line */
if (C == '\n') {
/* We got a new line */
++Input->Line;
/* If the \n is preceeded by a \r, remove the \r, so we can read
* DOS/Windows files under *nix.
*/
if (SB_LookAtLast (Line) == '\r') {
SB_Drop (Line, 1);
}
/* If we don't have a line continuation character at the end,
* we're done with this line. Otherwise replace the character
* by a newline and continue reading.
*/
if (SB_LookAtLast (Line) == '\\') {
Line->Buf[Line->Len-1] = '\n';
} else {
break;
}
} else if (C != '\0') { /* Ignore embedded NULs */
/* Just some character, add it to the line */
SB_AppendChar (Line, C);
}
}
/* Add a termination character to the string buffer */
SB_Terminate (Line);
/* Initialize the current and next characters. */
InitLine (Line);
/* Create line information for this line */
UpdateLineInfo (Input->Input, Input->Line, Line);
/* Done */
return 1;
}
