Evaluate Constant Expressions

This algorithm traverses the source model and computes the values of constant symbols and expressions.

Input

1. A list tul of translation units.

2. An analysis data structure a representing the results of analysis so far. Evaluate Implied Enum Constants must have already been run.

Output

1. The analysis a with an updated value map, if the check passes; otherwise an error.

Procedure

1. Visit each translation unit in tul with input a, yielding either a new analysis a' or an error.

AST Visitor Methods

Each method accepts an analysis data structure a as input and yields either a new analysis data structure a' or an error as output.

Translation Units

For each translation unit tu, visit each definition appearing in tu.

Definitions

For each constant definition d:

1. If d is not in the value map of a, then

   1. Visit each expression appearing in d, threading the analysis through the visits. Let a' be the resulting analysis.

   2. Use the value map of a' to compute the value v of d.

   3. Let a'' be the analysis data structure that results from adding the mapping from d to v to the value map of a'.

   4. Yield a'' as the result.

2. Otherwise we have already visited d; yield a as the result.

For each enum definition d, check that the enumerated constants of d all have different values.

For each template expansion specifier n:

1. For each constant parameter symbol of n, with parameter type name t and argument p:

   1. Visit the expression p, so that it has a value v in the value map of a.

   2. Run Finalize Type Definitions on t, and let T be the resulting type of t in the type map of a.

   3. Convert v to T, yielding v'. If the conversion is not possible, then report a type mismatch error.

   4. Let a' be the analysis data structure that results from adding the mapping from p to T in the type map of a and the mapping from p to v' in the value map of a. The type and the value of a bound parameter symbol are the ones recorded for its argument.

   5. Yield a' as the result.

2. For each type parameter symbol of n with argument p, visit the type name p.

3. Visit all the member nodes of n.

Type Names and Expressions

For each AST node n that represents an expression, if n is not already in the value map of a:

1. Compute the value v of n:

   1. If the value of n is directly available (for example, the value of the integer literal 1 is 1), then use that as v.

   2. Otherwise if n represents a use, then

      1. Look in the use-def map of n to get the symbol s corresponding to n. Throw an internal error if it is not there.

      2. If s is a constant parameter symbol with argument p, then if p is not already in the value map of a, apply the rules stated above for the constant parameters of a template expansion specifier.

      3. Otherwise visit the definition corresponding to s.

      4. Look in the value map of a to get the value v of s. Throw an internal error if it is not there.

      5. Use v as the value of n.

   3. Otherwise if n is an expression sizeof typename, then

      1. Visit the child expressions of n.

      2. Let t be the type assigned to typename in the type map.

      3. Finalize t: if t has a definition d and d has not yet been visited by Finalize Type Definitions, then

         1. Visit d.

         2. Recursively finalize the member types of d.

         3. Run Finalize Type Definitions on d.

      4. Let t' be the finalized type of typename. If t has a definition d, then t' is the type assigned to d in the type map. Otherwise t' is t.

      5. Compute the size v of t'.

   4. Otherwise

      1. Visit the child expressions of n.

      2. If possible, use the child values to compute the value v of n. If this is not possible (for example, because an array index is out of bounds), then report an error.

2. Update the value map with the mapping of n to v.