Семантическая ошибка что это

Advantages of pair programming

Pair programming has several advantages:

•

It can improve the quality of the source code, because two people work together. There is a greater chance that concepts and programming conventions will be maintained. Formal and semantic errors are usually discovered right away.

•

When pairs change systematically, knowledge about the overall system is dispersed throughout the team. The departure or unavailability of a developer thus has no serious effect on project progress.

•

The developers frequently question design decisions. Any blocked thinking or dead ends are avoided in development.

Pair programming for team training

In addition to these advantages, which mainly apply to homogeneous pairs, pair programming can also be used for team training. For example, an experienced programmer works with the new team member in pairs. Two things are important when using pair programming for team training:

•

New team members should have good basic programming knowledge; this is particularly important for retraining in a new technology. Without minimum qualification and experience, the gap between experienced and novice team members is too great, with the result that the inexperienced person does not understand the work at hand and is usually too timid to ask questions.

•

Experienced programmers should keep an eye on the training task assigned to them. It should be made clear that this task does not focus on development work.

We can further analyze this workflow of processing as follows:

•

Hive client triggers a query

•

Compiler receives the query and connects to metastore

•

Compiler receives the query and initiates the first phase of compilation

•

Parser—Converts the query into parse tree representation. Hive uses ANTLR to generate the abstract syntax tree (AST)

•

Semantic Analyzer—In this stage the compiler builds a logical plan based on the information that is provided by the metastore on the input and output tables. Additionally the complier also checks type compatibilities in expressions and flags compile time semantic errors at this stage. The best step is the transformation of an AST to intermediate representation that is called the query block (QB) tree. Nested queries are converted into parent–child relationships in a QB tree during this stage

•

Logical Plan Generator—In this stage the compiler writes the logical plan from the semantic analyzer into a logical tree of operations

•

Optimization—This is the most involved phase of the complier as the entire series of DAG optimizations are implemented in this phase. There are several customizations than can be done to the complier if desired. The primary operations done at this stage are as follows:

—

Logical optimization—Perform multiple passes over logical plan and rewrites in several ways

—

Column pruning—This optimization step ensures that only the columns that are needed in the query processing are actually projected out of the row

—

Predicate pushdown—Predicates are pushed down to the scan if possible so that rows can be filtered early in the processing

—

Partition pruning—Predicates on partitioned columns are used to prune out files of partitions that do not satisfy the predicate

—

Join optimization

—

Grouping and regrouping

—

Repartitioning

—

Physical plan generator converts logical plan into physical.

—

Physical plan generation creates the final DAG workflow of MapReduce

•

Execution engine gets the compiler outputs to execute on the Hadoop platform.

—

All the tasks are executed in the order of their dependencies. Each task is only executed if all of its prerequisites have been executed.

—

A map/reduce task first serializes its part of the plan into a plan.xml file.

—

This file is then added to the job cache for the task and instances of ExecMapper and ExecReducers are spawned using Hadoop.

—

Each of these classes deserializes the plan.xml and executes the relevant part of the task.

—

The final results are stored in a temporary location and at the completion of the entire query, the results are moved to the table if inserts or partitions, or returned to the calling program at a temporary location

Example 7.27

Coercion in Ada

Whenever a language allows a value of one type to be used in a context that expects another, the language implementation must perform an automatic, implicit conversion to the expected type. This conversion is called a type coercion. Like the explicit conversions discussed above, a coercion may require run-time code to perform a dynamic semantic check, or to convert between low-level representations. Ada coercions sometimes need the former, though never the latter:

d : weekday;  — as in Example 7.3

k : workday;  — as in Example 7.9

type calendar_column is new weekday;

c : calendar_column;

…

k := d; — run-time check required

d := k; — no check required; every workday is a weekday

c := d; — static semantic error;

   — weekdays and calendar_columns are not compatible

To perform this third assignment in Ada we would have to use an explicit conversion:

c := calendar_column(d);

Example 7.28

Coercion in C

