File Coverage

blib/lib/OPTIMADE/Filter/Parser.pm

Criterion	Covered	Total	%
statement	9	9	100.0
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	12	12	100.0

####################################################################
#
#    This file was generated using Parse::Yapp version 1.21.
#
#        Don't edit this file, use source file instead.
#
#             ANY CHANGE MADE HERE WILL BE LOST !
#
####################################################################
package OPTIMADE::Filter::Parser;
use vars qw ( @ISA );
use strict;

@ISA= qw ( Parse::Yapp::Driver );
use Parse::Yapp::Driver;

#line 3 "lib/OPTIMADE/Filter/Parser.yp"


use warnings;

use Scalar::Util qw(blessed);

use OPTIMADE::Filter::AndOr;
use OPTIMADE::Filter::Boolean;
use OPTIMADE::Filter::Comparison;
use OPTIMADE::Filter::Known;
use OPTIMADE::Filter::ListComparison;
use OPTIMADE::Filter::Negation;
use OPTIMADE::Filter::Property;
use OPTIMADE::Filter::Zip;

our $allow_LIKE_operator = 0;



sub new {
        my($class)=shift;
        ref($class)
    and $class=ref($class);

    my($self)=$class->SUPER::new( yyversion => '1.21',
                                  yystates =>
[
	{#State 0
		ACTIONS => {
			"(" => 11,
			'identifier' => 12,
			'NOT' => 6,
			'TRUE' => 3,
			'number' => 9,
			'FALSE' => 10,
			'string' => 16
		},
		GOTOS => {
			'expression_clause' => 17,
			'expression_phrase' => 18,
			'property' => 7,
			'comparison' => 8,
			'unordered_constant' => 14,
			'property_first_comparison' => 13,
			'filter' => 15,
			'constant_first_comparison' => 4,
			'openingbrace' => 5,
			'expression' => 2,
			'ordered_constant' => 1
		}
	},
	{#State 1
		ACTIONS => {
			"<" => 19,
			"=" => 23,
			">" => 24,
			"!" => 21
		},
		GOTOS => {
			'value_op_rhs' => 25,
			'value_rel_comp_rhs' => 22,
			'value_eq_rhs' => 27,
			'relative_comparison_operator' => 26,
			'equality_operator' => 20
		}
	},
	{#State 2
		DEFAULT => -1
	},
	{#State 3
		DEFAULT => -4
	},
	{#State 4
		DEFAULT => -28
	},
	{#State 5
		ACTIONS => {
			'TRUE' => 3,
			"(" => 11,
			'identifier' => 12,
			'NOT' => 6,
			'number' => 9,
			'string' => 16,
			'FALSE' => 10
		},
		GOTOS => {
			'openingbrace' => 5,
			'constant_first_comparison' => 4,
			'ordered_constant' => 1,
			'expression' => 28,
			'expression_clause' => 17,
			'expression_phrase' => 18,
			'property_first_comparison' => 13,
			'unordered_constant' => 14,
			'comparison' => 8,
			'property' => 7
		}
	},
	{#State 6
		ACTIONS => {
			'identifier' => 12,
			"(" => 11,
			'string' => 16,
			'FALSE' => 10,
			'TRUE' => 3,
			'number' => 9
		},
		GOTOS => {
			'openingbrace' => 30,
			'constant_first_comparison' => 4,
			'ordered_constant' => 1,
			'unordered_constant' => 14,
			'property_first_comparison' => 13,
			'property' => 7,
			'comparison' => 29
		}
	},
	{#State 7
		ACTIONS => {
			'CONTAINS' => 34,
			">" => 24,
			'HAS' => 35,
			'IS' => 36,
			'LIKE' => 48,
			"." => 45,
			"=" => 23,
			"!" => 21,
			":" => 40,
			"<" => 19,
			'STARTS' => 38,
			'LENGTH' => 37,
			'ENDS' => 39
		},
		DEFAULT => -32,
		GOTOS => {
			'set_op_rhs' => 42,
			'property_zip_addon' => 33,
			'colon' => 32,
			'dot' => 43,
			'value_eq_rhs' => 27,
			'relative_comparison_operator' => 26,
			'set_zip_op_rhs' => 31,
			'value_op_rhs' => 41,
			'known_op_rhs' => 47,
			'fuzzy_string_op_rhs' => 46,
			'value_rel_comp_rhs' => 22,
			'length_op_rhs' => 44,
			'equality_operator' => 20
		}
	},
	{#State 8
		DEFAULT => -24
	},
	{#State 9
		DEFAULT => -3
	},
	{#State 10
		DEFAULT => -5
	},
	{#State 11
		DEFAULT => -68
	},
	{#State 12
		DEFAULT => -66
	},
	{#State 13
		DEFAULT => -29
	},
	{#State 14
		ACTIONS => {
			"=" => 23,
			"!" => 21
		},
		GOTOS => {
			'value_eq_rhs' => 49,
			'equality_operator' => 20
		}
	},
	{#State 15
		ACTIONS => {
			'' => 50
		}
	},
	{#State 16
		DEFAULT => -2
	},
	{#State 17
		ACTIONS => {
			'OR' => 51
		},
		DEFAULT => -20
	},
	{#State 18
		ACTIONS => {
			'AND' => 52
		},
		DEFAULT => -22
	},
	{#State 19
		ACTIONS => {
			"=" => 53
		},
		DEFAULT => -77
	},
	{#State 20
		ACTIONS => {
			'number' => 9,
			'TRUE' => 3,
			'string' => 16,
			'FALSE' => 10,
			'identifier' => 12
		},
		GOTOS => {
			'value' => 54,
			'property' => 57,
			'ordered_constant' => 58,
			'unordered_constant' => 56,
			'ordered_value' => 55
		}
	},
	{#State 21
		ACTIONS => {
			"=" => 59
		}
	},
	{#State 22
		DEFAULT => -40
	},
	{#State 23
		DEFAULT => -75
	},
	{#State 24
		ACTIONS => {
			"=" => 60
		},
		DEFAULT => -79
	},
	{#State 25
		DEFAULT => -30
	},
	{#State 26
		ACTIONS => {
			'string' => 16,
			'number' => 9,
			'identifier' => 12
		},
		GOTOS => {
			'ordered_value' => 61,
			'property' => 57,
			'ordered_constant' => 58
		}
	},
	{#State 27
		DEFAULT => -39
	},
	{#State 28
		ACTIONS => {
			")" => 62
		},
		GOTOS => {
			'closingbrace' => 63
		}
	},
	{#State 29
		DEFAULT => -26
	},
	{#State 30
		ACTIONS => {
			'string' => 16,
			'TRUE' => 3,
			'FALSE' => 10,
			'number' => 9,
			'NOT' => 6,
			'identifier' => 12,
			"(" => 11
		},
		GOTOS => {
			'expression_phrase' => 18,
			'expression_clause' => 17,
			'unordered_constant' => 14,
			'property_first_comparison' => 13,
			'comparison' => 8,
			'property' => 7,
			'openingbrace' => 5,
			'constant_first_comparison' => 4,
			'ordered_constant' => 1,
			'expression' => 64
		}
	},
	{#State 31
		DEFAULT => -37
	},
	{#State 32
		ACTIONS => {
			'identifier' => 12
		},
		GOTOS => {
			'property' => 65
		}
	},
	{#State 33
		ACTIONS => {
			'HAS' => 67,
			":" => 40
		},
		GOTOS => {
			'colon' => 66
		}
	},
	{#State 34
		ACTIONS => {
			'string' => 16,
			'TRUE' => 3,
			'FALSE' => 10,
			'number' => 9,
			'identifier' => 12
		},
		GOTOS => {
			'value' => 68,
			'ordered_value' => 55,
			'ordered_constant' => 58,
			'unordered_constant' => 56,
			'property' => 57
		}
	},
	{#State 35
		ACTIONS => {
			'TRUE' => 3,
			">" => 24,
			'number' => 9,
			'ANY' => 70,
			'CONTAINS' => 34,
			'ALL' => 69,
			'FALSE' => 10,
			"=" => 23,
			"!" => 21,
			'identifier' => 12,
			'ONLY' => 71,
			'LIKE' => 48,
			'ENDS' => 39,
			'STARTS' => 38,
			"<" => 19,
			'string' => 16
		},
		GOTOS => {
			'ordered_constant' => 58,
			'ordered_value' => 55,
			'fuzzy_string_op_rhs' => 74,
			'equality_operator' => 73,
			'relative_comparison_operator' => 72,
			'unordered_constant' => 56,
			'property' => 57,
			'value' => 75
		}
	},
	{#State 36
		ACTIONS => {
			'UNKNOWN' => 77,
			'KNOWN' => 76
		}
	},
	{#State 37
		ACTIONS => {
			'TRUE' => 3,
			"!" => 21,
			"=" => 23,
			'identifier' => 12,
			"<" => 19,
			'number' => 9,
			'FALSE' => 10,
			'string' => 16,
			">" => 24
		},
		GOTOS => {
			'operator' => 78,
			'ordered_value' => 55,
			'ordered_constant' => 58,
			'relative_comparison_operator' => 81,
			'equality_operator' => 80,
			'unordered_constant' => 56,
			'property' => 57,
			'value' => 79
		}
	},
	{#State 38
		ACTIONS => {
			'string' => 16,
			'FALSE' => 10,
			'TRUE' => 3,
			'number' => 9,
			'WITH' => 82,
			'identifier' => 12
		},
		GOTOS => {
			'value' => 83,
			'ordered_constant' => 58,
			'unordered_constant' => 56,
			'property' => 57,
			'ordered_value' => 55
		}
	},
	{#State 39
		ACTIONS => {
			'identifier' => 12,
			'WITH' => 84,
			'number' => 9,
			'TRUE' => 3,
			'string' => 16,
			'FALSE' => 10
		},
		GOTOS => {
			'value' => 85,
			'unordered_constant' => 56,
			'ordered_constant' => 58,
			'property' => 57,
			'ordered_value' => 55
		}
	},
	{#State 40
		DEFAULT => -72
	},
	{#State 41
		DEFAULT => -33
	},
	{#State 42
		DEFAULT => -36
	},
	{#State 43
		ACTIONS => {
			'identifier' => 86
		}
	},
	{#State 44
		DEFAULT => -38
	},
	{#State 45
		DEFAULT => -70
	},
	{#State 46
		DEFAULT => -35
	},
	{#State 47
		DEFAULT => -34
	},
	{#State 48
		ACTIONS => {
			'identifier' => 12,
			'number' => 9,
			'TRUE' => 3,
			'FALSE' => 10,
			'string' => 16
		},
		GOTOS => {
			'ordered_constant' => 58,
			'unordered_constant' => 56,
			'property' => 57,
			'ordered_value' => 55,
			'value' => 87
		}
	},
	{#State 49
		DEFAULT => -31
	},
	{#State 50
		DEFAULT => 0
	},
	{#State 51
		ACTIONS => {
			'number' => 9,
			'string' => 16,
			'FALSE' => 10,
			"(" => 11,
			'NOT' => 6,
			'identifier' => 12,
			'TRUE' => 3
		},
		GOTOS => {
			'ordered_constant' => 1,
			'expression' => 88,
			'openingbrace' => 5,
			'constant_first_comparison' => 4,
			'unordered_constant' => 14,
			'property_first_comparison' => 13,
			'property' => 7,
			'comparison' => 8,
			'expression_clause' => 17,
			'expression_phrase' => 18
		}
	},
	{#State 52
		ACTIONS => {
			'identifier' => 12,
			'NOT' => 6,
			"(" => 11,
			'TRUE' => 3,
			'FALSE' => 10,
			'string' => 16,
			'number' => 9
		},
		GOTOS => {
			'ordered_constant' => 1,
			'constant_first_comparison' => 4,
			'openingbrace' => 5,
			'unordered_constant' => 14,
			'property_first_comparison' => 13,
			'comparison' => 8,
			'property' => 7,
			'expression_phrase' => 18,
			'expression_clause' => 89
		}
	},
	{#State 53
		DEFAULT => -78
	},
	{#State 54
		DEFAULT => -41
	},
	{#State 55
		DEFAULT => -7
	},
	{#State 56
		DEFAULT => -6
	},
	{#State 57
		ACTIONS => {
			"." => 45
		},
		DEFAULT => -9,
		GOTOS => {
			'dot' => 43
		}
	},
	{#State 58
		DEFAULT => -8
	},
	{#State 59
		DEFAULT => -76
	},
	{#State 60
		DEFAULT => -80
	},
	{#State 61
		DEFAULT => -42
	},
	{#State 62
		DEFAULT => -69
	},
	{#State 63
		DEFAULT => -25
	},
	{#State 64
		ACTIONS => {
			")" => 62
		},
		GOTOS => {
			'closingbrace' => 90
		}
	},
	{#State 65
		ACTIONS => {
			"." => 45
		},
		DEFAULT => -62,
		GOTOS => {
			'dot' => 43
		}
	},
	{#State 66
		ACTIONS => {
			'identifier' => 12
		},
		GOTOS => {
			'property' => 91
		}
	},
	{#State 67
		ACTIONS => {
			'TRUE' => 3,
			">" => 24,
			'ALL' => 96,
			'FALSE' => 10,
			'CONTAINS' => 34,
			'number' => 9,
			'ANY' => 95,
			'identifier' => 12,
			"=" => 23,
			"!" => 21,
			'LIKE' => 48,
			'ONLY' => 92,
			'STARTS' => 38,
			'ENDS' => 39,
			'string' => 16,
			"<" => 19
		},
		GOTOS => {
			'value' => 100,
			'value_list_entry' => 99,
			'unordered_constant' => 56,
			'equality_operator' => 20,
			'fuzzy_string_op_rhs' => 98,
			'value_rel_comp_rhs' => 97,
			'ordered_value' => 55,
			'value_zip' => 93,
			'property' => 57,
			'relative_comparison_operator' => 26,
			'value_eq_rhs' => 94,
			'ordered_constant' => 58
		}
	},
	{#State 68
		DEFAULT => -45
	},
	{#State 69
		ACTIONS => {
			'string' => 16,
			"<" => 19,
			'STARTS' => 38,
			'ENDS' => 39,
			'LIKE' => 48,
			'identifier' => 12,
			"!" => 21,
			"=" => 23,
			'FALSE' => 10,
			'CONTAINS' => 34,
			'number' => 9,
			">" => 24,
			'TRUE' => 3
		},
		GOTOS => {
			'property' => 57,
			'value_eq_rhs' => 94,
			'relative_comparison_operator' => 26,
			'ordered_constant' => 58,
			'value' => 100,
			'value_list_entry' => 101,
			'unordered_constant' => 56,
			'value_rel_comp_rhs' => 97,
			'fuzzy_string_op_rhs' => 98,
			'value_list' => 102,
			'equality_operator' => 20,
			'ordered_value' => 55
		}
	},
	{#State 70
		ACTIONS => {
			'TRUE' => 3,
			'LIKE' => 48,
			'identifier' => 12,
			"!" => 21,
			"=" => 23,
			'string' => 16,
			'FALSE' => 10,
			"<" => 19,
			'number' => 9,
			'CONTAINS' => 34,
			'STARTS' => 38,
			">" => 24,
			'ENDS' => 39
		},
		GOTOS => {
			'equality_operator' => 20,
			'value_rel_comp_rhs' => 97,
			'value_list' => 103,
			'fuzzy_string_op_rhs' => 98,
			'ordered_value' => 55,
			'value' => 100,
			'unordered_constant' => 56,
			'value_list_entry' => 101,
			'relative_comparison_operator' => 26,
			'value_eq_rhs' => 94,
			'ordered_constant' => 58,
			'property' => 57
		}
	},
	{#State 71
		ACTIONS => {
			'TRUE' => 3,
			'FALSE' => 10,
			'number' => 9,
			'CONTAINS' => 34,
			">" => 24,
			'LIKE' => 48,
			'identifier' => 12,
			"=" => 23,
			"!" => 21,
			'string' => 16,
			"<" => 19,
			'STARTS' => 38,
			'ENDS' => 39
		},
		GOTOS => {
			'ordered_value' => 55,
			'value_rel_comp_rhs' => 97,
			'fuzzy_string_op_rhs' => 98,
			'value_list' => 104,
			'equality_operator' => 20,
			'value_list_entry' => 101,
			'unordered_constant' => 56,
			'value' => 100,
			'ordered_constant' => 58,
			'value_eq_rhs' => 94,
			'relative_comparison_operator' => 26,
			'property' => 57
		}
	},
	{#State 72
		ACTIONS => {
			'number' => 9,
			'string' => 16,
			'identifier' => 12
		},
		GOTOS => {
			'ordered_value' => 105,
			'property' => 57,
			'ordered_constant' => 58
		}
	},
	{#State 73
		ACTIONS => {
			'number' => 9,
			'FALSE' => 10,
			'string' => 16,
			'TRUE' => 3,
			'identifier' => 12
		},
		GOTOS => {
			'value' => 106,
			'ordered_value' => 55,
			'property' => 57,
			'ordered_constant' => 58,
			'unordered_constant' => 56
		}
	},
	{#State 74
		DEFAULT => -54
	},
	{#State 75
		DEFAULT => -51
	},
	{#State 76
		DEFAULT => -43
	},
	{#State 77
		DEFAULT => -44
	},
	{#State 78
		ACTIONS => {
			'identifier' => 12,
			'number' => 9,
			'string' => 16,
			'FALSE' => 10,
			'TRUE' => 3
		},
		GOTOS => {
			'ordered_value' => 55,
			'ordered_constant' => 58,
			'unordered_constant' => 56,
			'property' => 57,
			'value' => 107
		}
	},
	{#State 79
		DEFAULT => -64
	},
	{#State 80
		DEFAULT => -73
	},
	{#State 81
		DEFAULT => -74
	},
	{#State 82
		ACTIONS => {
			'identifier' => 12,
			'number' => 9,
			'FALSE' => 10,
			'string' => 16,
			'TRUE' => 3
		},
		GOTOS => {
			'ordered_value' => 55,
			'unordered_constant' => 56,
			'ordered_constant' => 58,
			'property' => 57,
			'value' => 108
		}
	},
	{#State 83
		DEFAULT => -46
	},
	{#State 84
		ACTIONS => {
			'identifier' => 12,
			'FALSE' => 10,
			'string' => 16,
			'TRUE' => 3,
			'number' => 9
		},
		GOTOS => {
			'ordered_value' => 55,
			'ordered_constant' => 58,
			'unordered_constant' => 56,
			'property' => 57,
			'value' => 109
		}
	},
	{#State 85
		DEFAULT => -48
	},
	{#State 86
		DEFAULT => -67
	},
	{#State 87
		DEFAULT => -50
	},
	{#State 88
		DEFAULT => -21
	},
	{#State 89
		DEFAULT => -23
	},
	{#State 90
		DEFAULT => -27
	},
	{#State 91
		ACTIONS => {
			"." => 45
		},
		DEFAULT => -63,
		GOTOS => {
			'dot' => 43
		}
	},
	{#State 92
		ACTIONS => {
			"<" => 19,
			'string' => 16,
			'ENDS' => 39,
			'STARTS' => 38,
			'LIKE' => 48,
			"!" => 21,
			"=" => 23,
			'identifier' => 12,
			'number' => 9,
			'CONTAINS' => 34,
			'FALSE' => 10,
			">" => 24,
			'TRUE' => 3
		},
		GOTOS => {
			'unordered_constant' => 56,
			'value_list_entry' => 99,
			'value' => 100,
			'ordered_value' => 55,
			'value_zip_list' => 110,
			'value_zip' => 111,
			'equality_operator' => 20,
			'value_rel_comp_rhs' => 97,
			'fuzzy_string_op_rhs' => 98,
			'property' => 57,
			'ordered_constant' => 58,
			'relative_comparison_operator' => 26,
			'value_eq_rhs' => 94
		}
	},
	{#State 93
		ACTIONS => {
			":" => 40
		},
		DEFAULT => -58,
		GOTOS => {
			'colon' => 112
		}
	},
	{#State 94
		DEFAULT => -11
	},
	{#State 95
		ACTIONS => {
			'STARTS' => 38,
			'ENDS' => 39,
			'string' => 16,
			"<" => 19,
			'identifier' => 12,
			"=" => 23,
			"!" => 21,
			'LIKE' => 48,
			">" => 24,
			'FALSE' => 10,
			'CONTAINS' => 34,
			'number' => 9,
			'TRUE' => 3
		},
		GOTOS => {
			'value' => 100,
			'unordered_constant' => 56,
			'value_list_entry' => 99,
			'fuzzy_string_op_rhs' => 98,
			'value_rel_comp_rhs' => 97,
			'equality_operator' => 20,
			'value_zip' => 111,
			'value_zip_list' => 113,
			'ordered_value' => 55,
			'property' => 57,
			'value_eq_rhs' => 94,
			'relative_comparison_operator' => 26,
			'ordered_constant' => 58
		}
	},
	{#State 96
		ACTIONS => {
			'TRUE' => 3,
			'LIKE' => 48,
			'identifier' => 12,
			"!" => 21,
			"=" => 23,
			'string' => 16,
			'FALSE' => 10,
			"<" => 19,
			'number' => 9,
			'CONTAINS' => 34,
			'STARTS' => 38,
			">" => 24,
			'ENDS' => 39
		},
		GOTOS => {
			'property' => 57,
			'ordered_constant' => 58,
			'relative_comparison_operator' => 26,
			'value_eq_rhs' => 94,
			'unordered_constant' => 56,
			'value_list_entry' => 99,
			'value' => 100,
			'ordered_value' => 55,
			'value_zip_list' => 114,
			'value_zip' => 111,
			'equality_operator' => 20,
			'value_rel_comp_rhs' => 97,
			'fuzzy_string_op_rhs' => 98
		}
	},
	{#State 97
		DEFAULT => -12
	},
	{#State 98
		DEFAULT => -13
	},
	{#State 99
		ACTIONS => {
			":" => 40
		},
		GOTOS => {
			'colon' => 115
		}
	},
	{#State 100
		DEFAULT => -10
	},
	{#State 101
		DEFAULT => -14
	},
	{#State 102
		ACTIONS => {
			"," => 116
		},
		DEFAULT => -55,
		GOTOS => {
			'comma' => 117
		}
	},
	{#State 103
		ACTIONS => {
			"," => 116
		},
		DEFAULT => -56,
		GOTOS => {
			'comma' => 117
		}
	},
	{#State 104
		ACTIONS => {
			"," => 116
		},
		DEFAULT => -57,
		GOTOS => {
			'comma' => 117
		}
	},
	{#State 105
		DEFAULT => -53
	},
	{#State 106
		DEFAULT => -52
	},
	{#State 107
		DEFAULT => -65
	},
	{#State 108
		DEFAULT => -47
	},
	{#State 109
		DEFAULT => -49
	},
	{#State 110
		ACTIONS => {
			"," => 116
		},
		DEFAULT => -59,
		GOTOS => {
			'comma' => 118
		}
	},
	{#State 111
		ACTIONS => {
			":" => 40
		},
		DEFAULT => -18,
		GOTOS => {
			'colon' => 112
		}
	},
	{#State 112
		ACTIONS => {
			'number' => 9,
			'CONTAINS' => 34,
			'FALSE' => 10,
			">" => 24,
			'TRUE' => 3,
			"<" => 19,
			'string' => 16,
			'ENDS' => 39,
			'STARTS' => 38,
			'LIKE' => 48,
			"=" => 23,
			"!" => 21,
			'identifier' => 12
		},
		GOTOS => {
			'property' => 57,
			'unordered_constant' => 56,
			'value_list_entry' => 119,
			'value' => 100,
			'ordered_constant' => 58,
			'ordered_value' => 55,
			'fuzzy_string_op_rhs' => 98,
			'value_rel_comp_rhs' => 97,
			'value_eq_rhs' => 94,
			'relative_comparison_operator' => 26,
			'equality_operator' => 20
		}
	},
	{#State 113
		ACTIONS => {
			"," => 116
		},
		DEFAULT => -61,
		GOTOS => {
			'comma' => 118
		}
	},
	{#State 114
		ACTIONS => {
			"," => 116
		},
		DEFAULT => -60,
		GOTOS => {
			'comma' => 118
		}
	},
	{#State 115
		ACTIONS => {
			'number' => 9,
			'CONTAINS' => 34,
			'FALSE' => 10,
			">" => 24,
			'TRUE' => 3,
			"<" => 19,
			'string' => 16,
			'ENDS' => 39,
			'STARTS' => 38,
			'LIKE' => 48,
			"!" => 21,
			"=" => 23,
			'identifier' => 12
		},
		GOTOS => {
			'equality_operator' => 20,
			'fuzzy_string_op_rhs' => 98,
			'value_rel_comp_rhs' => 97,
			'ordered_value' => 55,
			'value' => 100,
			'value_list_entry' => 120,
			'unordered_constant' => 56,
			'relative_comparison_operator' => 26,
			'value_eq_rhs' => 94,
			'ordered_constant' => 58,
			'property' => 57
		}
	},
	{#State 116
		DEFAULT => -71
	},
	{#State 117
		ACTIONS => {
			">" => 24,
			'FALSE' => 10,
			'CONTAINS' => 34,
			'number' => 9,
			'TRUE' => 3,
			'STARTS' => 38,
			'ENDS' => 39,
			'string' => 16,
			"<" => 19,
			'identifier' => 12,
			"=" => 23,
			"!" => 21,
			'LIKE' => 48
		},
		GOTOS => {
			'ordered_constant' => 58,
			'value_eq_rhs' => 94,
			'relative_comparison_operator' => 26,
			'property' => 57,
			'ordered_value' => 55,
			'value_rel_comp_rhs' => 97,
			'fuzzy_string_op_rhs' => 98,
			'equality_operator' => 20,
			'unordered_constant' => 56,
			'value_list_entry' => 121,
			'value' => 100
		}
	},
	{#State 118
		ACTIONS => {
			'LIKE' => 48,
			'identifier' => 12,
			"!" => 21,
			"=" => 23,
			'string' => 16,
			"<" => 19,
			'STARTS' => 38,
			'ENDS' => 39,
			'TRUE' => 3,
			'FALSE' => 10,
			'number' => 9,
			'CONTAINS' => 34,
			">" => 24
		},
		GOTOS => {
			'unordered_constant' => 56,
			'value_list_entry' => 99,
			'value' => 100,
			'value_zip' => 122,
			'ordered_value' => 55,
			'value_rel_comp_rhs' => 97,
			'fuzzy_string_op_rhs' => 98,
			'equality_operator' => 20,
			'property' => 57,
			'ordered_constant' => 58,
			'value_eq_rhs' => 94,
			'relative_comparison_operator' => 26
		}
	},
	{#State 119
		DEFAULT => -17
	},
	{#State 120
		DEFAULT => -16
	},
	{#State 121
		DEFAULT => -15
	},
	{#State 122
		ACTIONS => {
			":" => 40
		},
		DEFAULT => -19,
		GOTOS => {
			'colon' => 112
		}
	}
],
                                  yyrules  =>
[
	[#Rule 0
		 '$start', 2, undef
	],
	[#Rule 1
		 'filter', 1, undef
	],
	[#Rule 2
		 'ordered_constant', 1, undef
	],
	[#Rule 3
		 'ordered_constant', 1, undef
	],
	[#Rule 4
		 'unordered_constant', 1,
sub
#line 35 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return OPTIMADE::Filter::Boolean->new( 1 );
                    }
	],
	[#Rule 5
		 'unordered_constant', 1,
sub
#line 39 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return OPTIMADE::Filter::Boolean->new( '' );
                    }
	],
	[#Rule 6
		 'value', 1, undef
	],
	[#Rule 7
		 'value', 1, undef
	],
	[#Rule 8
		 'ordered_value', 1, undef
	],
	[#Rule 9
		 'ordered_value', 1, undef
	],
	[#Rule 10
		 'value_list_entry', 1,
sub
#line 49 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return [ '=', $_[1] ];
                    }
	],
	[#Rule 11
		 'value_list_entry', 1,
sub
#line 53 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return [ $_[1]->operator, $_[1]->left ];
                    }
	],
	[#Rule 12
		 'value_list_entry', 1,
sub
#line 57 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return [ $_[1]->operator, $_[1]->left ];
                    }
	],
	[#Rule 13
		 'value_list_entry', 1,
sub
#line 61 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return [ $_[1]->operator, $_[1]->left ];
                    }
	],
	[#Rule 14
		 'value_list', 1,
sub
#line 67 "lib/OPTIMADE/Filter/Parser.yp"
{
                return [ $_[1] ];
            }
	],
	[#Rule 15
		 'value_list', 3,
sub
#line 71 "lib/OPTIMADE/Filter/Parser.yp"
{
                push @{$_[1]}, $_[3];
                return $_[1];
            }
	],
	[#Rule 16
		 'value_zip', 3,
sub
#line 78 "lib/OPTIMADE/Filter/Parser.yp"
{
                return [ $_[1], $_[3] ];
            }
	],
	[#Rule 17
		 'value_zip', 3,
sub
#line 82 "lib/OPTIMADE/Filter/Parser.yp"
{
                push @{$_[1]}, $_[3];
                return $_[1];
            }
	],
	[#Rule 18
		 'value_zip_list', 1,
sub
#line 89 "lib/OPTIMADE/Filter/Parser.yp"
{
                    return [ $_[1] ];
                }
	],
	[#Rule 19
		 'value_zip_list', 3,
sub
#line 93 "lib/OPTIMADE/Filter/Parser.yp"
{
                    push @{$_[1]}, $_[3];
                    return $_[1];
                }
	],
	[#Rule 20
		 'expression', 1, undef
	],
	[#Rule 21
		 'expression', 3,
sub
#line 103 "lib/OPTIMADE/Filter/Parser.yp"
{
                return OPTIMADE::Filter::AndOr->new( @_[1..$#_] );
            }
	],
	[#Rule 22
		 'expression_clause', 1, undef
	],
	[#Rule 23
		 'expression_clause', 3,
sub
#line 110 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return OPTIMADE::Filter::AndOr->new( @_[1..$#_] );
                    }
	],
	[#Rule 24
		 'expression_phrase', 1, undef
	],
	[#Rule 25
		 'expression_phrase', 3,
sub
#line 117 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return $_[2];
                    }
	],
	[#Rule 26
		 'expression_phrase', 2,
sub
#line 121 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return OPTIMADE::Filter::Negation->new( $_[2] );
                    }
	],
	[#Rule 27
		 'expression_phrase', 4,
sub
#line 125 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return OPTIMADE::Filter::Negation->new( $_[3] );
                    }
	],
	[#Rule 28
		 'comparison', 1, undef
	],
	[#Rule 29
		 'comparison', 1, undef
	],
	[#Rule 30
		 'constant_first_comparison', 2,
sub
#line 133 "lib/OPTIMADE/Filter/Parser.yp"
{
                                $_[2]->unshift_operand( $_[1] );
                                return $_[2];
                            }
	],
	[#Rule 31
		 'constant_first_comparison', 2,
sub
#line 138 "lib/OPTIMADE/Filter/Parser.yp"
{
                                $_[2]->unshift_operand( $_[1] );
                                return $_[2];
                            }
	],
	[#Rule 32
		 'property_first_comparison', 1,
sub
#line 145 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    my $cmp = OPTIMADE::Filter::Comparison->new( '=' );
                                    $cmp->left( $_[1] );
                                    $cmp->right( OPTIMADE::Filter::Boolean->new( 1 ) );
                                    return $cmp;
                                }
	],
	[#Rule 33
		 'property_first_comparison', 2,
sub
#line 152 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    $_[2]->unshift_operand( $_[1] );
                                    return $_[2];
                                }
	],
	[#Rule 34
		 'property_first_comparison', 2,
sub
#line 157 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    $_[2]->property( $_[1] );
                                    return $_[2];
                                }
	],
	[#Rule 35
		 'property_first_comparison', 2,
sub
#line 162 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    $_[2]->unshift_operand( $_[1] );
                                    return $_[2];
                                }
	],
	[#Rule 36
		 'property_first_comparison', 2,
sub
#line 167 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    $_[2]->property( $_[1] );
                                    return $_[2];
                                }
	],
	[#Rule 37
		 'property_first_comparison', 2,
sub
#line 172 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    $_[2]->unshift_property( $_[1] );
                                    return $_[2];
                                }
	],
	[#Rule 38
		 'property_first_comparison', 2,
sub
#line 177 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    $_[2]->property( $_[1] );
                                    return $_[2];
                                }
	],
	[#Rule 39
		 'value_op_rhs', 1, undef
	],
	[#Rule 40
		 'value_op_rhs', 1, undef
	],
	[#Rule 41
		 'value_eq_rhs', 2,
sub
#line 186 "lib/OPTIMADE/Filter/Parser.yp"
{
                    my $cmp = OPTIMADE::Filter::Comparison->new( $_[1] );
                    $cmp->push_operand( $_[2] );
                    return $cmp;
                }
	],
	[#Rule 42
		 'value_rel_comp_rhs', 2,
sub
#line 194 "lib/OPTIMADE/Filter/Parser.yp"
{
                        my $cmp = OPTIMADE::Filter::Comparison->new( $_[1] );
                        $cmp->push_operand( $_[2] );
                        return $cmp;
                    }
	],
	[#Rule 43
		 'known_op_rhs', 2,
sub
#line 202 "lib/OPTIMADE/Filter/Parser.yp"
{
                    return OPTIMADE::Filter::Known->new( 1 );
                }
	],
	[#Rule 44
		 'known_op_rhs', 2,
sub
#line 206 "lib/OPTIMADE/Filter/Parser.yp"
{
                    return OPTIMADE::Filter::Known->new( 0 );
                }
	],
	[#Rule 45
		 'fuzzy_string_op_rhs', 2,
sub
#line 212 "lib/OPTIMADE/Filter/Parser.yp"
{
                            my $cmp = OPTIMADE::Filter::Comparison->new( $_[1] );
                            $cmp->push_operand( $_[2] );
                            return $cmp;
                        }
	],
	[#Rule 46
		 'fuzzy_string_op_rhs', 2,
sub
#line 218 "lib/OPTIMADE/Filter/Parser.yp"
{
                            my $cmp = OPTIMADE::Filter::Comparison->new( $_[1] );
                            $cmp->push_operand( $_[2] );
                            return $cmp;
                        }
	],
	[#Rule 47
		 'fuzzy_string_op_rhs', 3,
sub
#line 224 "lib/OPTIMADE/Filter/Parser.yp"
{
                            my $cmp = OPTIMADE::Filter::Comparison->new( "$_[1] $_[2]" );
                            $cmp->push_operand( $_[3] );
                            return $cmp;
                        }
	],
	[#Rule 48
		 'fuzzy_string_op_rhs', 2,
sub
#line 230 "lib/OPTIMADE/Filter/Parser.yp"
{
                            my $cmp = OPTIMADE::Filter::Comparison->new( $_[1] );
                            $cmp->push_operand( $_[2] );
                            return $cmp;
                        }
	],
	[#Rule 49
		 'fuzzy_string_op_rhs', 3,
sub
#line 236 "lib/OPTIMADE/Filter/Parser.yp"
{
                            my $cmp = OPTIMADE::Filter::Comparison->new( "$_[1] $_[2]" );
                            $cmp->push_operand( $_[3] );
                            return $cmp;
                        }
	],
	[#Rule 50
		 'fuzzy_string_op_rhs', 2,
sub
#line 242 "lib/OPTIMADE/Filter/Parser.yp"
{
                            my $cmp = OPTIMADE::Filter::Comparison->new( $_[1] );
                            $cmp->push_operand( $_[2] );
                            return $cmp;
                        }
	],
	[#Rule 51
		 'set_op_rhs', 2,
sub
#line 250 "lib/OPTIMADE/Filter/Parser.yp"
{
                my $lc = OPTIMADE::Filter::ListComparison->new( $_[1] );
                $lc->values( [ [ '=', $_[2] ] ] );
                return $lc;
            }
	],
	[#Rule 52
		 'set_op_rhs', 3,
sub
#line 256 "lib/OPTIMADE/Filter/Parser.yp"
{
                my $lc = OPTIMADE::Filter::ListComparison->new( $_[1] );
                $lc->values( [ [ $_[2], $_[3] ] ] );
                return $lc;
            }
	],
	[#Rule 53
		 'set_op_rhs', 3,
sub
#line 262 "lib/OPTIMADE/Filter/Parser.yp"
{
                my $lc = OPTIMADE::Filter::ListComparison->new( $_[1] );
                $lc->values( [ [ $_[2], $_[3] ] ] );
                return $lc;
            }
	],
	[#Rule 54
		 'set_op_rhs', 2,
sub
#line 268 "lib/OPTIMADE/Filter/Parser.yp"
{
                my $lc = OPTIMADE::Filter::ListComparison->new( $_[1] );
                $lc->values( [ [ $_[2]->operator, $_[2]->left ] ] );
                return $lc;
            }
	],
	[#Rule 55
		 'set_op_rhs', 3,
sub
#line 274 "lib/OPTIMADE/Filter/Parser.yp"
{
                my $lc = OPTIMADE::Filter::ListComparison->new( "$_[1] $_[2]" );
                $lc->values( $_[3] );
                return $lc;
            }
	],
	[#Rule 56
		 'set_op_rhs', 3,
sub
#line 280 "lib/OPTIMADE/Filter/Parser.yp"
{
                my $lc = OPTIMADE::Filter::ListComparison->new( "$_[1] $_[2]" );
                $lc->values( $_[3] );
                return $lc;
            }
	],
	[#Rule 57
		 'set_op_rhs', 3,
sub
#line 286 "lib/OPTIMADE/Filter/Parser.yp"
{
                my $lc = OPTIMADE::Filter::ListComparison->new( "$_[1] $_[2]" );
                $lc->values( $_[3] );
                return $lc;
            }
	],
	[#Rule 58
		 'set_zip_op_rhs', 3,
sub
#line 294 "lib/OPTIMADE/Filter/Parser.yp"
{
                    $_[1]->operator( $_[2] );
                    $_[1]->values( [ $_[3] ] );
                    return $_[1];
                }
	],
	[#Rule 59
		 'set_zip_op_rhs', 4,
sub
#line 300 "lib/OPTIMADE/Filter/Parser.yp"
{
                    $_[1]->operator( "$_[2] $_[3]" );
                    $_[1]->values( $_[4] );
                    return $_[1];
                }
	],
	[#Rule 60
		 'set_zip_op_rhs', 4,
sub
#line 306 "lib/OPTIMADE/Filter/Parser.yp"
{
                    $_[1]->operator( "$_[2] $_[3]" );
                    $_[1]->values( $_[4] );
                    return $_[1];
                }
	],
	[#Rule 61
		 'set_zip_op_rhs', 4,
sub
#line 312 "lib/OPTIMADE/Filter/Parser.yp"
{
                    $_[1]->operator( "$_[2] $_[3]" );
                    $_[1]->values( $_[4] );
                    return $_[1];
                }
	],
	[#Rule 62
		 'property_zip_addon', 2,
sub
#line 320 "lib/OPTIMADE/Filter/Parser.yp"
{
                            my $zip = OPTIMADE::Filter::Zip->new;
                            $zip->push_property( $_[2] );
                            return $zip;
                        }
	],
	[#Rule 63
		 'property_zip_addon', 3,
sub
#line 326 "lib/OPTIMADE/Filter/Parser.yp"
{
                            $_[1]->push_property( $_[3] );
                            return $_[1];
                        }
	],
	[#Rule 64
		 'length_op_rhs', 2,
sub
#line 333 "lib/OPTIMADE/Filter/Parser.yp"
{
                    my $cmp = OPTIMADE::Filter::ListComparison->new( $_[1] );
                    $cmp->values( [ [ '=', $_[2] ] ] );
                    return $cmp;
                }
	],
	[#Rule 65
		 'length_op_rhs', 3,
sub
#line 339 "lib/OPTIMADE/Filter/Parser.yp"
{
                    my $cmp = OPTIMADE::Filter::ListComparison->new( $_[1] );
                    $cmp->values( [ [ $_[2], $_[3] ] ] );
                    return $cmp;
                }
	],
	[#Rule 66
		 'property', 1,
sub
#line 349 "lib/OPTIMADE/Filter/Parser.yp"
{
                return OPTIMADE::Filter::Property->new( $_[1] );
            }
	],
	[#Rule 67
		 'property', 3,
sub
#line 353 "lib/OPTIMADE/Filter/Parser.yp"
{
                push @{$_[1]}, $_[3];
                return $_[1];
            }
	],
	[#Rule 68
		 'openingbrace', 1, undef
	],
	[#Rule 69
		 'closingbrace', 1, undef
	],
	[#Rule 70
		 'dot', 1, undef
	],
	[#Rule 71
		 'comma', 1, undef
	],
	[#Rule 72
		 'colon', 1, undef
	],
	[#Rule 73
		 'operator', 1, undef
	],
	[#Rule 74
		 'operator', 1, undef
	],
	[#Rule 75
		 'equality_operator', 1, undef
	],
	[#Rule 76
		 'equality_operator', 2,
sub
#line 377 "lib/OPTIMADE/Filter/Parser.yp"
{
                        return join( '', @_[1..$#_] );
                    }
	],
	[#Rule 77
		 'relative_comparison_operator', 1, undef
	],
	[#Rule 78
		 'relative_comparison_operator', 2,
sub
#line 384 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    return join( '', @_[1..$#_] );
                                }
	],
	[#Rule 79
		 'relative_comparison_operator', 1, undef
	],
	[#Rule 80
		 'relative_comparison_operator', 2,
sub
#line 389 "lib/OPTIMADE/Filter/Parser.yp"
{
                                    return join( '', @_[1..$#_] );
                                }
	]
],
                                  @_);
    bless($self,$class);
}

