In which phase of the compiler below errors are detected ?

Question

1. Declaring an array with a floating point subscript :

               e.g    int a[2.8] ;

In my opinion ,it should be a syntax error :

How will the parse tree be generated for this ,because in between the square brackets we can have an identifier with some constant literal so in the grammar we can have S->int a[id] where id can be a constant literal , so why can't this be a syntax error , why it has to be semantic only ?

 

2. Simple declaration of a variable :

e.g int a ;

Now it is said that for simple declarative sentences ,parse tree is not generated , but then if I would have written int 1 ; then in this case ,if parse tree is not generated then how will the compiler know whether the token is a constant or an identifier ?

3. If there is an undefined symbol in the code , then why it can't be detected during parse tree and how is it detected during semantic phase only ?

4. If the name of the identifier is too long , then is this any type of error ?If Yes , then in which phase is this detected ?

Answer 1

Syntax Analysis: Checks out if the code follows the given CFG or not, i.e., it just checks the given code for typing errors based on the programming language's rules. For eg., if we miss a terminator/semicolon at the end of a C program's statement then it will be a syntax error because C requires its each statement/line to end with a terminator symbol. And for this purpose, a parse tree is generated on the basis of the given CFG.

Semantic analysis: Checks the meaning & usefulness of the program, i.e., type checking. It is better understood by examples:

1. x=a+b*c;

Now "x" can't be a constant or an array.

2. int a[3]={1,2,3};

int b[3]=a[3];

This is invalid because an array can not be directly assigned to some other array. This is semantically wrong but its syntax is alright.

While semantic analysis certainly can not check all possible meanings of all codes so it has its own limitations. But in reality, all these phases have vague lines to differentiate them. Compilers are implemented just as frontend(analysis phase) and backend(synthesis phase). That's why all operations of lexical, syntax  & semantic analysis are merged and it is hard to say what happened in which phase unless we know how the compiler itself was implemented at the first phase. One could try checking out output after each phase(there are specific terminal commands for them) but then this could vary when checked on a different machine.

NOW, coming to your questions:

1. Parse tree will be generated for it but it won't be semantically verified because it is meaningless. It is like those examples I gave above in semantic analysis. Thus, this error is only found out in semantic analysis phase.

2. I am hearing this for the first time that a parse tree is not generated for simple declarative sentences. I think int a; will also generate a parse tree. Please provide a link of where you read it, I could be wrong.

3. If an undefined symbol is used without creating a syntax error then it is found out in semantic analysis because syntax analysis just checks the rules of a programming language but not its meaning. But it is vague(maybe wrong) to say so because syntax and semantic phase, as said previously, are implemented together.

4. It is detected in lexical analysis phase. Errors detected by lexical analysis phase:

- Numeric literals too long. Eg. int a=12345678; (exceeding integer range)

- Long identifiers

- Badly formed numeric literals. Eg. int a=$123; ($ not allowed)

- Input characters that are not in the same language. Eg., On a english fixed (only) compiler, one entered/copied a Hindi letter.

Comments

"1. x=a+b*c;

Now, "x" can't be a constant or an array."

I hope Akhilesh mean this- x[ ]=a+b*c; when he said x cant be an array here?If not then pls clarify.

Adding on to point no.1- As she said, The grammar has rules like -

S->int a[id]

id->constant (constant.type=int)

Here, we also have "type" value of the constant to be used while using the second production, syntax tree generally would do the reductions as

int a[2.8]->int a[id]->S

but in semantic phase, the compiler would actually check for the semantics in the brackets.However, as Akhilesh said there is no clear distinction, they are implemented together.

Point No. 2-"I am hearing this for the first time that a parse tree is not generated for simple declarative sentences. I think int a; will also generate a parse tree."

I agree. But to answer her question i.e which phase is responsible for an error on  "int 1;"? Ans is Lexical phase is responsible for this as here we are violating the rules for identifier naming, that identifier's name must start with a letter and lexical analyzer will trap this using regex - letter(letter+digit)*

---

@Mamta

#include<stdio.h>
void main()
{ int x[2]={1,2};
int y=1,z=2;
x=y+z; //x[1]=y+z works fine
}

This gives a semantic error as I mentioned.

"x[]=y+z;" will give syntax error because a value is expected inside the array brackets.

Thanks for talking about "int 1;" and other stuff. I actually forgot to write about "int 1;" while answering.

---

Sure. Thanks.

---

@Akhilesh Singla, Won’t int a[3]={1,2,3}; be lexical error? As it is the invalid format of the identifier. (i.e. violating the rules for identifier naming)