As we noted in Section 3.5.3, coercions are a controversial subject in language design. Because they allow types to be mixed without an explicit indication of intent on the part of the programmer, they represent a significant weakening of type security. C, which has a relatively weak type system, performs quite a bit of coercion. It allows values of most numeric types to be intermixed in expressions, and will coerce types back and forth “as necessary.” Here are some examples:

short int s;

unsigned long int l;

char c; /* may be signed or unsigned — implementation-dependent */

float f; /* usually IEEE single-precision */

double d;  /* usually IEEE double-precision */

…

s = l; /* l’s low-order bits are interpreted as a signed number. */

l = s; /* s is sign-extended to the longer length, then

   its bits are interpreted as an unsigned number. */

s = c; /* c is either sign-extended or zero-extended to s’s length;

   the result is then interpreted as a signed number. */

f = l; /* l is converted to floating-point. Since f has fewer

   significant bits, some precision may be lost. */

d = f; /* f is converted to the longer format; no precision lost. */

f = d; /* d is converted to the shorter format; precision may be lost.

   If d’s value cannot be represented in single-precision, the

   result is undefined, but NOT a dynamic semantic error. */

Example 2.42

A Syntax Error in C

Suppose we are parsing a C program and see the following code fragment in a context where a statement is expected:

A = B : C + D;

We will detect a syntax error immediately after the B, when the colon appears from the scanner. At this point the simplest thing to do is just to print an error message and halt. This naive approach is generally not acceptable, however: it would mean that every run of the compiler reveals no more than one syntax error. Since most programs, at least at first, contain numerous such errors, we really need to find as many as possible now (we’d also like to continue looking for semantic errors). To do so, we must modify the state of the parser and/or the input stream so that the upcoming token(s) are acceptable. We shall probably want to turn off code generation, disabling the back end of the compiler: since the input is not a valid program, the code will not be of use, and there’s no point in spending time creating it.

In More Depth

On the PLP CD we explore several possible approaches to syntax error recovery. In panic mode, the compiler writer defines a small set of “safe symbols” that delimit clean points in the input. Semicolons, which typically end a statement, are a good choice in many languages. When an error occurs, the compiler deletes input tokens until it finds a safe symbol, and then “backs the parser out” (e.g., returns from recursive descent subroutines) until it finds a context in which that symbol might appear. Phrase-level recovery improves on this technique by employing different sets of “safe” symbols in different productions of the grammar (right parentheses when in an expression; semicolons when in a declaration). Context-specific look-ahead obtains additional improvements by differentiating among the various contexts in which a given production might appear in a syntax tree. To respond gracefully to certain common programming errors, the compiler writer may augment the grammar with error productions that capture language-specific idioms that are incorrect but are often written by mistake.

Niklaus Wirth published an elegant implementation of phrase-level and context-specific recovery for recursive descent parsers in 1976 [Wir76, Sec. 5.9]. Exceptions (to be discussed further in Section 8.5) provide a simpler alternative if supported by the language in which the compiler is written. For table-driven top-down parsers, Fischer, Milton, and Quiring published an algorithm in 1980 that automatically implements a well-defined notion of locally least-cost syntax repair. Locally least-cost repair is also possible in bottom-up parsers, but it is significantly more difficult. Most bottom-up parsers rely on more straightforward phrase-level recovery; a typical example can be found in Yacc/bison.

1.1

Errors in a computer program can be classified according to when they are detected and, if they are detected at compile time, what part of the compiler detects them. Using your favorite imperative language, give an example of each of the following.

(a)

A lexical error, detected by the scanner

(b)

A syntax error, detected by the parser

(c)

A static semantic error, detected by semantic analysis

(d)

A dynamic semantic error, detected by code generated by the compiler

(e)

An error that the compiler can neither catch nor easily generate code to catch (this should be a violation of the language definition, not just a program bug)

1.2

Consider again the Pascal tool set distributed by Niklaus Wirth (Example 1.15). After successfully building a machine language version of the Pascal compiler, one could in principle discard the P-code interpreter and the P-code version of the compiler. Why might one choose not to do so?

1.3

