#!/usr/bin/perl 

###################
### Clause  7.1 ###
###################

sub ALF_generic_object {	local($token,$parent) = @_;
	&ALF_alias_declaration($token,$parent) ||
	&ALF_constant_declaration($token,$parent) ||
	&ALF_class_declaration($token,$parent) ||
	&ALF_keyword_declaration($token,$parent) ||
	&ALF_semantics_declaration($token,$parent) ||
	&ALF_group_declaration($token,$parent) ||
	&ALF_template_declaration($token,$parent);
}

$ALF_SyntaxRule{'ALIAS'} = 'generic_object';
$ALF_SyntaxRule{'CONSTANT'} = 'generic_object';
$ALF_SyntaxRule{'CLASS'} = 'generic_object';
$ALF_SyntaxRule{'KEYWORD'} = 'generic_object';
$ALF_SyntaxRule{'SEMANTICS'} = 'generic_object';
$ALF_SyntaxRule{'GROUP'} = 'generic_object';
$ALF_SyntaxRule{'TEMPLATE'} = 'generic_object';

###################
### Clause  7.2 ###
###################

sub ALF_all_purpose_item {	local($token,$parent) = @_;
	&ALF_generic_object($token,$parent) ||
### Errata: &ALF_include_statement should be &ALF_include
###	&ALF_include_statement($token,$parent) ||
	&ALF_include($token,$parent) ||
### Errata: &ALF_associate_statement should be &ALF_associate
###	&ALF_associate_statement($token,$parent) ||
	&ALF_associate($token,$parent) ||
	&ALF_arithmetic_model_container($token,$parent) ||
	&ALF_arithmetic_model($token,$parent) ||
	&ALF_annotation_container($token,$parent) ||
	&ALF_annotation($token,$parent) ||
	&ALF_template_instantiation;
}

###################
### Clause  7.3 ###
###################

sub ALF_annotation {	local($token,$parent) = @_;
	local $type = $ALF_ParserData[$token];
	&ALF_SyntaxMatch('annotation',$type,$parent)
	&& (	&ALF_single_value_annotation($token,$parent)
	||	&ALF_multi_value_annotation($token,$parent)
	||	&ALF_SyntaxError('annotation',$token)
	) ||
	&ALF_SyntaxMatch('single_value_annotation',$type,$parent)
	&& (	&ALF_single_value_annotation($token,$parent)
	||	&ALF_SyntaxError('single_value_annotation',$token)
	) ||
	&ALF_SyntaxMatch('multi_value_annotation',$type,$parent)
	&& (	&ALF_multi_value_annotation($token,$parent)
	||	&ALF_SyntaxError('multi_value_annotation',$token)
	);
}

sub ALF_single_value_annotation {	local($token,$parent) = @_;
	local ($start,$end);
		$ALF_ParserData[$token+1] eq '='
	&&	($start = $token + 2)
	&&	($end = &ALF_annotation_value($start))
	&&	$ALF_ParserData[$end+1] eq ';'
	&&	&ALF_CreateObject($parent,$ALF_ParserData[$token],0,join(' ',&GetSubArray('ALF_ParserData',$start,$end)))
	&&	$end + 1;
}

sub ALF_multi_value_annotation {	local($token,$parent) = @_;
	local ($start,$end);
		$ALF_ParserData[$token+1] eq '{'	
	&&	($start = $token + 2)
	&&	($end = &ALF_LexicalItems('generic_value',$start))
	&&	&ALF_CreateObject($parent,$ALF_ParserData[$token],0,&CreateSubArray('ALF_ParserData',$start,$end))
	&&	$ALF_ParserData[$end+1] eq '}'
	&&	$end+1;
}

sub ALF_annotation_value {	local($token) = @_;
	&ALF_generic_value($token) ||
	&ALF_control_expression($token) ||
	&ALF_boolean_expression($token) ||
	&ALF_arithmetic_expression($token);
}

### ALF_edge_value implemented as syntax rule
### from Clause 6.12

sub ALF_edge_value {	local($token) = @_;
		$ALF_ParserData[$token] eq '('
	&&	&ALF_LexicalRule('edge_literal',$token+1)
	&&	$ALF_ParserData[$token+2] eq ')'
	&&	$token + 2;
}

### ALF_generic_value implemented as syntax rule
### from Clause 6.16

