Detect Use-Before-Declaration and Undefined Variables

Topic Overview

Names Must Exist Before Use

TypeScript reports used before its declaration; C warns on implicit declarations. OpenSSL once shipped bugs from calling functions that were never declared. The fix is a two-pass or ordered walk: process declarations before uses in each scope, or reject forward references where the language forbids them.

Detection Strategy

Maintain a set of declared names per scope. On declaration, insert with line number. On use, verify the name exists and that the declaration line precedes the use line. Distinguish undefined (never declared) from use-before-decl (declared later).

cCopy
Loading…

• Track declaration line vs use line
• Block scope: inner declarations visible only after their line
• Globals may allow forward declarations depending on language
• Typos in names look like undefined variables

Connecting to real compilers

Production compilers embed this step inside a longer pipeline. GCC flows through cpp, cc1, assembly, and ld; Clang uses the driver, Sema, LLVM IR passes, and a target backend. LLVM bitcode, JVM bytecode, and WASM are other familiar IRs at the same layer. The exercise isolates one pass so you can test it alone before chaining it to the next stage.

Why for this exercise

You will detect variables used before declaration and references to undefined names. This exercise asks you to walk simple statements, maintain a declaration table, and emit precise errors with line numbers.

Your Task

Find every use of a variable that is not in scope, and tell the programmer why: either it is declared, but only later (a use before declaration), or no visible declaration exists at all (undefined).

Input

A small block-structured program, one statement per line (blank lines ignored):

An EXPR is made of identifiers, integer literals, + - * / ( ) and spaces. Everything outside any { } is the global scope.

Scope rules

• A declaration's name comes into scope after its whole statement, so int x = x + 1; uses x before its declaration.
• A name is visible at a use if it was declared on an earlier line in the current block or in an enclosing block that is still open.
• Declarations inside a block that has already closed are not visible.

What to report

For each identifier in an assignment target or an expression, in order of appearance (left to right, line by line):

• visible → fine, nothing printed;
• not visible, but declared later in the current block or in an enclosing block (before that block closes) → line L: 'NAME' used before declaration (declared at line D), where D is the first such later declaration;
• otherwise → line L: undefined variable 'NAME'.

Finish with uses=U errors=E, where U counts every identifier use checked (declared names on the left of a declaration are not uses).

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

step on line 7 is undefined: its declaration was inside a block that has closed.

Requirements

1. A scope stack of symbol tables, pushed on { and popped on }.
2. To classify a miss, you need to know about later declarations: read the whole program first (or use two passes).

Hidden tests cover shadowing across blocks, deeply nested blocks, globals declared after use, and names that are only declared in sibling blocks.