Imperative languages like Fortran and C are typically compiled, while scripting languages, in which many issues cannot be settled until run time, are typically interpreted. Is interpretation simply what one “has to do” when compilation is infeasible, or are there actually some advantages to interpreting a language, even when a compiler is available?

1.4

The gcd program of Example 1.20 might also be written

int main() {

 int i = getint(), j = getint();

 while (i != j) {

 if (i > j) i = i % j;

 else j = j % i;

 }

 putint(i);

}

Does this program compute the same result? If not, can you fix it? Under what circumstances would you expect one or the other to be faster?

1.5

In your local implementation of C, what is the limit on the size of integers? What happens in the event of arithmetic overflow? What are the implications of size limits on the portability of programs from one machine/compiler to another? How do the answers to these questions differ for Java? For Ada? For Pascal? For Scheme? (You may need to find a manual.)

1.6

The Unix make utility allows the programmer to specify dependences among the separately compiled pieces of a program. If file A depends on file B and file B is modified, make deduces that A must be recompiled, in case any of the changes to B would affect the code produced for A. How accurate is this sort of dependence management? Under what circumstances will it lead to unnecessary work? Under what circumstances will it fail to recompile something that needs to be recompiled?

1.7

Why is it difficult to tell whether a program is correct? How do you go about finding bugs in your code? What kinds of bugs are revealed by testing? What kinds of bugs are not? (For more formal notions of program correctness, see the bibliographic notes at the end of Chapter 4.)

Example 3.7

A “Gotcha” in Declare-Before-Use

In an apparent attempt to simplify the implementation of the compiler, Pascal modified the requirement to say that names must be declared before they are used (with special-case mechanisms to accommodate recursive types and subroutines). At the same time, however, Pascal retained the notion that the scope of a declaration is the entire surrounding block. These two rules can interact in surprising ways:

1.

const N = 10;

2.

…

3.

procedure foo;

4.

const

5.

 M = N; (* static semantic error! *)

6.

 …

7.

 N = 20; (* local constant declaration; hides the outer N *)

Pascal says that the second declaration of N covers all of foo, so the semantic analyzer should complain on line 5 that N is being used before its declaration. The error has the potential to be highly confusing, particularly if the programmer meant to use the outer N:

const N = 10;

…

procedure foo;

const

 M = N; (* static semantic error! *)

var

 A : array [1..M] of integer;

 N : real; (* hiding declaration *)

Here the pair of messages “N used before declaration” and “N is not a constant” are almost certainly not helpful.

In order to determine the validity of any declaration that appears to use a name from a surrounding scope, a Pascal compiler must scan the remainder of the scope’s declarations to see if the name is hidden. To avoid this complication, most Pascal successors (and some dialects of Pascal itself) specify that the scope of an identifier is not the entire block in which it is declared (excluding holes), but rather the portion of that block from the declaration to the end (again excluding holes). If our program fragment had been written in Ada, for example, or in C, C++, or Java, no semantic errors would be reported. The declaration of M would refer to the first (outer) declaration of N.

Design & Implementation

Example 3.8

Whole-Block Scope in C#

C++ and Java further relax the rules by dispensing with the define-before-use requirement in many cases. In both languages, members of a class (including those that are not defined until later in the program text) are visible inside all of the class’s methods. In Java, classes themselves can be declared in any order. Interestingly, while C# echos Java in requiring declaration before use for local variables (but not for classes and members), it returns to the Pascal notion of whole-block scope. Thus the following is invalid in C#.

class A

 const int N = 10;

 void foo()

 const int M = N; // uses inner N before it is declared

 const int N = 20;

Example 3.9

“Local if written” in Python

Perhaps the simplest approach to declaration order, from a conceptual point of view, is that of Modula-3, which says that the scope of a declaration is the entire block in which it appears (minus any holes created by nested declarations), and that the order of declarations doesn’t matter. The principal objection to this approach is that programmers may find it counterintuitive to use a local variable before it is declared. Python takes the “whole block” scope rule one step further by dispensing with variable declarations altogether. In their place it adopts the unusual convention that the local variables of subroutine S are precisely those variables that are written by some statement in the (static) body of S. If S is nested inside of T, and the name x appears on the left-hand side of assignment statements in both S and T, then the x‘s are distinct: there is one in S and one in T. Non-local variables are read-only unless explicitly imported (using Python’s global statement). We will consider these conventions in more detail in Section 13.4.1, as part of a general discussion of scoping in scripting languages.

