General Information

	Eli: Translator Construction Made Easy
	Global Index
	Frequently Asked Questions
	Typical Eli Usage Errors

Tutorials

	Quick Reference Card
	Guide For new Eli Users
	Release Notes of Eli
	Tutorial on Name Analysis
	Tutorial on Scope Graphs
	Tutorial on Type Analysis
	Typical Eli Usage Errors

Reference Manuals

	User Interface
	Eli products and parameters
	LIDO Reference Manual
	Typical Eli Usage Errors

Libraries

	Eli library routines
	Specification Module Library

Translation Tasks

	Lexical analysis specification
	Syntactic Analysis Manual
	Computation in Trees

Tools

	LIGA Control Language
	Debugging Information for LIDO
	Graphical ORder TOol

FunnelWeb User's Manual

	Pattern-based Text Generator
	Property Definition Language
	Operator Identification Language
	Tree Grammar Specification Language
	Command Line Processing
	COLA Options Reference Manual

Generating Unparsing Code

Monitoring a Processor's Execution

Administration

System Administration Guide

Tutorial on Type Analysis

Union Types

We introduce union types to our language in order to demonstrate how subtype relations and their coercions are specified. A union type is described by a sequence of type denotations, which constitute the subtypes of the specified union type. A value of one of the subtypes can be coerced to the union type. A value of a union type can be treated as a value of one of the subtypes using a cast operation or a case statement.

Here is an example program that defines and uses a union variable named rv:

UnionExamp[75]==

begin
  var   union int, bool end rv;
  var   int j, bool c;
  rv = 42; rv = true;
  j = <int> rv;
  case rv of
    int t: j = t;
    bool t: c = t;
  end
end

This macro is attached to a product file.

In the case statement the case expression has a union type. Each case declares a variable of a subtype of that union type. The branch which corresponds to the current type of the case expression is selected, its variable is initialized with the value of the case expression, and the statement is executed.

The following productions describe union types, type casts, and case statements: Abstract union syntax[76]==

RULE: TypeDenoter ::= UnionType END;
RULE: UnionType  ::= 'union' UnitedTypes 'end' END;
RULE: UnitedTypes LISTOF UnitedType END;
RULE: UnitedType ::= TypeDenoter END;

RULE: Expression ::= '<' TypeDenoter '>' Expression END;

RULE: Statement ::= CaseStmt END;
RULE: CaseStmt ::= 'case' Expression 'of' Cases 'end' END;
RULE: Cases LISTOF Case END;
RULE: Case ::= ObjDecl ':' Statement END;

This macro is invoked in definition 88.

The following computations introduce a type denoter for union types and associate properties for test output to it: In order to check whether a type is a union type, as required for example in a case statement, we introduce a property IsUnionType. Is union type[77]==

IsUnionType: int;

This macro is invoked in definition 87.

Union type denoter[78]==

SYMBOL UnionType INHERITS TypeDenotation END;

RULE: UnionType ::= 'union' UnitedTypes 'end' COMPUTE
  .GotTypeProp =
      ORDER (
        ResetIsUnionType (UnionType.Type, 1),
        ResetTypeName (UnionType.Type, "union..."),
        ResetTypeLine (UnionType.Type, LINE));
END;

RULE: TypeDenoter ::= UnionType COMPUTE
  TypeDenoter.Type = UnionType.Type;
END;

This macro is invoked in definition 88.

For the comparison of union types stuctural equivalence is specified, such that the fact that it is a union type and the sequence of subtypes are relevant for type equality. UnionClass is the the set containing all union types for initialization of the equivalence check.

Union type class[79]==

UnionClass;

This macro is invoked in definition 87.

The UnionClass and the sequence UnitedTypes.OpndTypeList are used as arguments of AddTypeToBlock to specify type equivalence of union types. Property ComponentTypes is set accordingly:

Union type equality computation[80]==

RULE: UnionType ::= 'union' UnitedTypes 'end' COMPUTE
  UnionType.GotType +=
      AddTypeToBlock 
        (UnionType.Type, UnionClass, 
         VResetComponentTypes (UnionType.Type, UnitedTypes.OpndTypeList))
      <- .GotTypeProp;
