Question

Consider the following C statements:

char *str1 = "Hello;      /* Statement S1 */
char *str2 = "Hello;";    /* Statement S2 */
int  *str3 = "Hello";     /* Statement S3 */

Which of the following options is/are correct?

• A. S1 and S2 have syntactic errors
• B. S2 has a lexical error and S3 has a syntactic error
• C. S1 has a lexical error and S3 has a semantic error
• D. S1 has a syntactic error and S3 has a semantic error

Hint:

Ask at which compiler phase each line first fails: can the scanner even form valid tokens (lexical), does the token sequence match the grammar (syntactic), or is the shape fine but the types clash (semantic)?

Answer 1

The Correct Option is C

Step 1: Walk through the compiler pipeline for each line instead of naming the error type first.
A C compiler processes source text in stages: scanning (turns characters into tokens), parsing (checks the token stream against the grammar), and semantic analysis (checks types and meaning). A failure at the earliest stage that cannot succeed is the error that gets reported for that line.

Step 2: Run S1, char *str1 = "Hello;, through scanning.
The scanner sees the opening quote and starts consuming characters looking for the closing quote. It reaches the end of the physical line (the newline character) with the string still open. Since a plain string literal in C cannot legally contain a raw newline, the scanner cannot close this token; it must abort with a lexical-level complaint such as "missing terminating character". Parsing never even gets a complete token stream to work with, so this is unambiguously a lexical failure.

Step 3: Run S2, char *str2 = "Hello;";, through the same pipeline.
Scanning succeeds cleanly: it produces the token sequence char, *, str2, =, the string-literal token "Hello;" (whose value happens to contain a semicolon character, which is irrelevant to tokenizing since it is inside quotes), ;. Parsing succeeds because this token sequence is exactly the grammar production for a pointer declaration with an initializer. Semantic analysis succeeds too, because a string literal (type char *) is exactly the right type to initialize a char * variable. S2 passes every stage with zero errors.

Step 4: Run S3, int *str3 = "Hello";, through the same pipeline.
Scanning produces a clean token sequence, and parsing accepts it as a valid pointer declaration with initializer, identical in shape to S2. It is only in semantic analysis, where the compiler checks that the initializer's type matches the declared type, that a problem appears: the initializer is of type char * and the variable is declared int *, an incompatible pointer assignment without a cast. This is caught after parsing succeeds, so it is a semantic error, not a syntax error.

Step 5: Map the pipeline outcome onto the four options.
Only the pairing "S1 fails at scanning (lexical), S3 fails at semantic analysis" is consistent with tracing all three statements through the pipeline, which is exactly what option (C) states; every other option either invents an error where none exists (S2) or names the wrong pipeline stage (calling S1's failure syntactic, or S3's failure syntactic).

Step 6: Final answer.
$\[ \boxed{\text{Only (C) is correct}} \]$