Example 3.10

Declaration Order in Scheme

In the interest of flexibility, modern Lisp dialects tend to provide several options for declaration order. In Scheme, for example, the letrec and let* constructs define scopes with, respectively, whole-block and declaration-to-end-of-block semantics. The most frequently used construct, let, provides yet another option:

(let ((A 1))  ; outer scope, with A defined to be 1

 (let ((A 2)  ; inner scope, with A defined to be 2

 (B A))  ;  and B defined to be A

 B))  ; return the value of B

Here the nested declarations of A and B don’t until after the end of the declaration list. Thus when B is defined, the redefinition of A has not yet taken effect. B is defined to be the outer A, and the code as a whole returns 1.

We can see how elaboration achieves this reduction by starting at the top level of a model, namely, an entity, and choosing an architecture of the entity to simulate. The architecture comprises signals, processes and component instances. Each component instance is a copy of an entity and an architecture that also comprises signals, processes and component instances. Instances of those signals and processes are created, corresponding to the component instance, and then the elaboration operation is repeated for the subcomponent instances. Ultimately, a component instance is reached that is a copy of an entity with a purely behavioral architecture, containing only processes. This corresponds to a primitive component for the level of design being simulated. Figure 1.7 shows how elaboration proceeds for the structural architecture body of the reg4 entity from Example 1.3. As each instance of a process is created, its variables are created and given initial values. We can think of each process instance as corresponding to one instance of a component.

Figure 1.7. The elaboration of the reg4 entity using the structural architecture body. Each instance of the d_ff and and2 entities is replaced with the contents of the corresponding basic architecture. These each consist of a process with its variables and statements.

Advantages of pair programming

Pair programming has several advantages:

•

It can improve the quality of the source code, because two people work together. There is a greater chance that concepts and programming conventions will be maintained. Formal and semantic errors are usually discovered right away.

•

When pairs change systematically, knowledge about the overall system is dispersed throughout the team. The departure or unavailability of a developer thus has no serious effect on project progress.

•

The developers frequently question design decisions. Any blocked thinking or dead ends are avoided in development.

Pair programming for team training

In addition to these advantages, which mainly apply to homogeneous pairs, pair programming can also be used for team training. For example, an experienced programmer works with the new team member in pairs. Two things are important when using pair programming for team training:

•

New team members should have good basic programming knowledge; this is particularly important for retraining in a new technology. Without minimum qualification and experience, the gap between experienced and novice team members is too great, with the result that the inexperienced person does not understand the work at hand and is usually too timid to ask questions.

•

Experienced programmers should keep an eye on the training task assigned to them. It should be made clear that this task does not focus on development work.

We can further analyze this workflow of processing as follows:

•

Hive client triggers a query

•

Compiler receives the query and connects to metastore

•

Compiler receives the query and initiates the first phase of compilation

•

Parser—Converts the query into parse tree representation. Hive uses ANTLR to generate the abstract syntax tree (AST)

•

Semantic Analyzer—In this stage the compiler builds a logical plan based on the information that is provided by the metastore on the input and output tables. Additionally the complier also checks type compatibilities in expressions and flags compile time semantic errors at this stage. The best step is the transformation of an AST to intermediate representation that is called the query block (QB) tree. Nested queries are converted into parent–child relationships in a QB tree during this stage

•

Logical Plan Generator—In this stage the compiler writes the logical plan from the semantic analyzer into a logical tree of operations

•

Optimization—This is the most involved phase of the complier as the entire series of DAG optimizations are implemented in this phase. There are several customizations than can be done to the complier if desired. The primary operations done at this stage are as follows:

—