END;

SYMBOL UnitedTypes INHERITS OpndTypeListRoot END;
SYMBOL UnitedType  INHERITS OpndTypeListElem END;

RULE: UnitedType ::= TypeDenoter COMPUTE
  UnitedType.Type = TypeDenoter.Type;
  UnitedType.DefTableKeyElem = UnitedType.Type;
END;

This macro is invoked in definition 88.

Note, that here the order of the subtypes in the type denoter is relevant for type equality. If that is not desired, one could for example sort the list of the component types in a canonical order before using it as an argument of AddTypeToBlock.

For each union type we introduce two groups of conversion operators: A widening coercion from each subtype type to the union type, and a down cast from the union type to each subtype. For the latter an indication has to be introduced: Downcast indication[81]==

DownCast;
UnionWiden;

This macro is invoked in definition 87.

As a pair of operators has to be introduced for each subtype, the context of the subtype denoter is the right place to do it. The coercion operator is not created explicitly; it is only stated that the subtype is Coercible to the union type. The down cast conversion is introduced as a MonadicOperator:

Widening coercion computation[82]==

SYMBOL UnitedType INHERITS OperatorDefs COMPUTE
  SYNT.GotOper +=
    ORDER
      (Coercible (UnionWiden, THIS.Type, INCLUDING UnionType.Type),
       MonadicOperator
        (DownCast, NewKey(), 
         INCLUDING UnionType.Type, THIS.Type));
END;

This macro is invoked in definition 88.

The context of the down cast construct imposes a requirement on the type of the operand expression. Any conversion operator of the DownCast indication can be applied to the operand expression, in addition to any coercions, to satisfy this requirement:

Down cast[83]==

RULE: Expression ::= '<' TypeDenoter '>' Expression COMPUTE
  CastContext (Expression[1], , Expression[2], TypeDenoter.Type);
  Indication (DownCast);
END;

This macro is invoked in definition 88.

In a case statement it is required that the case expression has a union type:

Union case statement[84]==

SYMBOL CaseStmt: Type: DefTableKey;

RULE: CaseStmt ::= 'case' Expression 'of' Cases 'end' COMPUTE
  CaseStmt.Type = Expression.Type;

  IF (NOT (GetIsUnionType (Expression.Type, 0)),
  message (ERROR, "Case expression must have a union type",
           0,COORDREF))
  <- INCLUDING Program.TypeIsSet;
END;

This macro is invoked in definition 88.

Each branch of a case statement forms a range for the declaration of the variable that gets the value of the case expression if that case is selected. It is required that the type of the variable is a subtype of the type of the case expression. We here require that it is coercible to the type of the case expression, although that is not quite exact. Union case[85]==

SYMBOL Case INHERITS RangeScope END;

RULE: Case ::= ObjDecl ':' Statement COMPUTE
  IF (NOT (IsCoercible 
             (ObjDecl.Type, INCLUDING CaseStmt.Type)),
  message (ERROR, "Must be a subtype of the case expression",
           0, COORDREF))
  <- INCLUDING Program.GotType;
END;

This macro is invoked in definition 88.

In other contexts ObjDecl occurs in a CHAIN. To avoid an error message on missing a chain start we apply the role OpndTypeListRoot here, which has the CHAINSTART, although that role is not needed:

Union CHAIN workaraound[86]==

SYMBOL Cases INHERITS OpndTypeListRoot END;

This macro is invoked in definition 88.

Union.pdl[87]==

Is union type[77]
Union type class[79]
Downcast indication[81]

This macro is attached to a product file.

Union.lido[88]==

Abstract union syntax[76]
Union type denoter[78]
Union type equality computation[80]
Widening coercion computation[82]
Down cast[83]
Union case[85]
Union case statement[84]
Union CHAIN workaraound[86]

This macro is attached to a product file.

Union.con[89]==

Concrete union syntax[144]

This macro is attached to a product file.