#!/usr/bin/perl 

###################
### Clause  8.1 ###
###################

sub ALF_library_specific_object {	local($token,$parent) = @_;
	&ALF_library($token,$parent) ||
	&ALF_sublibrary($token,$parent) ||
	&ALF_cell($token,$parent) ||
	&ALF_primitive($token,$parent) ||
	&ALF_wire($token,$parent) ||
	&ALF_pin($token,$parent) ||
	&ALF_pingroup($token,$parent) ||
	&ALF_vector($token,$parent) ||
	&ALF_node($token,$parent) ||
	&ALF_layer($token,$parent) ||
	&ALF_via($token,$parent) ||
	&ALF_rule($token,$parent) ||
	&ALF_antenna($token,$parent) ||
	&ALF_site($token,$parent) ||
	&ALF_array($token,$parent) ||
	&ALF_blockage($token,$parent) ||
	&ALF_port($token,$parent) ||
	&ALF_pattern($token,$parent) ||
	&ALF_region($token,$parent);
}

$ALF_SyntaxRule{'LIBRARY'}	= 'library_specific_object';
$ALF_SyntaxRule{'SUBLIBRARY'}	= 'library_specific_object';
$ALF_SyntaxRule{'CELL'} 	= 'library_specific_object';
$ALF_SyntaxRule{'PRIMITIVE'} 	= 'library_specific_object';
$ALF_SyntaxRule{'WIRE'} 	= 'library_specific_object';
$ALF_SyntaxRule{'PIN'}  	= 'library_specific_object';
$ALF_SyntaxRule{'PINGROUP'} 	= 'library_specific_object';
$ALF_SyntaxRule{'VECTOR'}	= 'library_specific_object';
$ALF_SyntaxRule{'NODE'} 	= 'library_specific_object';
$ALF_SyntaxRule{'LAYER'} 	= 'library_specific_object';
$ALF_SyntaxRule{'VIA'}  	= 'library_specific_object';
$ALF_SyntaxRule{'RULE'} 	= 'library_specific_object';
$ALF_SyntaxRule{'ANTENNA'} 	= 'library_specific_object';
$ALF_SyntaxRule{'SITE'} 	= 'library_specific_object';
$ALF_SyntaxRule{'ARRAY'} 	= 'library_specific_object';
$ALF_SyntaxRule{'BLOCKAGE'} 	= 'library_specific_object';
$ALF_SyntaxRule{'PORT'} 	= 'library_specific_object';
$ALF_SyntaxRule{'PATTERN'} 	= 'library_specific_object';
$ALF_SyntaxRule{'REGION'} 	= 'library_specific_object';

###################
### Clause  8.2 ###
###################

sub ALF_library {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'LIBRARY')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('library_item',$token+2,$object)	
	||	&ALF_SyntaxError('library',$token)
	);
}

sub ALF_library_item {	local($token,$object) = @_;
	&ALF_sublibrary($token,$object) ||
	&ALF_sublibrary_item($token,$object);
}

sub ALF_sublibrary {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'SUBLIBRARY')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('sublibrary_item',$token+2,$object)	
	||	&ALF_SyntaxError('sublibrary',$token)
	);
}

sub ALF_sublibrary_item {	local($token,$object) = @_;
	&ALF_cell($token,$object) ||
	&ALF_primitive($token,$object) ||
	&ALF_wire($token,$object) ||
	&ALF_layer($token,$object) ||
	&ALF_via($token,$object) ||
	&ALF_rule($token,$object) ||
	&ALF_antenna($token,$object) ||
	&ALF_array($token,$object) ||
	&ALF_site($token,$object) ||
	&ALF_region($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.3 ###
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.LIBRARY'}	= 'annotation';

$ALF_SyntaxRule{'LIBRARY.INFORMATION'}	= 'annotation_container';
$ALF_SyntaxRule{'SUBLIBRARY.INFORMATION'}	= 'annotation_container';
$ALF_SyntaxRule{'CELL.INFORMATION'}	= 'annotation_container';
$ALF_SyntaxRule{'WIRE.INFORMATION'}	= 'annotation_container';
$ALF_SyntaxRule{'PRIMITIVE.INFORMATION'}	= 'annotation_container';

$ALF_SyntaxRule{'INFORMATION.PRODUCT'}	= 'single_value_annotation';
$ALF_SyntaxRule{'INFORMATION.TITLE'}	= 'single_value_annotation';
$ALF_SyntaxRule{'INFORMATION.VERSION'}	= 'single_value_annotation';
$ALF_SyntaxRule{'INFORMATION.AUTHOR'}	= 'single_value_annotation';
$ALF_SyntaxRule{'INFORMATION.DATETIME'}	= 'single_value_annotation';

###################
### Clause  8.4 ###
###################

sub ALF_cell {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'CELL')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('cell_item',$token+2,$object)	
	||	&ALF_SyntaxError('cell',$token)
	);
}