Logical optimization—Perform multiple passes over logical plan and rewrites in several ways

—

Column pruning—This optimization step ensures that only the columns that are needed in the query processing are actually projected out of the row

—

Predicate pushdown—Predicates are pushed down to the scan if possible so that rows can be filtered early in the processing

—

Partition pruning—Predicates on partitioned columns are used to prune out files of partitions that do not satisfy the predicate

—

Join optimization

—

Grouping and regrouping

—

Repartitioning

—

Physical plan generator converts logical plan into physical.

—

Physical plan generation creates the final DAG workflow of MapReduce

•

Execution engine gets the compiler outputs to execute on the Hadoop platform.

—

All the tasks are executed in the order of their dependencies. Each task is only executed if all of its prerequisites have been executed.

—

A map/reduce task first serializes its part of the plan into a plan.xml file.

—

This file is then added to the job cache for the task and instances of ExecMapper and ExecReducers are spawned using Hadoop.

—

Each of these classes deserializes the plan.xml and executes the relevant part of the task.

—

The final results are stored in a temporary location and at the completion of the entire query, the results are moved to the table if inserts or partitions, or returned to the calling program at a temporary location

Example 7.27

Coercion in Ada

Whenever a language allows a value of one type to be used in a context that expects another, the language implementation must perform an automatic, implicit conversion to the expected type. This conversion is called a type coercion. Like the explicit conversions discussed above, a coercion may require run-time code to perform a dynamic semantic check, or to convert between low-level representations. Ada coercions sometimes need the former, though never the latter:

d : weekday;  — as in Example 7.3

k : workday;  — as in Example 7.9

type calendar_column is new weekday;

c : calendar_column;

…

k := d; — run-time check required

d := k; — no check required; every workday is a weekday

c := d; — static semantic error;

   — weekdays and calendar_columns are not compatible

To perform this third assignment in Ada we would have to use an explicit conversion:

c := calendar_column(d);

Example 7.28

Coercion in C

As we noted in Section 3.5.3, coercions are a controversial subject in language design. Because they allow types to be mixed without an explicit indication of intent on the part of the programmer, they represent a significant weakening of type security. C, which has a relatively weak type system, performs quite a bit of coercion. It allows values of most numeric types to be intermixed in expressions, and will coerce types back and forth “as necessary.” Here are some examples:

short int s;

unsigned long int l;

char c; /* may be signed or unsigned — implementation-dependent */

float f; /* usually IEEE single-precision */

double d;  /* usually IEEE double-precision */

…

s = l; /* l’s low-order bits are interpreted as a signed number. */

l = s; /* s is sign-extended to the longer length, then

   its bits are interpreted as an unsigned number. */

s = c; /* c is either sign-extended or zero-extended to s’s length;

   the result is then interpreted as a signed number. */

f = l; /* l is converted to floating-point. Since f has fewer

   significant bits, some precision may be lost. */

d = f; /* f is converted to the longer format; no precision lost. */

f = d; /* d is converted to the shorter format; precision may be lost.

   If d’s value cannot be represented in single-precision, the

   result is undefined, but NOT a dynamic semantic error. */

Example 2.42

A Syntax Error in C

Suppose we are parsing a C program and see the following code fragment in a context where a statement is expected:

A = B : C + D;

We will detect a syntax error immediately after the B, when the colon appears from the scanner. At this point the simplest thing to do is just to print an error message and halt. This naive approach is generally not acceptable, however: it would mean that every run of the compiler reveals no more than one syntax error. Since most programs, at least at first, contain numerous such errors, we really need to find as many as possible now (we’d also like to continue looking for semantic errors). To do so, we must modify the state of the parser and/or the input stream so that the upcoming token(s) are acceptable. We shall probably want to turn off code generation, disabling the back end of the compiler: since the input is not a valid program, the code will not be of use, and there’s no point in spending time creating it.

In More Depth