#line 394 "lib/OPTIMADE/Filter/Parser.yp"


# Footer section

sub _Error
{
    my( $self ) = @_;
    close $self->{USER}{FILEIN} if $self->{USER}{FILEIN};
    my $msg = "$0: syntax error at line $self->{USER}{LINENO}, " .
              "position $self->{USER}{CHARNO}";
    if( $self->YYData->{INPUT} ) {
        $self->YYData->{INPUT} =~ s/\n$//;
        die "$msg: '" . $self->YYData->{INPUT} . "'.\n";
    } else {
        die "$msg.\n";
    }
}

sub _Lexer
{
    my( $self ) = @_;

    # If the line is empty and the input is originating from the file,
    # another line is read.
    if( !$self->YYData->{INPUT} && $self->{USER}{FILEIN} ) {
        my $filein = $self->{USER}{FILEIN};
        $self->YYData->{INPUT} = <$filein>;
        $self->{USER}{LINENO} = -1 unless exists $self->{USER}{LINENO};
        $self->{USER}{LINENO}++;
        $self->{USER}{CHARNO} = 0;
    }

    $self->YYData->{INPUT} =~ s/^(\s+)//;
    $self->{USER}{CHARNO} += length( $1 ) if defined $1;

    # Escaped double quote or backslash are detected here and returned
    # as is to the caller in order to be detected as syntax errors.
    if( $self->YYData->{INPUT} =~ s/^(\\"|\\\\)// ) {
        $self->{USER}{CHARNO} += length( $1 );
        return( $1, $1 );
    }

    # Handling strings
    if( $self->YYData->{INPUT} =~ s/^"// ) {
        $self->{USER}{CHARNO} ++;
        my $string = '';
        while( 1 ) {
            if( $self->YYData->{INPUT} =~
                    s/^([A-Za-z_0-9 \t!#\$\%&\'\(\)\*\+,\-\.\/\:;<=>\?@\[\]\^`\{\|\}\~\P{ASCII}]+)// ) {
                $self->{USER}{CHARNO} += length( $1 );
                $string .= $1;
            } elsif( $self->YYData->{INPUT} =~ s/^\\([\\"])// ) {
                $self->{USER}{CHARNO} ++;
                $string .= $1;
                next;
            } elsif( $self->YYData->{INPUT} =~ s/^"// ) {
                $self->{USER}{CHARNO} ++;
                return( 'string', $string );
            } else {
                return( undef, undef );
            }
        }
    }

    # Handling identifiers
    if( $self->YYData->{INPUT} =~ s/^([a-z_][a-z0-9_]*)// ) {
        $self->{USER}{CHARNO} += length( $1 );
        return( 'identifier', $1 );
    }

    # Handling textual operators and other literals
    if( $self->YYData->{INPUT} =~ s/^(AND|NOT|OR|
                                      IS|UNKNOWN|KNOWN|
                                      CONTAINS|STARTS|ENDS|WITH|
                                      LENGTH|HAS|ALL|ONLY|ANY|
                                      TRUE|FALSE)//x ) {
        $self->{USER}{CHARNO} += length( $1 );
        return( $1, $1 );
    }

    # Handling LIKE operator if allowed
    if( $allow_LIKE_operator && $self->YYData->{INPUT} =~ s/^(LIKE)// ) {
        $self->{USER}{CHARNO} += length( $1 );
        return( $1, $1 );
    }

    # Handling numbers
    if( $self->YYData->{INPUT} =~ s/^([+-]?
                                     (\d+\.?\d*|\.\d+)
                                     ([eE][+-]?\d+)?)//x ) {
        $self->{USER}{CHARNO} += length( $1 );
        return( 'number', $1 );
    }

    my $char = substr( $self->YYData->{INPUT}, 0, 1 );
    if( $char ne '' ) {
        $self->YYData->{INPUT} = substr( $self->YYData->{INPUT}, 1 );
    }
    $self->{USER}{CHARNO}++;
    return( $char, $char );
}

sub Run
{
    my( $self, $filename ) = @_;
    open $self->{USER}{FILEIN}, $filename;
    my $result = $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
    close $self->{USER}{FILEIN};
    return $result;
}

sub parse_string
{
    my( $self, $string ) = @_;
    $self->YYData->{INPUT} = $string;
    $self->{USER}{LINENO} = 0;
    $self->{USER}{CHARNO} = 0;
    return $self->YYParse( yylex => \&_Lexer, yyerror => \&_Error );
}

sub modify
{
    my $node = shift;
    my $code = shift;

    if( blessed $node && $node->can( 'modify' ) ) {
        return $node->modify( $code, @_ );
    } elsif( ref $node eq 'ARRAY' ) {
        return [ map { modify( $_, $code, @_ ) } @$node ];
    } else {
        return $code->( $node, @_ );
    }
}

1;

1;