What can create a lexical error in C?

Question

Besides not closing a comment /*..., what constitutes a lexical error in C?

Answer 1

Here are some:

 "abc<EOF>

where EOF is the end of the file. In fact, EOF in the middle of many lexemes should produce errors:

 0x<EOF>

I assume that using bad escapes in strings is illegal:

  "ab\qcd"

Probably trouble with floating point exponents

 1e+%

Arguably, you shouldn't have stuff at the end of a preprocessor directive:

#if x   %

Answer 2

Basically anything that is not conforming to ISO C 9899/1999, Annex A.1 "Lexical Grammar" is a lexical fault if the compiler does its lexical analysis according to this grammar. Here are some examples:

"abc<EOF> // invalid string literal (from Ira Baxter's answer) (ISO C 9899/1999 6.4.4.5)

'a<EOF> // invalid char literal (6.4.4.4)

where EOF is the end of the file.

double a = 1e*3; // misguided floating point literal (6.4.4.2)

int a = 0x0g; // invalid integer hex literal (6.4.4.1)

int a = 09; // invalid octal literal (6.4.4.1)

char a = 'aa'; // too long char literal (from Joel's answer, 6.4.4.4)

double a = 0x1p1q; // invalid hexadecimal floating point constant (6.4.4.2)
// instead of q, only a float suffix, that is 'f', 'l', 'F' or 'L' is allowed.

// invalid header name (6.4.7)
#include <<a.h>
#include ""a.h"

Answer 3

Aren't [@$`] and other symbols like that (maybe from Unicode) lexical errors in C if put anywhere outside of string or comment?

They are not constituting any valid lexical sequence of that language. They cannot pass the lexer because the lexer cannot recognize them as any kind of valid token. Usually lexers are FSMs or regex-based, so these symbols are just unrecognized input.

For example, in the following code there are several lexical errors:

int main(void){
` int a = 3;
@ —
return 0;
}

We can support it by feeding this to gcc, which gives

../a.c: In function ‘main’:
../a.c:2: error: stray ‘`’ in program
../a.c:3: error: stray ‘@’ in program
../a.c:3: error: stray ‘\342’ in program
../a.c:3: error: stray ‘\200’ in program
../a.c:3: error: stray ‘\224’ in program

GCC is smart and does error-recovery, so it parsed a function definition (it knows we are in 'main'), but these errors definitely look like lexical errors. They are not syntax errors and rightly so. GCC's lexer doesn't have any types of tokens that can be built from these symbols. Note that it even treats a three-byte UTF-8 symbol as three unrecognized symbols.

Answer 4

Badly formed float constant (e.g. 123.34e, or 123.45.33).

Answer 5

Illegal id

int 3d = 1;

Illegal preprocessor directive

#define x 1

Unexpected token

if [0] {}

Unresolvable id

while (0) {}            

Answer 6

Lexical errors:

1. An unterminated comment
2. Any sequence of non-comment and non-whitespace characters that is not a valid preprocessor token
3. Any preprocessor token that is not a valid C token; an example is 0xe-2, which looks like an expression but is in fact a syntax error according to the standard—an odd corner case resulting from the rules for pp-tokens.