On the PLP CD we explore several possible approaches to syntax error recovery. In panic mode, the compiler writer defines a small set of “safe symbols” that delimit clean points in the input. Semicolons, which typically end a statement, are a good choice in many languages. When an error occurs, the compiler deletes input tokens until it finds a safe symbol, and then “backs the parser out” (e.g., returns from recursive descent subroutines) until it finds a context in which that symbol might appear. Phrase-level recovery improves on this technique by employing different sets of “safe” symbols in different productions of the grammar (right parentheses when in an expression; semicolons when in a declaration). Context-specific look-ahead obtains additional improvements by differentiating among the various contexts in which a given production might appear in a syntax tree. To respond gracefully to certain common programming errors, the compiler writer may augment the grammar with error productions that capture language-specific idioms that are incorrect but are often written by mistake.

Niklaus Wirth published an elegant implementation of phrase-level and context-specific recovery for recursive descent parsers in 1976 [Wir76, Sec. 5.9]. Exceptions (to be discussed further in Section 8.5) provide a simpler alternative if supported by the language in which the compiler is written. For table-driven top-down parsers, Fischer, Milton, and Quiring published an algorithm in 1980 that automatically implements a well-defined notion of locally least-cost syntax repair. Locally least-cost repair is also possible in bottom-up parsers, but it is significantly more difficult. Most bottom-up parsers rely on more straightforward phrase-level recovery; a typical example can be found in Yacc/bison.

1.1

Errors in a computer program can be classified according to when they are detected and, if they are detected at compile time, what part of the compiler detects them. Using your favorite imperative language, give an example of each of the following.

(a)

A lexical error, detected by the scanner

(b)

A syntax error, detected by the parser

(c)

A static semantic error, detected by semantic analysis

(d)

A dynamic semantic error, detected by code generated by the compiler

(e)

An error that the compiler can neither catch nor easily generate code to catch (this should be a violation of the language definition, not just a program bug)

1.2

Consider again the Pascal tool set distributed by Niklaus Wirth (Example 1.15). After successfully building a machine language version of the Pascal compiler, one could in principle discard the P-code interpreter and the P-code version of the compiler. Why might one choose not to do so?

1.3

Imperative languages like Fortran and C are typically compiled, while scripting languages, in which many issues cannot be settled until run time, are typically interpreted. Is interpretation simply what one “has to do” when compilation is infeasible, or are there actually some advantages to interpreting a language, even when a compiler is available?

1.4

The gcd program of Example 1.20 might also be written

int main() {

 int i = getint(), j = getint();

 while (i != j) {

 if (i > j) i = i % j;

 else j = j % i;

 }

 putint(i);

}

Does this program compute the same result? If not, can you fix it? Under what circumstances would you expect one or the other to be faster?

1.5

In your local implementation of C, what is the limit on the size of integers? What happens in the event of arithmetic overflow? What are the implications of size limits on the portability of programs from one machine/compiler to another? How do the answers to these questions differ for Java? For Ada? For Pascal? For Scheme? (You may need to find a manual.)

1.6

The Unix make utility allows the programmer to specify dependences among the separately compiled pieces of a program. If file A depends on file B and file B is modified, make deduces that A must be recompiled, in case any of the changes to B would affect the code produced for A. How accurate is this sort of dependence management? Under what circumstances will it lead to unnecessary work? Under what circumstances will it fail to recompile something that needs to be recompiled?

1.7

Why is it difficult to tell whether a program is correct? How do you go about finding bugs in your code? What kinds of bugs are revealed by testing? What kinds of bugs are not? (For more formal notions of program correctness, see the bibliographic notes at the end of Chapter 4.)

Example 3.7

A “Gotcha” in Declare-Before-Use

In an apparent attempt to simplify the implementation of the compiler, Pascal modified the requirement to say that names must be declared before they are used (with special-case mechanisms to accommodate recursive types and subroutines). At the same time, however, Pascal retained the notion that the scope of a declaration is the entire surrounding block. These two rules can interact in surprising ways:

1.

const N = 10;

2.

…

3.

procedure foo;

4.

const

5.

 M = N; (* static semantic error! *)

6.

 …

7.

 N = 20; (* local constant declaration; hides the outer N *)

