Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

247 lines (219 sloc) 6.635 kb
/* The ___P macro assembles a function prototype from ANSI text or K&R
text as chosen at compile time. The K&R text has a list of argument
names and a list of declarations which must match. Also the K&R and
ANSI text must have the same number of declarations. This program
checks those. Rather than comparing names or trying to parse C, it
just counts commas and semicolons. It uses parentheses and commas to
determine the current part of the ___P macro call.
A count of the commas is not the same as a count of the number of
things between them. If there are no commas, there may be one thing,
but there may also be zero things. We don't check for that yet.
*/
start {
/* variables */ /* indices in stack frame */
paren_depth = 0; PAREN_DEPTH = 0;
current_arg = 0; CURRENT_ARG = 1;
ansi_commas = 0; ANSI_COMMAS = 2;
kr_commas = 0; KR_COMMAS = 3;
kr_semicolons = 0; KR_SEMICOLONS = 4;
start_line = 0;
error_header_printed = 0;
trace = 0; /* 0 = no trace, 1 = trace */
stackpointer = 0;
stackframes = list();
check_namerules();
}
/* In this program the start state is always other. */
namerules {
/./ other;
}
sub stack () {
if (trace) { print ("\n", stackpointer, " -> ", paren_depth, " ",
current_arg, " ", ansi_commas, " ", kr_commas, " ", kr_semicolons,
"\n"); }
stackframes[stackpointer] = list (paren_depth, current_arg, ansi_commas,
kr_commas, kr_semicolons);
stackpointer = stackpointer + 1;
}
sub unstack () {
if (stackpointer == 0) {
panic ("line ", $., "\tstack underflow");
}
stackpointer = stackpointer - 1;
paren_depth = stackframes[stackpointer][PAREN_DEPTH];
current_arg = stackframes[stackpointer][CURRENT_ARG];
ansi_commas = stackframes[stackpointer][ANSI_COMMAS];
kr_commas = stackframes[stackpointer][KR_COMMAS];
kr_semicolons = stackframes[stackpointer][KR_SEMICOLONS];
if (trace) { print ("\n", stackpointer, " <- ", paren_depth, " ",
current_arg, " ", ansi_commas, " ", kr_commas, " ", kr_semicolons,
"\n"); }
}
/* assume caller has read ___P((
so we set current_arg = 1 and paren_depth to 2, getting us ready
to read "ansi" below
we want to read this argument structure
1 2 1 2 1 0
( ( ansi ) , ( kr-commas ) kr-semis )
if current_arg == 1 and paren_depth == 2 and comma seen, it's an ANSI
comma
if paren_depth == 1 and comma seen, it's the macro arg separating comma
(ANSI before, K&R after)
if current_arg == 2 and paren_depth == 2 and comma seen, it's a K&R
comma
if current_arg == 2 and paren_depth == 1 and semicolon seen, it's a K&R
semicolon
we don't check that the K&R commas come before or after the semicolons
we do check that semicolons aren't allowed except as described above
we allow commas other places, e.g. in pointer-to-function decls.
we don't check for missing parentheses (leading or trailing comma at
depth 1, for example)
we check that the macro ends with two args. (not less) and that no
extra args appear -- checks are done as early as possible to try to
give useful errors even if file ends early
commas are separators, semicolons are terminators
so ANSI commas should equal K&R commas
but K&R semicolons should equal K&R commas + 1
check for end of file? TO DO
check number of things in prototypes, instead of just number of commas?
TO DO
*/
state ___P {
BEGIN {
paren_depth = 2;
current_arg = 1;
ansi_commas = 0;
kr_commas = 0;
kr_semicolons = 0;
start_line = $.;
stackpointer = 0;
/* no change to error_header_printed */
/* no change to trace */
if (trace) { print (start_line, "-", $., "-___P(( "); }
}
/\(/ {
paren_depth = paren_depth + 1;
if (trace) { print (start_line, "-", $., "-( "); }
}
/\)/ {
paren_depth = paren_depth - 1;
if (trace) { print (start_line, "-", $., "-)"); }
if (paren_depth == 0) {
if (trace) { print ("depth 0\n"); }
if (current_arg < 2) {
panic (start_line, "\tmacro ended with ", current_arg, " arguments");
}
if (ansi_commas > 0 || kr_commas > 0 || kr_semicolons > 0) {
if (ansi_commas != kr_commas || kr_semicolons != (kr_commas + 1)) {
if (!error_header_printed) {
print ("line\tANSI ,\tK&R ,\tK&R ;\n");
error_header_printed = 1;
}
print (start_line); print ("\t");
print (ansi_commas); print ("\t");
print (kr_commas); print ("\t");
print (kr_semicolons); print ("\n");
}
}
if (stackpointer > 0) {
unstack();
} else {
return;
}
}
/* paren depth is not 0 */
if (trace) { print (" "); }
}
/,/ {
if (trace) { print (start_line, "-", $., "-,"); }
if (paren_depth == 1) {
current_arg = current_arg + 1;
if (trace) { print ("arg "); }
if (current_arg > 2) {
panic (start_line, "\tmacro has at least ", current_arg, " arguments");
}
}
if (paren_depth == 2 && current_arg == 1) {
if (trace) { print ("ansi"); }
ansi_commas = ansi_commas + 1;
}
if (paren_depth == 2 && current_arg == 2) {
if (trace) { print ("kr"); }
kr_commas = kr_commas + 1;
}
if (trace) { print (" "); }
}
/;/ {
if (paren_depth == 1 && current_arg == 2) {
if (trace) { print (start_line, "-", $., "-;kr "); }
kr_semicolons = kr_semicolons + 1;
} else {
panic (start_line, "\tunexpected semicolon");
}
}
/\<___P\(\(/ {
stack();
paren_depth = 2;
current_arg = 1;
ansi_commas = 0;
kr_commas = 0;
kr_semicolons = 0;
/* no change to start_line */
/* no change to error_header_printed or trace */
/* no change to stackpointer */
}
/\<___P\(/ {
panic ($., "\tunexpected ___P");
}
/./ {
}
}
state comment {
BEGIN {
comment_start_line = $.;
}
/\*\\\// {
if (trace) { print (comment_start_line, "-", $., "-*/ "); }
return;
}
/./ {
}
}
state string {
BEGIN {
string_start_line = $.;
}
/\\\\./ {
}
/"/ {
if (trace) { print (string_start_line, "-", $., "-'' "); }
return;
}
/./ {
}
}
state other {
/\<___PVOID\>/ {
}
/\<___P\(\(/ {
call (___P);
}
/\<___P\(/ {
panic ($., "\tunexpected ___P");
}
/*
/\<___P/ {
panic ($., "\tunexpected ___P");
}
*/
/\/\*/ {
if (trace) { print ($., "-/* "); }
call (comment);
}
/\"/ {
if (trace) { print ($., "-`` "); }
call (string);
}
/./ {
}
}
Jump to Line
Something went wrong with that request. Please try again.