scan.l

reads a set of C-source files and generates a two-column listing of those sources

%{
/* scan.l -- a lexical scanner for C written in (f)lex */
/*
 * This is derived from a lex-scanner and yacc-parser published on the Net
 * by Arnold Robbins <[e-mail]> May, 1985.
 * He commented that he got it from Scott Lee <[e-mail]> who
 * wrote that it is based on the current (then - November 12 1984) draft of
 * the C grammar.
 * The original lex-scanner is in the public domain.
 *
 * I found and fixed a few bugs concerning escaped newlines in literal strings
 * and cpp-commands. I also changed the indentation to suit my personal
 * preferences. I moved most C-code to a separate file "scan.h", so it could
 * be cross-referenced with the cdg-program of which this scanner is a part.
 *
 * All input is now copied to file "listfile" but input lines that go beyond
 * column 80 are broken up at column 80 and a '\\' is output after column 80.
 * Tabs are expanded into spaces (tabwidth = 8). All output lines are numbered.
 * All parsed tokens including strings (except preprocessor commands and
 * comments) are copied in yytext, though the cdg parser never actually uses
 * that. The scanner does not return for comments and preprocessor commands.
 *
 * I ended up not using the original parser (as it was posted on the Net),
 * because that would require knowing all typedefs and types that may be
 * defined in include files. What I needed was a parser that would recognize
 * all identifiers and the way they were apparently used. Modifying the
 * original parser to work out whether a name is a type or an identifier caused
 * dozens of shift-reduce and reduce-reduce conflicts and the resulting parser
 * program refused to parse C.
 *
 * I thank Scott Lee for permitting me to use this modified scanner.
 *
 * Peter Knoppers <[e-mail]>
 */

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "y.tab.h"			/* generated with "original" parser */
#include "cdg.h"

void macro(void);
void string(void);
void comment (void);
void count(void);
int identifier (void);
%}

D	    [0-9]
L	    [a-zA-Z_]
H	    [a-fA-F0-9]
E	    [Ee][+-]?{D}+
LS	    (l|L)
US	    (u|U)

%%
"/*"			{ comment(); }

"auto"			{ count(); return(AUTO); }
"break"			{ count(); return(BREAK); }
"case"			{ count(); return(CASE); }
"char"			{ count(); return(CHAR); }
"const"			{ count(); return(CONST); }
"continue"		{ count(); return(CONTINUE); }
"default"		{ count(); return(DEFAULT); }
"do"			{ count(); return(DO); }
"double"		{ count(); return(DOUBLE); }
"else"			{ count(); return(ELSE); }
"enum"			{ count(); return(ENUM); }
"extern"		{ count(); return(EXTERN); }
"float"			{ count(); return(FLOAT); }
"for"			{ count(); return(FOR); }
"goto"			{ count(); return(GOTO); }
"if"			{ count(); return(IF); }
"int"			{ count(); return(INT); }
"long"			{ count(); return(LONG); }
"register"		{ count(); return(REGISTER); }
"return"		{ count(); return(RETURN); }
"short"			{ count(); return(SHORT); }
"signed"		{ count(); return(SIGNED); }
"sizeof"		{ count(); return(SIZEOF); }
"static"		{ count(); return(STATIC); }
"struct"		{ count(); return(STRUCT); }
"switch"		{ count(); return(SWITCH); }
"typedef"		{ count(); return(TYPEDEF); }
"union"			{ count(); return(UNION); }
"unsigned"		{ count(); return(UNSIGNED); }
"void"			{ count(); return(VOID); }
"volatile"		{ count(); return(VOLATILE); }
"while"			{ count(); return(WHILE); }

{L}({L}|{D})*		{ count(); return(identifier()); }

0[xX]{H}+{LS}?{US}?	{ count(); return(CONSTANT); }
0[xX]{H}+{US}?{LS}?	{ count(); return(CONSTANT); }
0{D}+{LS}?{US}?		{ count(); return(CONSTANT); }
0{D}+{US}?{LS}?		{ count(); return(CONSTANT); }
{D}+{LS}?{US}?		{ count(); return(CONSTANT); }
{D}+{US}?{LS}?		{ count(); return(CONSTANT); }
'(\\.|[^\\'])+'		{ count(); return(CONSTANT); }

{D}+{E}{LS}?		{ count(); return(CONSTANT); }
{D}*"."{D}+({E})?{LS}?	{ count(); return(CONSTANT); }
{D}+"."{D}*({E})?{LS}?	{ count(); return(CONSTANT); }

\"			{ string(); return(STRING_LITERAL); }

"#"			{ macro(); }

"\.\.\."		{ count(); return(ELIPSIS); }

">>="			{ count(); return(RIGHT_ASSIGN); }
"<<="			{ count(); return(LEFT_ASSIGN); }
"+="			{ count(); return(ADD_ASSIGN); }
"-="			{ count(); return(SUB_ASSIGN); }
"*="			{ count(); return(MUL_ASSIGN); }
"/="			{ count(); return(DIV_ASSIGN); }
"%="			{ count(); return(MOD_ASSIGN); }
"&="			{ count(); return(AND_ASSIGN); }
"^="			{ count(); return(XOR_ASSIGN); }
"|="			{ count(); return(OR_ASSIGN); }
">>"			{ count(); return(RIGHT_OP); }
"<<"			{ count(); return(LEFT_OP); }
"++"			{ count(); return(INC_OP); }
"--"			{ count(); return(DEC_OP); }
"->"			{ count(); return(PTR_OP); }
"&&"			{ count(); return(AND_OP); }
"||"			{ count(); return(OR_OP); }
"<="			{ count(); return(LE_OP); }
">="			{ count(); return(GE_OP); }
"=="			{ count(); return(EQ_OP); }
"!="			{ count(); return(NE_OP); }
";"			{ count(); return(';'); }
"{"			{ count(); return('{'); }
"}"			{ count(); return('}'); }
","			{ count(); return(','); }
":"			{ count(); return(':'); }
"="			{ count(); return('='); }
"("			{ count(); return('('); }
")"			{ count(); return(')'); }
"["			{ count(); return('['); }
"]"			{ count(); return(']'); }
"."			{ count(); return('.'); }
"&"			{ count(); return('&'); }
"!"			{ count(); return('!'); }
"~"			{ count(); return('~'); }
"-"			{ count(); return('-'); }
"+"			{ count(); return('+'); }
"*"			{ count(); return('*'); }
"/"			{ count(); return('/'); }
"%"			{ count(); return('%'); }
"<"			{ count(); return('<'); }
">"			{ count(); return('>'); }
"^"			{ count(); return('^'); }
"|"			{ count(); return('|'); }
"?"			{ count(); return('?'); }

[ \t\v\n\f]		{ count(); }
.			{ /* ignore bad characters */ }

%%

/*
 * Now include the code that DOES look like C.
 */
#include "scan.h"