sub ALF_generic_value {	local($token) = @_;
	(	&ALF_LexicalRule('number',$token)
	||	&ALF_LexicalRule('identifier',$token)
	||	&ALF_LexicalRule('quoted_string',$token)
### Errata: bit_literal should be alphanumeric_bit_literal ???
	||	&ALF_LexicalRule('bit_literal',$token)
###	||	&ALF_LexicalRule('alphanumeric_bit_literal',$token)
	||	&ALF_LexicalRule('based_literal',$token)
	||	&ALF_LexicalRule('multiplier_prefix_symbol',$token)
	) &&	$token
	||	&ALF_edge_value($token);
}

###################
### Clause  7.4 ###
###################

### ALF_property is included in ALF_annotation_container
### see Clause 7.6

sub ALF_annotation_container {	local($token,$parent) = @_;
	local ($object,$type);
	$type = $ALF_ParserData[$token];
	&ALF_property($token,$parent)
	||	&ALF_SyntaxMatch('annotation_container',$type,$parent)
	&&	($object = &ALF_CreateObject($parent,$type))
	&& (	&ALF_SyntaxItems('annotation',$token+1,$object)
	||	&ALF_SyntaxError('annotation_container',$token+1)
	);
}

###################
### Clause  7.5 ###
###################

$ALF_SyntaxRule{'ATTRIBUTE'}	= 'multi_value_annotation';

###################
### Clause  7.6 ###
###################

sub ALF_property {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = &ALF_LexicalRule('identifier',$token+1)? $ALF_ParserData[$token+1] : 0;
	&StringMatch($type,'PROPERTY')
	&&	($token = $name? $token+2 : $token+1)
	&&	($object = &ALF_CreateObject($parent,$type,$name))
	&& (	&ALF_SyntaxItems('annotation',$token,$object)
	||	&ALF_SyntaxError('property_declaration',$token)
	);
}

$ALF_SyntaxRule{'PROPERTY.identifier'}	= 'annotation';

###################
### Clause  7.7 ###
###################

sub ALF_alias_declaration {	local($token,$parent) = @_;
	local ($type,$name,$value,$start,$end);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
### identify alias syntax
	&StringMatch($type,'ALIAS')
	&&	$ALF_ParserData[$token+2] eq '='
	&& (
### alias for identifier
	(	&ALF_LexicalRule('identifier',$token+1)
	&&	&ALF_LexicalRule('identifier',$token+3,1)
	&&	($value = $ALF_ParserData[$token+3])
	&&	($end = $token + 4)
### alias for vector expression
	||	&ALF_LexicalRule('vector_expression_macro',$token+1)
	&&	($start = $token + 4)
	&&	$ALF_ParserData[$start-1] eq '('
	&&	($end = &ALF_vector_expression($start))
	&&	$ALF_ParserData[$end+1] eq ')'
	&&	($value = join(' ',&GetSubArray('ALF_ParserData',$start-1,$end+1)))
	&&	($end = $end + 2)
### create alias object if valid termination
	) &&	$ALF_ParserData[$end] eq ';'
	&&	&ALF_CreateObject($parent,$type,$name,$value)	
	&&	$end
	||	&ALF_SyntaxError('alias_declaration',$token)
	);
}

###################
### Clause  7.8 ###
###################

sub ALF_constant_declaration {	local($token,$parent) = @_;
	local ($type,$name,$value);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	$value = $ALF_ParserData[$token+3];
	&StringMatch($type,'CONSTANT')
	&&	$ALF_ParserData[$token+2] eq '='
	&& (	$ALF_ParserData[$token+4] eq ';'
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&&	&ALF_LexicalRule('constant_value',$token+3,1)
	&&	&ALF_CreateObject($parent,$type,$name,$value)	
	&&	$token+4
	||	&ALF_SyntaxError('constant_declaration',$token)
	);
}

### ALF_constant_value implemented as lexical rule for simplicity

$ALF_constant_value = join('$|^',
	$ALF_number,
	$ALF_based_literal,
);

###################
### Clause  7.9 ###
###################

sub ALF_keyword_declaration {	local($token,$parent) = @_;
	local ($object,$type,$name,$value);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	$value = $ALF_ParserData[$token+3];
	&StringMatch($type,'KEYWORD')
	&&	$ALF_ParserData[$token+2] eq '='
	&& (	&ALF_LexicalRule('identifier',$token+1,1)
	&&	&ALF_LexicalRule('identifier',$token+3,1)
	&&	($object = &ALF_CreateObject($parent,$type,$name,$value))	
	&&	($token = &ALF_SyntaxItems('annotation',$token+4,$object))
### process the keyword information
	&&	&ALF_DefineKeywordRule($object)
	&&	$token
	||	&ALF_SyntaxError('keyword_declaration',$token)
	);
}