Pascal says that the second declaration of N covers all of foo, so the semantic analyzer should complain on line 5 that N is being used before its declaration. The error has the potential to be highly confusing, particularly if the programmer meant to use the outer N:

const N = 10;

…

procedure foo;

const

 M = N; (* static semantic error! *)

var

 A : array [1..M] of integer;

 N : real; (* hiding declaration *)

Here the pair of messages “N used before declaration” and “N is not a constant” are almost certainly not helpful.

In order to determine the validity of any declaration that appears to use a name from a surrounding scope, a Pascal compiler must scan the remainder of the scope’s declarations to see if the name is hidden. To avoid this complication, most Pascal successors (and some dialects of Pascal itself) specify that the scope of an identifier is not the entire block in which it is declared (excluding holes), but rather the portion of that block from the declaration to the end (again excluding holes). If our program fragment had been written in Ada, for example, or in C, C++, or Java, no semantic errors would be reported. The declaration of M would refer to the first (outer) declaration of N.

Design & Implementation

Example 3.8

Whole-Block Scope in C#

C++ and Java further relax the rules by dispensing with the define-before-use requirement in many cases. In both languages, members of a class (including those that are not defined until later in the program text) are visible inside all of the class’s methods. In Java, classes themselves can be declared in any order. Interestingly, while C# echos Java in requiring declaration before use for local variables (but not for classes and members), it returns to the Pascal notion of whole-block scope. Thus the following is invalid in C#.

class A

 const int N = 10;

 void foo()

 const int M = N; // uses inner N before it is declared

 const int N = 20;

Example 3.9

“Local if written” in Python

Perhaps the simplest approach to declaration order, from a conceptual point of view, is that of Modula-3, which says that the scope of a declaration is the entire block in which it appears (minus any holes created by nested declarations), and that the order of declarations doesn’t matter. The principal objection to this approach is that programmers may find it counterintuitive to use a local variable before it is declared. Python takes the “whole block” scope rule one step further by dispensing with variable declarations altogether. In their place it adopts the unusual convention that the local variables of subroutine S are precisely those variables that are written by some statement in the (static) body of S. If S is nested inside of T, and the name x appears on the left-hand side of assignment statements in both S and T, then the x‘s are distinct: there is one in S and one in T. Non-local variables are read-only unless explicitly imported (using Python’s global statement). We will consider these conventions in more detail in Section 13.4.1, as part of a general discussion of scoping in scripting languages.

Example 3.10

Declaration Order in Scheme

In the interest of flexibility, modern Lisp dialects tend to provide several options for declaration order. In Scheme, for example, the letrec and let* constructs define scopes with, respectively, whole-block and declaration-to-end-of-block semantics. The most frequently used construct, let, provides yet another option:

(let ((A 1))  ; outer scope, with A defined to be 1

 (let ((A 2)  ; inner scope, with A defined to be 2

 (B A))  ;  and B defined to be A

 B))  ; return the value of B

Here the nested declarations of A and B don’t until after the end of the declaration list. Thus when B is defined, the redefinition of A has not yet taken effect. B is defined to be the outer A, and the code as a whole returns 1.

We can see how elaboration achieves this reduction by starting at the top level of a model, namely, an entity, and choosing an architecture of the entity to simulate. The architecture comprises signals, processes and component instances. Each component instance is a copy of an entity and an architecture that also comprises signals, processes and component instances. Instances of those signals and processes are created, corresponding to the component instance, and then the elaboration operation is repeated for the subcomponent instances. Ultimately, a component instance is reached that is a copy of an entity with a purely behavioral architecture, containing only processes. This corresponds to a primitive component for the level of design being simulated. Figure 1.7 shows how elaboration proceeds for the structural architecture body of the reg4 entity from Example 1.3. As each instance of a process is created, its variables are created and given initial values. We can think of each process instance as corresponding to one instance of a component.

Figure 1.7. The elaboration of the reg4 entity using the structural architecture body. Each instance of the d_ff and and2 entities is replaced with the contents of the corresponding basic architecture. These each consist of a process with its variables and statements.