sub ALF_cell_item {	local($token,$object) = @_;
	&ALF_pin($token,$object) ||
	&ALF_pingroup($token,$object) ||
	&ALF_primitive($token,$object) ||
	&ALF_function($token,$object) ||
	&ALF_non_scan_cell($token,$object) ||
	&ALF_test($token,$object) ||
	&ALF_vector($token,$object) ||
	&ALF_wire($token,$object) ||
	&ALF_blockage($token,$object) ||
	&ALF_artwork($token,$object) ||
	&ALF_pattern($token,$object) ||
	&ALF_region($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.5 ###
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.CELL'}	= 'annotation';

$ALF_SyntaxRule{'CELL.CELLTYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'CELL.RESTRICT_CLASS'}	= 'multi_value_annotation';
$ALF_SyntaxRule{'CLASS.RESTRICT_CLASS'}	= 'multi_value_annotation';

$ALF_SyntaxRule{'CELL.SWAP_CLASS'}	= 'single_value_annotation';

$ALF_SyntaxRule{'CELL.SCAN_TYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'CELL.SCAN_USAGE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'CELL.BUFFERTYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'CELL.DRIVERTYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'CELL.PARALLEL_DRIVE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'CELL.PLACEMENT_TYPE'}	= 'single_value_annotation';

###################
### Clause  8.6 ###
###################

sub ALF_pin {	local($token,$object) = @_;
	&StringMatch($ALF_ParserData[$token],'PIN')
	&& (	&ALF_LexicalRule('multi_index',$token+1)
	&& (	&ALF_LexicalRule('multi_index',$token+3)
	&&	&ALF_matrix_pin($token,$object)
	||	&ALF_vector_pin($token,$object)
	) ||	&ALF_scalar_pin($token,$object)
	);
}

sub ALF_scalar_pin {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'PIN')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('scalar_pin_item',$token+2,$object)	
	||	&ALF_SyntaxError('scalar_pin',$token)
	);
}
sub ALF_scalar_pin {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('scalar_pin_item',$token+2,$object)	
	||	&ALF_SyntaxError('scalar_pin',$token)
	;
}

sub ALF_vector_pin {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+2];
	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_DefineBus($object,$ALF_ParserData[$token+1])
	&&	&ALF_LexicalRule('identifier',$token+2,1)
	&& 	&ALF_SyntaxItems('vector_pin_item',$token+3,$object)	
	||	&ALF_SyntaxError('vector_pin',$token)
	;
}

sub ALF_matrix_pin {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+2];
	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_DefineBus($object,$ALF_ParserData[$token+1],$ALF_ParserData[$token+3])
	&&	&ALF_LexicalRule('identifier',$token+2,1)
	&& 	&ALF_SyntaxItems('matrix_pin_item',$token+4,$object)	
	||	&ALF_SyntaxError('matrix_pin',$token)
	;
}