###################
### Clause  7.10 ##
###################

sub ALF_semantics_declaration {	local($token,$parent) = @_;
	local ($object,$type,$name,$value,$return);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'SEMANTICS')
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& (
### semantics with value
	(	$ALF_ParserData[$token+2] eq '='
	&&	&ALF_LexicalRule('identifier',$token+3,1)
	&&	($value = $ALF_ParserData[$token+3])
	&&	($token = $token + 4)
### semantics without value
	||	($token = $token + 2)
### create semantics object
	) && 	($object = &ALF_CreateObject($parent,$type,$name,$value))	
	&&	($return = &ALF_SyntaxItems('annotation',$token,$object))
#	&&	&ALF_CheckSemanticsDeclaration($object)
	&&	$return
	||	&ALF_SyntaxError('semantics_declaration',$token)
	);
}

###################
### Clause  7.11 ##
###################

$ALF_SyntaxRule{'KEYWORD.CONTEXT'}	= 'annotation';
$ALF_SyntaxRule{'SEMANTICS.CONTEXT'}	= 'annotation';
$ALF_SyntaxRule{'SEMANTICS.VALUETYPE'}	= 'single_value_annotation';
$ALF_SyntaxRule{'SEMANTICS.VALUES'}	= 'multi_value_annotation';
$ALF_SyntaxRule{'SEMANTICS.REFERENCETYPE'}	= 'annotation';
$ALF_SyntaxRule{'SEMANTICS.DEFAULT'}	= 'single_value_annotation';
$ALF_SyntaxRule{'ARITHMETIC_MODEL.DEFAULT'}	= 'single_value_annotation';
$ALF_SyntaxRule{'SEMANTICS.SI_MODEL'}	= 'single_value_annotation';

###################
### Clause  7.12 ##
###################

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

sub ALF_class_item {	local($token,$parent) = @_;
	&ALF_all_purpose_item($token,$parent) ||
#	&ALF_geometric_model($token,$parent) ||
#	&ALF_geometric_transformation($token,$parent) ||
	0;
}

###################
### Clause  7.13 ##
###################

$ALF_SyntaxRule{'LIBRARY_SPECIFIC_OBJECT.CLASS'}	= 'annotation';
$ALF_SyntaxRule{'ARITHMETIC_MODEL.CLASS'}	= 'annotation';
$ALF_SyntaxRule{'CLASS.USAGE'}	= 'annotation';

###################
### Clause  7.14 ##
###################

sub ALF_group_declaration {	local($token,$parent) = @_;
	local ($object,$type,$name,$start,$end);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
### identify group syntax
	&StringMatch($type,'GROUP')
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& (	($start = $token + 3)
	&&	$ALF_ParserData[$token+2] eq '{'	
	&& (
### group defined by left and right index
		$ALF_ParserData[$token+4] eq ':'
	&&	($end = $token + 5)
### group defined by set of values
	||	($end = &ALF_LexicalItems('generic_value',$start))
	) &&
### create group object if valid termination
		$ALF_ParserData[$end+1] eq '}'
	&&	($object = &ALF_CreateObject($parent,$type,$name,&CreateSubArray('ALF_ParserData',$start,$end)))
	&&	$end+1
	||	&ALF_SyntaxError('group_declaration',$token+1)
	);
}


###################
### Clause  7.15 ##
###################

sub ALF_template_declaration {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch($type,'TEMPLATE')
	&&	&ALF_LexicalRule('identifier',$token+1,1)
	&& (	($object = &ALF_CreateObject($parent,$type,$name))	
	&&	($token = &ALF_SyntaxItems('ALF_statement',$token+2,$object))
### process the template information
	&&	&ALF_DefineTemplateRule($object)
	&&	$token
	||	&ALF_SyntaxError('template_declaration',$token)
	);
}

sub ALF_ALF_statement {	local($token,$parent) = @_;
	&ALF_all_purpose_item($token,$parent) ||
	&ALF_library_specific_object($token,$parent) ||
	&ALF_function($token,$parent) ||
	&ALF_test($token,$parent) ||
	&ALF_behavior($token,$parent) ||
	&ALF_structure($token,$parent) ||
	&ALF_statetable($token,$parent) ||
	&ALF_cell_instantiation($token,$parent) ||
	&ALF_wire_instantiation($token,$parent) ||
	&ALF_non_scan_cell($token,$parent) ||
	&ALF_geometric_model($token,$parent) ||
	&ALF_artwork($token,$parent) ||
#	&ALF_equation($token,$parent) ||
	&ALF_violation($token,$parent) ||
	0;
}

###################
### Clause  7.16 ##
###################

sub ALF_template_instantiation {	local($token,$parent) = @_;
	local $type = $ALF_ParserData[$token];
	&ALF_SyntaxMatch('template_instantiation',&UpperCase($type),$parent)
	&& (	&ALF_static_template_instantiation($token,$parent)
	||	&ALF_dynamic_template_instantiation($token,$parent)
	||	&ALF_SyntaxError('template_instantiation',$token)
	);
}

### reference by order not yet implemented

sub ALF_static_template_instantiation {	local($token,$parent) = @_;
	local ($object,$type,$value);
	$type = $ALF_ParserData[$token];
	$value = $ALF_ParserData[$token+2] if ($ALF_ParserData[$token+1] eq '=');
	$token = $value? $token + 3 : $token + 1;
	(! $value || &StringMatch('static',$value))
	&& (	($object = &ALF_CreateObject($parent,$type))
	&&	&ALF_DefineReferenceRule($object,'annotation')
	&&	&ALF_SyntaxItems('annotation',$token,$object)
	||	&ALF_SyntaxError('static_template_instantiation',$token)
	);
}

sub ALF_dynamic_template_instantiation {	local($token,$parent) = @_;
	local ($object,$type,$value);
	$type = $ALF_ParserData[$token];
	$value = $ALF_ParserData[$token+2];
	&StringMatch('dynamic',$value)
	&&	$ALF_ParserData[$token+1] eq '='
	&& (	($object = &ALF_CreateObject($parent,$type,0,$value))
	&&	&ALF_DefineReferenceRule($object,'dynamic_template_instantiation_item')
	&&	&ALF_DefineDynamicTemplateRule($object)
	&&	&ALF_SyntaxItems('dynamic_template_instantiation_item',$token+3,$object)
	||	&ALF_SyntaxError('dynamic_template_instantiation',$token+3)
	);
}

sub ALF_dynamic_template_instantiation_item {	local($token,$parent) = @_;
	&ALF_arithmetic_assignment($token,$parent) ||
	&ALF_annotation($token,$parent) ||
	&ALF_arithmetic_model($token,$parent);
}

sub ALF_arithmetic_assignment {	local($token,$parent) = @_;
	local ($type,$value,$start,$end); 
	$type = $ALF_ParserData[$token];
	&ALF_LexicalRule('identifier',$token)
	&& $ALF_ParserData[$token+1] eq '='
	&& ($start = $token+2)
	&& ($end = &ALF_arithmetic_expression($start))
	&& (($value = join(' ',&GetSubArray('ALF_ParserData',$start,$end))) || defined($value))
	&& &ALF_CreateObject($parent,$type,0,$value)
	&& (	$ALF_ParserData[$end+1] eq ';'
	&&	$end+1
	||	&ALF_SyntaxError('arithmetic_assignment',$end+1)
	);
}

###################
### Clause  7.17 ##
###################

sub ALF_include {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch('INCLUDE',$type)
	&& (	&ALF_LexicalRule('quoted_string',$token+1,1)
	&&	($object = &ALF_CreateObject($parent,$type,$name))
	&&	$ALF_ParserData[$token+2] eq ';'
	&&	&ALF_ProcessIncludedFile($object)
	&&	$token+2
	||	&ALF_SyntaxError('include',$token)
	);
}

###################
### Clause  7.18 ##
###################

sub ALF_associate {	local($token,$parent) = @_;
	local ($object,$type,$name);
	$type = $ALF_ParserData[$token];
	$name = $ALF_ParserData[$token+1];
	&StringMatch('ASSOCIATE',$type)
	&& (	&ALF_LexicalRule('quoted_string',$token+1,1)
	&&	($object = &ALF_CreateObject($parent,$type,$name))
	&&	&ALF_SyntaxItems('single_value_annotation',$token+2,$object)
	||	&ALF_SyntaxError('associate',$token)
	);
}

$ALF_SyntaxRule{'ASSOCIATE.FORMAT'}	= 'single_value_annotation';

###################
### Clause  7.19 ##
###################

### ALF_revision statement implemented in
### sub ALF_CreateData {	local($parent) = @_;
### see OpenALF.parseALF.pl

1;