sub ALF_scalar_pin_item {	local($token,$object) = @_;
	&ALF_pattern($token,$object) ||
	&ALF_port($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

sub ALF_vector_pin_item {	local($token,$object) = @_;
	&ALF_range($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

sub ALF_matrix_pin_item {	local($token,$object) = @_;
	&ALF_vector_pin_item($token,$object);
}

###################
### Clause  8.7 ###
###################

sub ALF_pingroup {	local($token,$object) = @_;
	&StringMatch($ALF_ParserData[$token],'PINGROUP')
	&& (	&ALF_LexicalRule('multi_index',$token+1)
	&&	&ALF_vector_pingroup($token,$object)
	||	&ALF_simple_pingroup($token,$object)
	);
}

sub ALF_simple_pingroup {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('all_purpose_item',$token+2,$object)	
	||	&ALF_SyntaxError('simple_pingroup',$token)
	;
}

sub ALF_vector_pingroup {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+2];
	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_DefineBus($object,$ALF_ParserData[$token+1])
	&&	&ALF_LexicalRule('identifier',$token+2,1)
	&& 	&ALF_SyntaxItems('vector_pingroup_item',$token+3,$object)	
	||	&ALF_SyntaxError('vector_pingroup',$token)
	;
}

sub ALF_vector_pingroup_item {	local($token,$object) = @_;
	&ALF_range($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.8 ###
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.PIN'}	= 'annotation';
$ALF_SyntaxRule{'FROM.PIN'}	= 'annotation';
$ALF_SyntaxRule{'TO.PIN'}	= 'annotation';

$ALF_SyntaxRule{'PINGROUP.MEMBERS'}  	= 'multi_value_annotation';

$ALF_SyntaxRule{'PIN.VIEW'}     	= 'single_value_annotation';
$ALF_SyntaxRule{'PINGROUP.VIEW'}     	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.PINTYPE'}  	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.DIRECTION'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.SIGNALTYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.ACTION'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.POLARITY'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.CONTROL_POLARITY'}    = 'annotation_container';

$ALF_SyntaxRule{'CONTROL_POLARITY.identifier'}    = 'single_value_annotation';

$ALF_SyntaxRule{'PIN.DATATYPE'}    	= 'single_value_annotation';
$ALF_SyntaxRule{'PINGROUP.DATATYPE'}     	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.INITIAL_VALUE'} 	= 'single_value_annotation';
$ALF_SyntaxRule{'PINGROUP.INITIAL_VALUE'} 	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.SCAN_POSITION'}    = 'single_value_annotation';

$ALF_SyntaxRule{'PIN.STUCK'}    = 'single_value_annotation';

$ALF_SyntaxRule{'PIN.SUPPLYTYPE'}    = 'single_value_annotation';
$ALF_SyntaxRule{'CLASS.SUPPLYTYPE'}    = 'single_value_annotation';

$ALF_SyntaxRule{'PIN.SIGNAL_CLASS'} 	= 'annotation';
$ALF_SyntaxRule{'PINGROUP.SIGNAL_CLASS'} 	= 'annotation';

$ALF_SyntaxRule{'PIN.SUPPLY_CLASS'} 	= 'annotation';
$ALF_SyntaxRule{'CLASS.SUPPLY_CLASS'} 	= 'annotation';
$ALF_SyntaxRule{'POWER.SUPPLY_CLASS'} 	= 'annotation';
$ALF_SyntaxRule{'ENERGY.SUPPLY_CLASS'} 	= 'annotation';

$ALF_SyntaxRule{'PIN.DRIVETYPE'}	= 'single_value_annotation';
$ALF_SyntaxRule{'CLASS.DRIVETYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.SCOPE'}    	= 'single_value_annotation';
$ALF_SyntaxRule{'PINGROUP.SCOPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.CONNECT_CLASS'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.SIDE'}	= 'single_value_annotation';
$ALF_SyntaxRule{'PINGROUP.SIDE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.ROW'} 	= 'annotation';
$ALF_SyntaxRule{'PINGROUP.ROW'}	= 'annotation';

$ALF_SyntaxRule{'PIN.COLUMN'}	= 'annotation';
$ALF_SyntaxRule{'PINGROUP.COLUMN'}	= 'annotation';

$ALF_SyntaxRule{'PIN.ROUTING_TYPE'}	= 'single_value_annotation';
$ALF_SyntaxRule{'PORT.ROUTING_TYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'PIN.PULL'}	= 'single_value_annotation';

###################
### Clause  8.9 ###
###################

sub ALF_primitive {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'PRIMITIVE')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('primitive_item',$token+2,$object)	
	||	&ALF_SyntaxError('primitive',$token)
	);
}

sub ALF_primitive_item {	local($token,$object) = @_;
	&ALF_pin($token,$object) ||
	&ALF_pingroup($token,$object) ||
	&ALF_function($token,$object) ||
	&ALF_test($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.10 ##
###################

sub ALF_wire {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'WIRE')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('wire_item',$token+2,$object)	
	||	&ALF_SyntaxError('wire',$token)
	);
}

sub ALF_wire_item {	local($token,$object) = @_;
	&ALF_node($token,$object) ||
### Errata: vector is missing in wire_item
	&ALF_vector($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.11 ##
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.WIRE'}	= 'annotation';

### Errata in text: WIRE annotation establishes association between arithmetic_model and wire, not vector

$ALF_SyntaxRule{'WIRE.WIRETYPE'}   	= 'single_value_annotation';

$ALF_SyntaxRule{'WIRE.SELECT_CLASS'}	= 'annotation';

###################
### Clause  8.12 ##
###################

sub ALF_node {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'NODE')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('node_item',$token+2,$object)	
	||	&ALF_SyntaxError('node',$token)
	);
}

sub ALF_node_item {	local($token,$object) = @_;
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.13 ##
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.NODE'}	= 'multi_value_annotation';

$ALF_SyntaxRule{'NODE.NODETYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'NODE.NODE_CLASS'}	= 'annotation';

###################
### Clause  8.14 ##
###################

sub ALF_vector {	local($token,$parent) = @_;
	local ($object,$type,$name,$start,$end,$list,%array);
	$type = $ALF_ParserData[$token];
	&StringMatch($type,'VECTOR')
	&& (	($start = $token + 1)
	&&	($list = &AutoName)
	&&	($end = &ALF_control_expression($start,$list) || &ALF_SyntaxError('control_expression',$start))
	&&	($name = join(' ',&GetSubArray('ALF_ParserData',$start,$end)))
	&&	(%array = %ALF_ExpressionToken)
	&&	($object = &ALF_CreateObject($parent,$type,$name))
	&&	($ALF_Expression{$object} = &CreateArray(sort(ByAscendingAssocVal &Array($list))))
	&& 	&ALF_SyntaxItems('vector_item',$end+1,$object)	
	||	&ALF_SyntaxError('vector',$token)
	);
}

sub ALF_vector_item {	local($token,$object) = @_;
	&ALF_wire_instantiation($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.15 ##
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.VECTOR'}	= 'single_value_annotation';

$ALF_SyntaxRule{'VECTOR.PURPOSE'}	= 'annotation';
$ALF_SyntaxRule{'CLASS.PURPOSE'}	= 'annotation';

$ALF_SyntaxRule{'VECTOR.OPERATION'}	= 'single_value_annotation';

$ALF_SyntaxRule{'VECTOR.LABEL'}	= 'single_value_annotation';

$ALF_SyntaxRule{'VECTOR.EXISTENCE_CONDITION'}	= 'single_value_annotation';
$ALF_SyntaxRule{'CLASS.EXISTENCE_CONDITION'}	= 'single_value_annotation';

$ALF_SyntaxRule{'VECTOR.EXISTENCE_CLASS'}	= 'annotation';
$ALF_SyntaxRule{'CLASS.EXISTENCE_CLASS'}	= 'annotation';

$ALF_SyntaxRule{'VECTOR.CHARACTERIZATION_CONDITION'}	= 'single_value_annotation';
$ALF_SyntaxRule{'CLASS.CHARACTERIZATION_CONDITION'}	= 'single_value_annotation';

$ALF_SyntaxRule{'VECTOR.CHARACTERIZATION_VECTOR'}	= 'single_value_annotation';
$ALF_SyntaxRule{'CLASS.CHARACTERIZATION_VECTOR'}	= 'single_value_annotation';

$ALF_SyntaxRule{'VECTOR.CHARACTERIZATION_CLASS'}	= 'annotation';
$ALF_SyntaxRule{'CLASS.CHARACTERIZATION_CLASS'}	= 'annotation';

### Errata: VECTOR.MONITOR should be multi_value_annotation instead of annotation
### $ALF_SyntaxRule{'VECTOR.MONITOR'}	= 'annotation';
### $ALF_SyntaxRule{'CLASS.MONITOR'}	= 'annotation';
$ALF_SyntaxRule{'VECTOR.MONITOR'}	= 'multi_value_annotation';
$ALF_SyntaxRule{'CLASS.MONITOR'}	= 'multi_value_annotation';

###################
### Clause  8.16 ##
###################

sub ALF_layer {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'LAYER')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('layer_item',$token+2,$object)	
	||	&ALF_SyntaxError('layer',$token)
	);
}

sub ALF_layer_item {	local($token,$object) = @_;
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.17 ##
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.LAYER'}	= 'annotation';
$ALF_SyntaxRule{'PATTERN.LAYER'}	= 'annotation';
$ALF_SyntaxRule{'ARRAY.LAYER'}	= 'annotation';

$ALF_SyntaxRule{'LAYER.LAYERTYPE'}	= 'single_value_annotation';

$ALF_SyntaxRule{'LAYER.PITCH'}	= 'single_value_annotation';

$ALF_SyntaxRule{'LAYER.PREFERENCE'}	= 'single_value_annotation';

###################
### Clause  8.18 ##
###################

sub ALF_via {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'VIA')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('via_item',$token+2,$object)	
	||	&ALF_SyntaxError('via',$token)
	);
}

sub ALF_via_item {	local($token,$object) = @_;
	&ALF_pattern($token,$object) ||
	&ALF_artwork($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.19 ##
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.VIA'}	= 'annotation';

$ALF_SyntaxRule{'VIA.VIATYPE'}	= 'single_value_annotation';

###################
### Clause  8.20 ##
###################

sub ALF_rule {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'RULE')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('rule_item',$token+2,$object)	
	||	&ALF_SyntaxError('rule',$token)
	);
}

sub ALF_rule_item {	local($token,$object) = @_;
	&ALF_pattern($token,$object) ||
	&ALF_region($token,$object) ||
	&ALF_via_instantiation($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.21 ##
###################

sub ALF_antenna {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'ANTENNA')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('antenna_item',$token+2,$object)	
	||	&ALF_SyntaxError('antenna',$token)
	);
}

sub ALF_antenna_item {	local($token,$object) = @_;
	&ALF_region($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.22 ##
###################

sub ALF_blockage {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'BLOCKAGE')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('blockage_item',$token+2,$object)	
	||	&ALF_SyntaxError('blockage',$token)
	);
}

sub ALF_blockage_item {	local($token,$object) = @_;
	&ALF_pattern($token,$object) ||
	&ALF_region($token,$object) ||
	&ALF_rule($token,$object) ||
	&ALF_via_instantiation($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.23 ##
###################

sub ALF_port {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'PORT')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('port_item',$token+2,$object)	
	||	&ALF_SyntaxError('port',$token)
	);
}

sub ALF_port_item {	local($token,$object) = @_;
	&ALF_pattern($token,$object) ||
	&ALF_region($token,$object) ||
	&ALF_rule($token,$object) ||
	&ALF_via_instantiation($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.24 ##
###################

$ALF_SyntaxRule{'PORT.PORTTYPE'}	= 'single_value_annotation';

###################
### Clause  8.25 ##
###################

sub ALF_site {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'SITE')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('site_item',$token+2,$object)	
	||	&ALF_SyntaxError('site',$token)
	);
}

sub ALF_site_item {	local($token,$object) = @_;
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.26 ##
###################

$ALF_SyntaxRule{'CELL.SITE'}	= 'annotation';
$ALF_SyntaxRule{'ARRAY.SITE'}	= 'annotation';
$ALF_SyntaxRule{'CLASS.SITE'}	= 'annotation';

$ALF_SyntaxRule{'SITE.ORIENTATION_CLASS'}	= 'annotation';
$ALF_SyntaxRule{'CELL.ORIENTATION_CLASS'}	= 'annotation';

$ALF_SyntaxRule{'SITE.SYMMETRY_CLASS'}	= 'multi_value_annotation';

### Errata: SYMMETRY_CLASS example uses CLASS.PURPOSE instead of CLASS.USAGE

###################
### Clause  8.27 ##
###################

sub ALF_array {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'ARRAY')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('array_item',$token+2,$object)	
	||	&ALF_SyntaxError('array',$token)
	);
}

sub ALF_array_item {	local($token,$object) = @_;
	&ALF_geometric_transformation($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.28 ##
###################

$ALF_SyntaxRule{'ARRAY.ARRAYTYPE'}	= 'single_value_annotation';

###################
### Clause  8.29 ##
###################

sub ALF_pattern {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'PATTERN')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('pattern_item',$token+2,$object)	
	||	&ALF_SyntaxError('pattern',$token)
	);
}

sub ALF_pattern_item {	local($token,$object) = @_;
	&ALF_geometric_model($token,$object) ||
	&ALF_geometric_transformation($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.30 ##
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.PATTERN'}	= 'annotation';

$ALF_SyntaxRule{'PATTERN.SHAPE'}	= 'single_value_annotation';
$ALF_SyntaxRule{'PATTERN.VERTEX'}	= 'single_value_annotation';
$ALF_SyntaxRule{'PATTERN.ROUTE'}	= 'single_value_annotation';

###################
### Clause  8.31 ##
###################

sub ALF_region {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'REGION')
	&& (	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& 	&ALF_SyntaxItems('region_item',$token+2,$object)
	||	&ALF_SyntaxError('region',$token)
	);
}

sub ALF_region_item {	local($token,$object) = @_;
	&ALF_geometric_model($token,$object) ||
	&ALF_geometric_transformation($token,$object) ||
	&ALF_all_purpose_item($token,$object);
}

###################
### Clause  8.32 ##
###################

$ALF_SyntaxRule{'ARITHMETIC_MODEL.REGION'}	= 'annotation';

$ALF_SyntaxRule{'REGION.BOOLEAN'}	= 'single_value_annotation';

1;