Commit fe5357c265e79241484b5c855055c12a37847b07 - libcypher-parser

Merge tag 'dist/0.5.2' into debian Upstream version 0.5.2 Chris Leishman 7 years ago

9 changed file(s) with 387 addition(s) and 21 deletion(s). Raw diff Collapse all Expand all

+10

-10

configure less more

0	0	#! /bin/sh
1	1	# Guess values for system-dependent variables and create Makefiles.
2		# Generated by GNU Autoconf 2.69 for libcypher-parser 0.5.1.
	2	# Generated by GNU Autoconf 2.69 for libcypher-parser 0.5.2.
3	3	#
4	4	#
5	5	# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.

586	586	# Identity of this package.
587	587	PACKAGE_NAME='libcypher-parser'
588	588	PACKAGE_TARNAME='libcypher-parser'
589		PACKAGE_VERSION='0.5.1'
590		PACKAGE_STRING='libcypher-parser 0.5.1'
	589	PACKAGE_VERSION='0.5.2'
	590	PACKAGE_STRING='libcypher-parser 0.5.2'
591	591	PACKAGE_BUGREPORT=''
592	592	PACKAGE_URL=''
593	593

1398	1398	# Omit some internal or obsolete options to make the list less imposing.
1399	1399	# This message is too long to be a string in the A/UX 3.1 sh.
1400	1400	cat <<_ACEOF
1401		\`configure' configures libcypher-parser 0.5.1 to adapt to many kinds of systems.
	1401	\`configure' configures libcypher-parser 0.5.2 to adapt to many kinds of systems.
1402	1402
1403	1403	Usage: $0 [OPTION]... [VAR=VALUE]...
1404	1404

1469	1469
1470	1470	if test -n "$ac_init_help"; then
1471	1471	case $ac_init_help in
1472		short \| recursive ) echo "Configuration of libcypher-parser 0.5.1:";;
	1472	short \| recursive ) echo "Configuration of libcypher-parser 0.5.2:";;
1473	1473	esac
1474	1474	cat <<\_ACEOF
1475	1475

1609	1609	test -n "$ac_init_help" && exit $ac_status
1610	1610	if $ac_init_version; then
1611	1611	cat <<\_ACEOF
1612		libcypher-parser configure 0.5.1
	1612	libcypher-parser configure 0.5.2
1613	1613	generated by GNU Autoconf 2.69
1614	1614
1615	1615	Copyright (C) 2012 Free Software Foundation, Inc.

2074	2074	This file contains any messages produced by compilers while
2075	2075	running configure, to aid debugging if configure makes a mistake.
2076	2076
2077		It was created by libcypher-parser $as_me 0.5.1, which was
	2077	It was created by libcypher-parser $as_me 0.5.2, which was
2078	2078	generated by GNU Autoconf 2.69. Invocation command line was
2079	2079
2080	2080	$ $0 $@

2939	2939
2940	2940	# Define the identity of the package.
2941	2941	PACKAGE='libcypher-parser'
2942		VERSION='0.5.1'
	2942	VERSION='0.5.2'
2943	2943
2944	2944
2945	2945	cat >>confdefs.h <<_ACEOF

17078	17078	# report actual input values of CONFIG_FILES etc. instead of their
17079	17079	# values after options handling.
17080	17080	ac_log="
17081		This file was extended by libcypher-parser $as_me 0.5.1, which was
	17081	This file was extended by libcypher-parser $as_me 0.5.2, which was
17082	17082	generated by GNU Autoconf 2.69. Invocation command line was
17083	17083
17084	17084	CONFIG_FILES = $CONFIG_FILES

17144	17144	cat >>$CONFIG_STATUS <<_ACEOF \|\| ac_write_fail=1
17145	17145	ac_cs_config="`$as_echo "$ac_configure_args" \| sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
17146	17146	ac_cs_version="\\
17147		libcypher-parser config.status 0.5.1
	17147	libcypher-parser config.status 0.5.2
17148	17148	configured by $0, generated by GNU Autoconf 2.69,
17149	17149	with options \\"\$ac_cs_config\\"
17150	17150

-1

configure.ac less more

13	13	#
14	14	dnl Process this file with autoconf to produce a configure script
15	15	AC_PREREQ([2.69])
16		AC_INIT([libcypher-parser],[0.5.1])
	16	AC_INIT([libcypher-parser],[0.5.2])
17	17	AC_CONFIG_SRCDIR([src/lib/cypher-parser.h])
18	18	AC_CONFIG_MACRO_DIR([m4])
19	19	AM_INIT_AUTOMAKE([foreign])

-0

debian/changelog less more

	0	libcypher-parser (0.5.2-1) unstable; urgency=medium
	1
	2	* New upstream release.
	3	- Fixes an issue tracking line numbers over multiple statements.
	4
	5	-- Chris Leishman <chris@leishman.org> Sat, 24 Sep 2016 17:40:49 +0000
	6
0	7	libcypher-parser (0.5.1-1) unstable; urgency=medium
1	8
2	9	* New upstream release.

-1

src/lib/Makefile.am less more

142	142	# increment age.
143	143	# 4. If any interfaces have been removed or changed since the last public
144	144	# release, then set age to 0.
145		libcypher_parser_la_LDFLAGS = -version-info 9:0:1
	145	libcypher_parser_la_LDFLAGS = -version-info 9:1:1
146	146
147	147	parser.c: parser_leg.c
148	148	quick_parser.c: quick_parser_leg.c

-1

src/lib/Makefile.in less more

620	620	# increment age.
621	621	# 4. If any interfaces have been removed or changed since the last public
622	622	# release, then set age to 0.
623		libcypher_parser_la_LDFLAGS = -version-info 9:0:1
	623	libcypher_parser_la_LDFLAGS = -version-info 9:1:1
624	624	EXTRA_DIST = parser_leg.c quick_parser_leg.c
625	625	MAINTAINERCLEANFILES = parser_leg.c quick_parser_leg.c
626	626	all: all-am

-6

src/lib/parser.c less more

654	654	}
655	655
656	656	yy.position_offset = range.end;
	657
	658	offsets_clear(&(yy.line_start_offsets));
	659	if (offsets_push(&(yy.line_start_offsets), 0))
	660	{
	661	goto cleanup;
	662	}
657	663	}
658	664
659	665	result = 0;

715	721	goto failure;
716	722	}
717	723
718		offsets_clear(&(yy->line_start_offsets));
719		if (offsets_push(&(yy->line_start_offsets), 0))
720		{
721		goto failure;
722		}
723
724	724	assert(blocks_size(&(yy->blocks)) == 1 &&
725	725	"Mismatched use of `<` and `>` in grammar");
726	726	assert(blocks_last(&(yy->blocks)) == top_block &&

+286

-1

src/lib/parser_leg.c less more

0		/* A recursive-descent parser generated by peg 0.1.15 */
	0	/* A recursive-descent parser generated by peg 0.1.18 */
1	1
2	2	#include <stdio.h>
3	3	#include <stdlib.h>

534	534	#define yythunkpos yy->__thunkpos
535	535	yyprintf((stderr, "do yy_1__null_\n"));
536	536	{
	537	#line 1075
537	538	__ = NULL; ;
538	539	}
539	540	#undef yythunkpos

547	548	#define yythunkpos yy->__thunkpos
548	549	yyprintf((stderr, "do yy_1_skip_to_clause\n"));
549	550	{
	551	#line 1040
550	552	__ = skip(); ;
551	553	}
552	554	#undef yythunkpos

560	562	#define yythunkpos yy->__thunkpos
561	563	yyprintf((stderr, "do yy_1_skip_to_statement\n"));
562	564	{
	565	#line 1029
563	566	__ = skip(); ;
564	567	}
565	568	#undef yythunkpos

573	576	#define yythunkpos yy->__thunkpos
574	577	yyprintf((stderr, "do yy_1_skip_to_directive\n"));
575	578	{
	579	#line 1020
576	580	__ = skip(); ;
577	581	}
578	582	#undef yythunkpos

586	590	#define yythunkpos yy->__thunkpos
587	591	yyprintf((stderr, "do yy_1_EOF\n"));
588	592	{
	593	#line 855
589	594	yy->eof = true; ;
590	595	}
591	596	#undef yythunkpos

599	604	#define yythunkpos yy->__thunkpos
600	605	yyprintf((stderr, "do yy_1_block_comment\n"));
601	606	{
	607	#line 849
602	608	block_comment(); ;
603	609	}
604	610	#undef yythunkpos

612	618	#define yythunkpos yy->__thunkpos
613	619	yyprintf((stderr, "do yy_1_line_comment\n"));
614	620	{
	621	#line 846
615	622	line_comment(); ;
616	623	}
617	624	#undef yythunkpos

625	632	#define yythunkpos yy->__thunkpos
626	633	yyprintf((stderr, "do yy_1_integer_string\n"));
627	634	{
	635	#line 831
628	636	strbuf_append_block(); ;
629	637	}
630	638	#undef yythunkpos

638	646	#define yythunkpos yy->__thunkpos
639	647	yyprintf((stderr, "do yy_2_float_string\n"));
640	648	{
	649	#line 824
641	650	strbuf_append_block(); ;
642	651	}
643	652	#undef yythunkpos

651	660	#define yythunkpos yy->__thunkpos
652	661	yyprintf((stderr, "do yy_1_float_string\n"));
653	662	{
	663	#line 823
654	664	strbuf_append_block(); ;
655	665	}
656	666	#undef yythunkpos

664	674	#define yythunkpos yy->__thunkpos
665	675	yyprintf((stderr, "do yy_1_escaped_symbolic_name\n"));
666	676	{
	677	#line 817
667	678	strbuf_append_block(); ;
668	679	}
669	680	#undef yythunkpos

677	688	#define yythunkpos yy->__thunkpos
678	689	yyprintf((stderr, "do yy_1_unescaped_symbolic_name\n"));
679	690	{
	691	#line 815
680	692	strbuf_append_block(); ;
681	693	}
682	694	#undef yythunkpos

690	702	#define yythunkpos yy->__thunkpos
691	703	yyprintf((stderr, "do yy_11_escaped_char\n"));
692	704	{
	705	#line 809
693	706	strbuf_append("?", 1); ;
694	707	}
695	708	#undef yythunkpos

703	716	#define yythunkpos yy->__thunkpos
704	717	yyprintf((stderr, "do yy_10_escaped_char\n"));
705	718	{
	719	#line 808
706	720	strbuf_append("\"", 1); ;
707	721	}
708	722	#undef yythunkpos

716	730	#define yythunkpos yy->__thunkpos
717	731	yyprintf((stderr, "do yy_9_escaped_char\n"));
718	732	{
	733	#line 807
719	734	strbuf_append("'", 1); ;
720	735	}
721	736	#undef yythunkpos

729	744	#define yythunkpos yy->__thunkpos
730	745	yyprintf((stderr, "do yy_8_escaped_char\n"));
731	746	{
	747	#line 806
732	748	strbuf_append("\\", 1); ;
733	749	}
734	750	#undef yythunkpos

742	758	#define yythunkpos yy->__thunkpos
743	759	yyprintf((stderr, "do yy_7_escaped_char\n"));
744	760	{
	761	#line 805
745	762	strbuf_append("\v", 1); ;
746	763	}
747	764	#undef yythunkpos

755	772	#define yythunkpos yy->__thunkpos
756	773	yyprintf((stderr, "do yy_6_escaped_char\n"));
757	774	{
	775	#line 804
758	776	strbuf_append("\t", 1); ;
759	777	}
760	778	#undef yythunkpos

768	786	#define yythunkpos yy->__thunkpos
769	787	yyprintf((stderr, "do yy_5_escaped_char\n"));
770	788	{
	789	#line 803
771	790	strbuf_append("\r", 1); ;
772	791	}
773	792	#undef yythunkpos

781	800	#define yythunkpos yy->__thunkpos
782	801	yyprintf((stderr, "do yy_4_escaped_char\n"));
783	802	{
	803	#line 802
784	804	strbuf_append("\n", 1); ;
785	805	}
786	806	#undef yythunkpos

794	814	#define yythunkpos yy->__thunkpos
795	815	yyprintf((stderr, "do yy_3_escaped_char\n"));
796	816	{
	817	#line 801
797	818	strbuf_append("\f", 1); ;
798	819	}
799	820	#undef yythunkpos

807	828	#define yythunkpos yy->__thunkpos
808	829	yyprintf((stderr, "do yy_2_escaped_char\n"));
809	830	{
	831	#line 800
810	832	strbuf_append("\b", 1); ;
811	833	}
812	834	#undef yythunkpos

820	842	#define yythunkpos yy->__thunkpos
821	843	yyprintf((stderr, "do yy_1_escaped_char\n"));
822	844	{
	845	#line 799
823	846	strbuf_append("\a", 1); ;
824	847	}
825	848	#undef yythunkpos

833	856	#define yythunkpos yy->__thunkpos
834	857	yyprintf((stderr, "do yy_2_double_quoted\n"));
835	858	{
	859	#line 795
836	860	strbuf_append_block(); ;
837	861	}
838	862	#undef yythunkpos

846	870	#define yythunkpos yy->__thunkpos
847	871	yyprintf((stderr, "do yy_1_double_quoted\n"));
848	872	{
	873	#line 793
849	874	strbuf_append_block(); ;
850	875	}
851	876	#undef yythunkpos

859	884	#define yythunkpos yy->__thunkpos
860	885	yyprintf((stderr, "do yy_2_single_quoted\n"));
861	886	{
	887	#line 789
862	888	strbuf_append_block(); ;
863	889	}
864	890	#undef yythunkpos

872	898	#define yythunkpos yy->__thunkpos
873	899	yyprintf((stderr, "do yy_1_single_quoted\n"));
874	900	{
	901	#line 787
875	902	strbuf_append_block(); ;
876	903	}
877	904	#undef yythunkpos

885	912	#define yythunkpos yy->__thunkpos
886	913	yyprintf((stderr, "do yy_2_unquoted\n"));
887	914	{
	915	#line 781
888	916	strbuf_append_block(); ;
889	917	}
890	918	#undef yythunkpos

898	926	#define yythunkpos yy->__thunkpos
899	927	yyprintf((stderr, "do yy_1_unquoted\n"));
900	928	{
	929	#line 779
901	930	strbuf_append(";", 1); ;
902	931	}
903	932	#undef yythunkpos

911	940	#define yythunkpos yy->__thunkpos
912	941	yyprintf((stderr, "do yy_2_client_arg_string\n"));
913	942	{
	943	#line 768
914	944	__ = strbuf_string(); ;
915	945	}
916	946	#undef yythunkpos

924	954	#define yythunkpos yy->__thunkpos
925	955	yyprintf((stderr, "do yy_1_client_arg_string\n"));
926	956	{
	957	#line 767
927	958	strbuf_reset(); ;
928	959	}
929	960	#undef yythunkpos

938	969	#define yythunkpos yy->__thunkpos
939	970	yyprintf((stderr, "do yy_1_client_command_arg\n"));
940	971	{
	972	#line 765
941	973	__ = s; ;
942	974	}
943	975	#undef yythunkpos

953	985	#define yythunkpos yy->__thunkpos
954	986	yyprintf((stderr, "do yy_1_client_command_name\n"));
955	987	{
	988	#line 763
956	989	__ = n; ;
957	990	}
958	991	#undef yythunkpos

969	1002	#define yythunkpos yy->__thunkpos
970	1003	yyprintf((stderr, "do yy_2_client_command\n"));
971	1004	{
	1005	#line 759
972	1006	__ = command(n); ;
973	1007	}
974	1008	#undef yythunkpos

986	1020	#define yythunkpos yy->__thunkpos
987	1021	yyprintf((stderr, "do yy_1_client_command\n"));
988	1022	{
	1023	#line 757
989	1024	sequence_add(a); ;
990	1025	}
991	1026	#undef yythunkpos

1003	1038	#define yythunkpos yy->__thunkpos
1004	1039	yyprintf((stderr, "do yy_3_rel_varlength\n"));
1005	1040	{
	1041	#line 744
1006	1042	__ = range(NULL, NULL); ;
1007	1043	}
1008	1044	#undef yythunkpos

1020	1056	#define yythunkpos yy->__thunkpos
1021	1057	yyprintf((stderr, "do yy_2_rel_varlength\n"));
1022	1058	{
	1059	#line 743
1023	1060	__ = range(s, s); ;
1024	1061	}
1025	1062	#undef yythunkpos

1037	1074	#define yythunkpos yy->__thunkpos
1038	1075	yyprintf((stderr, "do yy_1_rel_varlength\n"));
1039	1076	{
	1077	#line 741
1040	1078	__ = range(s, e); ;
1041	1079	}
1042	1080	#undef yythunkpos

1053	1091	#define yythunkpos yy->__thunkpos
1054	1092	yyprintf((stderr, "do yy_2_rel_types\n"));
1055	1093	{
	1094	#line 735
1056	1095	sequence_add(n); ;
1057	1096	}
1058	1097	#undef yythunkpos

1068	1107	#define yythunkpos yy->__thunkpos
1069	1108	yyprintf((stderr, "do yy_1_rel_types\n"));
1070	1109	{
	1110	#line 733
1071	1111	sequence_add(n); ;
1072	1112	}
1073	1113	#undef yythunkpos

1085	1125	#define yythunkpos yy->__thunkpos
1086	1126	yyprintf((stderr, "do yy_8_relationship_pattern\n"));
1087	1127	{
	1128	#line 727
1088	1129	__ = rel_pattern(BIDIRECTIONAL, i, l, p); ;
1089	1130	}
1090	1131	#undef yythunkpos

1104	1145	#define yythunkpos yy->__thunkpos
1105	1146	yyprintf((stderr, "do yy_7_relationship_pattern\n"));
1106	1147	{
	1148	#line 726
1107	1149	__ = rel_pattern(OUTBOUND, i, l, p); ;
1108	1150	}
1109	1151	#undef yythunkpos

1123	1165	#define yythunkpos yy->__thunkpos
1124	1166	yyprintf((stderr, "do yy_6_relationship_pattern\n"));
1125	1167	{
	1168	#line 721
1126	1169	__ = simple_rel_pattern(BIDIRECTIONAL); ;
1127	1170	}
1128	1171	#undef yythunkpos

1142	1185	#define yythunkpos yy->__thunkpos
1143	1186	yyprintf((stderr, "do yy_5_relationship_pattern\n"));
1144	1187	{
	1188	#line 720
1145	1189	__ = simple_rel_pattern(OUTBOUND); ;
1146	1190	}
1147	1191	#undef yythunkpos

1161	1205	#define yythunkpos yy->__thunkpos
1162	1206	yyprintf((stderr, "do yy_4_relationship_pattern\n"));
1163	1207	{
	1208	#line 715
1164	1209	__ = rel_pattern(INBOUND, i, l, p); ;
1165	1210	}
1166	1211	#undef yythunkpos

1180	1225	#define yythunkpos yy->__thunkpos
1181	1226	yyprintf((stderr, "do yy_3_relationship_pattern\n"));
1182	1227	{
	1228	#line 714
1183	1229	__ = rel_pattern(BIDIRECTIONAL, i, l, p); ;
1184	1230	}
1185	1231	#undef yythunkpos

1199	1245	#define yythunkpos yy->__thunkpos
1200	1246	yyprintf((stderr, "do yy_2_relationship_pattern\n"));
1201	1247	{
	1248	#line 709
1202	1249	__ = simple_rel_pattern(INBOUND); ;
1203	1250	}
1204	1251	#undef yythunkpos

1218	1265	#define yythunkpos yy->__thunkpos
1219	1266	yyprintf((stderr, "do yy_1_relationship_pattern\n"));
1220	1267	{
	1268	#line 708
1221	1269	__ = simple_rel_pattern(BIDIRECTIONAL); ;
1222	1270	}
1223	1271	#undef yythunkpos

1237	1285	#define yythunkpos yy->__thunkpos
1238	1286	yyprintf((stderr, "do yy_2_node_pattern\n"));
1239	1287	{
	1288	#line 703
1240	1289	__ = node_pattern(i, p); ;
1241	1290	}
1242	1291	#undef yythunkpos

1256	1305	#define yythunkpos yy->__thunkpos
1257	1306	yyprintf((stderr, "do yy_1_node_pattern\n"));
1258	1307	{
	1308	#line 701
1259	1309	sequence_add(n); ;
1260	1310	}
1261	1311	#undef yythunkpos

1275	1325	#define yythunkpos yy->__thunkpos
1276	1326	yyprintf((stderr, "do yy_4_pattern_expression\n"));
1277	1327	{
	1328	#line 696
1278	1329	__ = pattern_path(); ;
1279	1330	}
1280	1331	#undef yythunkpos

1294	1345	#define yythunkpos yy->__thunkpos
1295	1346	yyprintf((stderr, "do yy_3_pattern_expression\n"));
1296	1347	{
	1348	#line 695
1297	1349	sequence_add(r); sequence_add(n); ;
1298	1350	}
1299	1351	#undef yythunkpos

1313	1365	#define yythunkpos yy->__thunkpos
1314	1366	yyprintf((stderr, "do yy_2_pattern_expression\n"));
1315	1367	{
	1368	#line 693
1316	1369	sequence_add(n); ;
1317	1370	}
1318	1371	#undef yythunkpos

1332	1385	#define yythunkpos yy->__thunkpos
1333	1386	yyprintf((stderr, "do yy_1_pattern_expression\n"));
1334	1387	{
	1388	#line 692
1335	1389	__ = p; ;
1336	1390	}
1337	1391	#undef yythunkpos

1350	1404	#define yythunkpos yy->__thunkpos
1351	1405	yyprintf((stderr, "do yy_3_pattern_path\n"));
1352	1406	{
	1407	#line 689
1353	1408	__ = pattern_path(); ;
1354	1409	}
1355	1410	#undef yythunkpos

1367	1422	#define yythunkpos yy->__thunkpos
1368	1423	yyprintf((stderr, "do yy_2_pattern_path\n"));
1369	1424	{
	1425	#line 688
1370	1426	sequence_add(r); sequence_add(n); ;
1371	1427	}
1372	1428	#undef yythunkpos

1384	1440	#define yythunkpos yy->__thunkpos
1385	1441	yyprintf((stderr, "do yy_1_pattern_path\n"));
1386	1442	{
	1443	#line 686
1387	1444	sequence_add(n); ;
1388	1445	}
1389	1446	#undef yythunkpos

1400	1457	#define yythunkpos yy->__thunkpos
1401	1458	yyprintf((stderr, "do yy_2_shortest_path_pattern\n"));
1402	1459	{
	1460	#line 683
1403	1461	__ = shortest_path(false, p); ;
1404	1462	}
1405	1463	#undef yythunkpos

1415	1473	#define yythunkpos yy->__thunkpos
1416	1474	yyprintf((stderr, "do yy_1_shortest_path_pattern\n"));
1417	1475	{
	1476	#line 681
1418	1477	__ = shortest_path(true, p); ;
1419	1478	}
1420	1479	#undef yythunkpos

1430	1489	#define yythunkpos yy->__thunkpos
1431	1490	yyprintf((stderr, "do yy_2_anon_pattern_part\n"));
1432	1491	{
	1492	#line 677
1433	1493	__ = p; ;
1434	1494	}
1435	1495	#undef yythunkpos

1445	1505	#define yythunkpos yy->__thunkpos
1446	1506	yyprintf((stderr, "do yy_1_anon_pattern_part\n"));
1447	1507	{
	1508	#line 676
1448	1509	__ = p; ;
1449	1510	}
1450	1511	#undef yythunkpos

1461	1522	#define yythunkpos yy->__thunkpos
1462	1523	yyprintf((stderr, "do yy_2_pattern_part\n"));
1463	1524	{
	1525	#line 673
1464	1526	__ = p; ;
1465	1527	}
1466	1528	#undef yythunkpos

1478	1540	#define yythunkpos yy->__thunkpos
1479	1541	yyprintf((stderr, "do yy_1_pattern_part\n"));
1480	1542	{
	1543	#line 672
1481	1544	__ = named_path(i, p); ;
1482	1545	}
1483	1546	#undef yythunkpos

1494	1557	#define yythunkpos yy->__thunkpos
1495	1558	yyprintf((stderr, "do yy_3_pattern\n"));
1496	1559	{
	1560	#line 667
1497	1561	__ = pattern(); ;
1498	1562	}
1499	1563	#undef yythunkpos

1509	1573	#define yythunkpos yy->__thunkpos
1510	1574	yyprintf((stderr, "do yy_2_pattern\n"));
1511	1575	{
	1576	#line 666
1512	1577	sequence_add(p); ;
1513	1578	}
1514	1579	#undef yythunkpos

1524	1589	#define yythunkpos yy->__thunkpos
1525	1590	yyprintf((stderr, "do yy_1_pattern\n"));
1526	1591	{
	1592	#line 665
1527	1593	sequence_add(p); ;
1528	1594	}
1529	1595	#undef yythunkpos

1538	1604	#define yythunkpos yy->__thunkpos
1539	1605	yyprintf((stderr, "do yy_3_proc_name\n"));
1540	1606	{
	1607	#line 656
1541	1608	__ = strbuf_proc_name(); ;
1542	1609	}
1543	1610	#undef yythunkpos

1551	1618	#define yythunkpos yy->__thunkpos
1552	1619	yyprintf((stderr, "do yy_2_proc_name\n"));
1553	1620	{
	1621	#line 653
1554	1622	strbuf_append(".", 1); ;
1555	1623	}
1556	1624	#undef yythunkpos

1564	1632	#define yythunkpos yy->__thunkpos
1565	1633	yyprintf((stderr, "do yy_1_proc_name\n"));
1566	1634	{
	1635	#line 652
1567	1636	strbuf_reset(); ;
1568	1637	}
1569	1638	#undef yythunkpos

1577	1646	#define yythunkpos yy->__thunkpos
1578	1647	yyprintf((stderr, "do yy_2_index_name\n"));
1579	1648	{
	1649	#line 649
1580	1650	__ = strbuf_index_name(); ;
1581	1651	}
1582	1652	#undef yythunkpos

1590	1660	#define yythunkpos yy->__thunkpos
1591	1661	yyprintf((stderr, "do yy_1_index_name\n"));
1592	1662	{
	1663	#line 647
1593	1664	strbuf_reset(); ;
1594	1665	}
1595	1666	#undef yythunkpos

1603	1674	#define yythunkpos yy->__thunkpos
1604	1675	yyprintf((stderr, "do yy_2_function_name\n"));
1605	1676	{
	1677	#line 644
1606	1678	__ = strbuf_function_name(); ;
1607	1679	}
1608	1680	#undef yythunkpos

1616	1688	#define yythunkpos yy->__thunkpos
1617	1689	yyprintf((stderr, "do yy_1_function_name\n"));
1618	1690	{
	1691	#line 642
1619	1692	strbuf_reset(); ;
1620	1693	}
1621	1694	#undef yythunkpos

1629	1702	#define yythunkpos yy->__thunkpos
1630	1703	yyprintf((stderr, "do yy_2_prop_name\n"));
1631	1704	{
	1705	#line 639
1632	1706	__ = strbuf_prop_name(); ;
1633	1707	}
1634	1708	#undef yythunkpos

1642	1716	#define yythunkpos yy->__thunkpos
1643	1717	yyprintf((stderr, "do yy_1_prop_name\n"));
1644	1718	{
	1719	#line 637
1645	1720	strbuf_reset(); ;
1646	1721	}
1647	1722	#undef yythunkpos

1655	1730	#define yythunkpos yy->__thunkpos
1656	1731	yyprintf((stderr, "do yy_2_rel_type_name\n"));
1657	1732	{
	1733	#line 634
1658	1734	__ = strbuf_reltype(); ;
1659	1735	}
1660	1736	#undef yythunkpos

1668	1744	#define yythunkpos yy->__thunkpos
1669	1745	yyprintf((stderr, "do yy_1_rel_type_name\n"));
1670	1746	{
	1747	#line 632
1671	1748	strbuf_reset(); ;
1672	1749	}
1673	1750	#undef yythunkpos

1681	1758	#define yythunkpos yy->__thunkpos
1682	1759	yyprintf((stderr, "do yy_2_rel_type\n"));
1683	1760	{
	1761	#line 629
1684	1762	__ = strbuf_reltype(); ;
1685	1763	}
1686	1764	#undef yythunkpos

1694	1772	#define yythunkpos yy->__thunkpos
1695	1773	yyprintf((stderr, "do yy_1_rel_type\n"));
1696	1774	{
	1775	#line 627
1697	1776	strbuf_reset(); ;
1698	1777	}
1699	1778	#undef yythunkpos

1707	1786	#define yythunkpos yy->__thunkpos
1708	1787	yyprintf((stderr, "do yy_2_label\n"));
1709	1788	{
	1789	#line 624
1710	1790	__ = strbuf_label(); ;
1711	1791	}
1712	1792	#undef yythunkpos

1720	1800	#define yythunkpos yy->__thunkpos
1721	1801	yyprintf((stderr, "do yy_1_label\n"));
1722	1802	{
	1803	#line 622
1723	1804	strbuf_reset(); ;
1724	1805	}
1725	1806	#undef yythunkpos

1733	1814	#define yythunkpos yy->__thunkpos
1734	1815	yyprintf((stderr, "do yy_2_parameter\n"));
1735	1816	{
	1817	#line 619
1736	1818	__ = strbuf_parameter(); ;
1737	1819	}
1738	1820	#undef yythunkpos

1746	1828	#define yythunkpos yy->__thunkpos
1747	1829	yyprintf((stderr, "do yy_1_parameter\n"));
1748	1830	{
	1831	#line 617
1749	1832	strbuf_reset(); ;
1750	1833	}
1751	1834	#undef yythunkpos

1759	1842	#define yythunkpos yy->__thunkpos
1760	1843	yyprintf((stderr, "do yy_1_null_literal\n"));
1761	1844	{
	1845	#line 614
1762	1846	__ = null_literal(); ;
1763	1847	}
1764	1848	#undef yythunkpos

1772	1856	#define yythunkpos yy->__thunkpos
1773	1857	yyprintf((stderr, "do yy_1_false_literal\n"));
1774	1858	{
	1859	#line 611
1775	1860	__ = false_literal(); ;
1776	1861	}
1777	1862	#undef yythunkpos

1785	1870	#define yythunkpos yy->__thunkpos
1786	1871	yyprintf((stderr, "do yy_1_true_literal\n"));
1787	1872	{
	1873	#line 608
1788	1874	__ = true_literal(); ;
1789	1875	}
1790	1876	#undef yythunkpos

1798	1884	#define yythunkpos yy->__thunkpos
1799	1885	yyprintf((stderr, "do yy_2_integer_literal\n"));
1800	1886	{
	1887	#line 604
1801	1888	__ = strbuf_integer(); ;
1802	1889	}
1803	1890	#undef yythunkpos

1811	1898	#define yythunkpos yy->__thunkpos
1812	1899	yyprintf((stderr, "do yy_1_integer_literal\n"));
1813	1900	{
	1901	#line 603
1814	1902	strbuf_reset(); ;
1815	1903	}
1816	1904	#undef yythunkpos

1824	1912	#define yythunkpos yy->__thunkpos
1825	1913	yyprintf((stderr, "do yy_2_float_literal\n"));
1826	1914	{
	1915	#line 600
1827	1916	__ = strbuf_float(); ;
1828	1917	}
1829	1918	#undef yythunkpos

1837	1926	#define yythunkpos yy->__thunkpos
1838	1927	yyprintf((stderr, "do yy_1_float_literal\n"));
1839	1928	{
	1929	#line 599
1840	1930	strbuf_reset(); ;
1841	1931	}
1842	1932	#undef yythunkpos

1850	1940	#define yythunkpos yy->__thunkpos
1851	1941	yyprintf((stderr, "do yy_2_string_literal\n"));
1852	1942	{
	1943	#line 596
1853	1944	__ = strbuf_string(); ;
1854	1945	}
1855	1946	#undef yythunkpos

1863	1954	#define yythunkpos yy->__thunkpos
1864	1955	yyprintf((stderr, "do yy_1_string_literal\n"));
1865	1956	{
	1957	#line 595
1866	1958	strbuf_reset(); ;
1867	1959	}
1868	1960	#undef yythunkpos

1876	1968	#define yythunkpos yy->__thunkpos
1877	1969	yyprintf((stderr, "do yy_2_identifier\n"));
1878	1970	{
	1971	#line 592
1879	1972	__ = strbuf_identifier(); ;
1880	1973	}
1881	1974	#undef yythunkpos

1889	1982	#define yythunkpos yy->__thunkpos
1890	1983	yyprintf((stderr, "do yy_1_identifier\n"));
1891	1984	{
	1985	#line 591
1892	1986	strbuf_reset(); ;
1893	1987	}
1894	1988	#undef yythunkpos

1904	1998	#define yythunkpos yy->__thunkpos
1905	1999	yyprintf((stderr, "do yy_5_map_literal\n"));
1906	2000	{
	2001	#line 588
1907	2002	__ = map_literal(); ;
1908	2003	}
1909	2004	#undef yythunkpos

1921	2016	#define yythunkpos yy->__thunkpos
1922	2017	yyprintf((stderr, "do yy_4_map_literal\n"));
1923	2018	{
	2019	#line 586
1924	2020	sequence_add(v); ;
1925	2021	}
1926	2022	#undef yythunkpos

1938	2034	#define yythunkpos yy->__thunkpos
1939	2035	yyprintf((stderr, "do yy_3_map_literal\n"));
1940	2036	{
	2037	#line 585
1941	2038	sequence_add(n); ;
1942	2039	}
1943	2040	#undef yythunkpos

1955	2052	#define yythunkpos yy->__thunkpos
1956	2053	yyprintf((stderr, "do yy_2_map_literal\n"));
1957	2054	{
	2055	#line 584
1958	2056	sequence_add(v); ;
1959	2057	}
1960	2058	#undef yythunkpos

1972	2070	#define yythunkpos yy->__thunkpos
1973	2071	yyprintf((stderr, "do yy_1_map_literal\n"));
1974	2072	{
	2073	#line 583
1975	2074	sequence_add(n); ;
1976	2075	}
1977	2076	#undef yythunkpos

1988	2087	#define yythunkpos yy->__thunkpos
1989	2088	yyprintf((stderr, "do yy_3_collection_literal\n"));
1990	2089	{
	2090	#line 579
1991	2091	__ = collection_literal(); ;
1992	2092	}
1993	2093	#undef yythunkpos

2003	2103	#define yythunkpos yy->__thunkpos
2004	2104	yyprintf((stderr, "do yy_2_collection_literal\n"));
2005	2105	{
	2106	#line 577
2006	2107	sequence_add(e); ;
2007	2108	}
2008	2109	#undef yythunkpos

2018	2119	#define yythunkpos yy->__thunkpos
2019	2120	yyprintf((stderr, "do yy_1_collection_literal\n"));
2020	2121	{
	2122	#line 576
2021	2123	sequence_add(e); ;
2022	2124	}
2023	2125	#undef yythunkpos

2034	2136	#define yythunkpos yy->__thunkpos
2035	2137	yyprintf((stderr, "do yy_8_function_application\n"));
2036	2138	{
	2139	#line 572
2037	2140	__ = apply_operator(n, false); ;
2038	2141	}
2039	2142	#undef yythunkpos

2051	2154	#define yythunkpos yy->__thunkpos
2052	2155	yyprintf((stderr, "do yy_7_function_application\n"));
2053	2156	{
	2157	#line 570
2054	2158	sequence_add(e); ;
2055	2159	}
2056	2160	#undef yythunkpos

2068	2172	#define yythunkpos yy->__thunkpos
2069	2173	yyprintf((stderr, "do yy_6_function_application\n"));
2070	2174	{
	2175	#line 569
2071	2176	sequence_add(e); ;
2072	2177	}
2073	2178	#undef yythunkpos

2085	2190	#define yythunkpos yy->__thunkpos
2086	2191	yyprintf((stderr, "do yy_5_function_application\n"));
2087	2192	{
	2193	#line 567
2088	2194	__ = apply_operator(n, true); ;
2089	2195	}
2090	2196	#undef yythunkpos

2102	2208	#define yythunkpos yy->__thunkpos
2103	2209	yyprintf((stderr, "do yy_4_function_application\n"));
2104	2210	{
	2211	#line 565
2105	2212	sequence_add(e); ;
2106	2213	}
2107	2214	#undef yythunkpos

2119	2226	#define yythunkpos yy->__thunkpos
2120	2227	yyprintf((stderr, "do yy_3_function_application\n"));
2121	2228	{
	2229	#line 564
2122	2230	sequence_add(e); ;
2123	2231	}
2124	2232	#undef yythunkpos

2136	2244	#define yythunkpos yy->__thunkpos
2137	2245	yyprintf((stderr, "do yy_2_function_application\n"));
2138	2246	{
	2247	#line 562
2139	2248	__ = apply_all_operator(n, false); ;
2140	2249	}
2141	2250	#undef yythunkpos

2153	2262	#define yythunkpos yy->__thunkpos
2154	2263	yyprintf((stderr, "do yy_1_function_application\n"));
2155	2264	{
	2265	#line 560
2156	2266	__ = apply_all_operator(n, true); ;
2157	2267	}
2158	2268	#undef yythunkpos

2171	2281	#define yythunkpos yy->__thunkpos
2172	2282	yyprintf((stderr, "do yy_1_none_predicate\n"));
2173	2283	{
	2284	#line 555
2174	2285	__ = none_predicate(i, e, p); ;
2175	2286	}
2176	2287	#undef yythunkpos

2190	2301	#define yythunkpos yy->__thunkpos
2191	2302	yyprintf((stderr, "do yy_1_single_predicate\n"));
2192	2303	{
	2304	#line 550
2193	2305	__ = single_predicate(i, e, p); ;
2194	2306	}
2195	2307	#undef yythunkpos

2209	2321	#define yythunkpos yy->__thunkpos
2210	2322	yyprintf((stderr, "do yy_1_any_predicate\n"));
2211	2323	{
	2324	#line 545
2212	2325	__ = any_predicate(i, e, p); ;
2213	2326	}
2214	2327	#undef yythunkpos

2228	2341	#define yythunkpos yy->__thunkpos
2229	2342	yyprintf((stderr, "do yy_1_all_predicate\n"));
2230	2343	{
	2344	#line 540
2231	2345	__ = all_predicate(i, e, p); ;
2232	2346	}
2233	2347	#undef yythunkpos

2249	2363	#define yythunkpos yy->__thunkpos
2250	2364	yyprintf((stderr, "do yy_1_reduce_expression\n"));
2251	2365	{
	2366	#line 535
2252	2367	__ = reduce(a, n, i, e, v); ;
2253	2368	}
2254	2369	#undef yythunkpos

2270	2385	#define yythunkpos yy->__thunkpos
2271	2386	yyprintf((stderr, "do yy_1_extract_expression\n"));
2272	2387	{
	2388	#line 529
2273	2389	__ = extract(i, e, v); ;
2274	2390	}
2275	2391	#undef yythunkpos

2289	2405	#define yythunkpos yy->__thunkpos
2290	2406	yyprintf((stderr, "do yy_1_filter_expression\n"));
2291	2407	{
	2408	#line 524
2292	2409	__ = filter(i, e, p); ;
2293	2410	}
2294	2411	#undef yythunkpos

2306	2423	#define yythunkpos yy->__thunkpos
2307	2424	yyprintf((stderr, "do yy_1_case_default\n"));
2308	2425	{
	2426	#line 519
2309	2427	__ = e; ;
2310	2428	}
2311	2429	#undef yythunkpos

2321	2439	#define yythunkpos yy->__thunkpos
2322	2440	yyprintf((stderr, "do yy_2_case_alternative\n"));
2323	2441	{
	2442	#line 518
2324	2443	sequence_add(e); ;
2325	2444	}
2326	2445	#undef yythunkpos

2336	2455	#define yythunkpos yy->__thunkpos
2337	2456	yyprintf((stderr, "do yy_1_case_alternative\n"));
2338	2457	{
	2458	#line 517
2339	2459	sequence_add(e); ;
2340	2460	}
2341	2461	#undef yythunkpos

2352	2472	#define yythunkpos yy->__thunkpos
2353	2473	yyprintf((stderr, "do yy_1_case_expression\n"));
2354	2474	{
	2475	#line 514
2355	2476	__ = case_expression(e, d); ;
2356	2477	}
2357	2478	#undef yythunkpos

2371	2492	#define yythunkpos yy->__thunkpos
2372	2493	yyprintf((stderr, "do yy_1_list_comprehension\n"));
2373	2494	{
	2495	#line 508
2374	2496	__ = list_comprehension(i, e, p, v); ;
2375	2497	}
2376	2498	#undef yythunkpos

2388	2510	#define yythunkpos yy->__thunkpos
2389	2511	yyprintf((stderr, "do yy_4_COMPARISON_OP\n"));
2390	2512	{
	2513	#line 501
2391	2514	op_push(GT); ;
2392	2515	}
2393	2516	#undef yythunkpos

2401	2524	#define yythunkpos yy->__thunkpos
2402	2525	yyprintf((stderr, "do yy_3_COMPARISON_OP\n"));
2403	2526	{
	2527	#line 500
2404	2528	op_push(LT); ;
2405	2529	}
2406	2530	#undef yythunkpos

2414	2538	#define yythunkpos yy->__thunkpos
2415	2539	yyprintf((stderr, "do yy_2_COMPARISON_OP\n"));
2416	2540	{
	2541	#line 499
2417	2542	op_push(GTE); ;
2418	2543	}
2419	2544	#undef yythunkpos

2427	2552	#define yythunkpos yy->__thunkpos
2428	2553	yyprintf((stderr, "do yy_1_COMPARISON_OP\n"));
2429	2554	{
	2555	#line 498
2430	2556	op_push(LTE); ;
2431	2557	}
2432	2558	#undef yythunkpos

2440	2566	#define yythunkpos yy->__thunkpos
2441	2567	yyprintf((stderr, "do yy_16_INFIX_OP\n"));
2442	2568	{
	2569	#line 494
2443	2570	op_push(STARTS_WITH); ;
2444	2571	}
2445	2572	#undef yythunkpos

2453	2580	#define yythunkpos yy->__thunkpos
2454	2581	yyprintf((stderr, "do yy_15_INFIX_OP\n"));
2455	2582	{
	2583	#line 493
2456	2584	op_push(CONTAINS); ;
2457	2585	}
2458	2586	#undef yythunkpos

2466	2594	#define yythunkpos yy->__thunkpos
2467	2595	yyprintf((stderr, "do yy_14_INFIX_OP\n"));
2468	2596	{
	2597	#line 492
2469	2598	op_push(REGEX); ;
2470	2599	}
2471	2600	#undef yythunkpos

2479	2608	#define yythunkpos yy->__thunkpos
2480	2609	yyprintf((stderr, "do yy_13_INFIX_OP\n"));
2481	2610	{
	2611	#line 491
2482	2612	op_push(IN); ;
2483	2613	}
2484	2614	#undef yythunkpos

2492	2622	#define yythunkpos yy->__thunkpos
2493	2623	yyprintf((stderr, "do yy_12_INFIX_OP\n"));
2494	2624	{
	2625	#line 490
2495	2626	op_push(POW); ;
2496	2627	}
2497	2628	#undef yythunkpos

2505	2636	#define yythunkpos yy->__thunkpos
2506	2637	yyprintf((stderr, "do yy_11_INFIX_OP\n"));
2507	2638	{
	2639	#line 489
2508	2640	op_push(MOD); ;
2509	2641	}
2510	2642	#undef yythunkpos

2518	2650	#define yythunkpos yy->__thunkpos
2519	2651	yyprintf((stderr, "do yy_10_INFIX_OP\n"));
2520	2652	{
	2653	#line 488
2521	2654	op_push(DIV); ;
2522	2655	}
2523	2656	#undef yythunkpos

2531	2664	#define yythunkpos yy->__thunkpos
2532	2665	yyprintf((stderr, "do yy_9_INFIX_OP\n"));
2533	2666	{
	2667	#line 487
2534	2668	op_push(MULT); ;
2535	2669	}
2536	2670	#undef yythunkpos

2544	2678	#define yythunkpos yy->__thunkpos
2545	2679	yyprintf((stderr, "do yy_8_INFIX_OP\n"));
2546	2680	{
	2681	#line 486
2547	2682	op_push(MINUS); ;
2548	2683	}
2549	2684	#undef yythunkpos

2557	2692	#define yythunkpos yy->__thunkpos
2558	2693	yyprintf((stderr, "do yy_7_INFIX_OP\n"));
2559	2694	{
	2695	#line 485
2560	2696	op_push(PLUS); ;
2561	2697	}
2562	2698	#undef yythunkpos

2570	2706	#define yythunkpos yy->__thunkpos
2571	2707	yyprintf((stderr, "do yy_6_INFIX_OP\n"));
2572	2708	{
	2709	#line 484
2573	2710	op_push(NEQUAL); ;
2574	2711	}
2575	2712	#undef yythunkpos

2583	2720	#define yythunkpos yy->__thunkpos
2584	2721	yyprintf((stderr, "do yy_5_INFIX_OP\n"));
2585	2722	{
	2723	#line 483
2586	2724	op_push(EQUAL); ;
2587	2725	}
2588	2726	#undef yythunkpos

2596	2734	#define yythunkpos yy->__thunkpos
2597	2735	yyprintf((stderr, "do yy_4_INFIX_OP\n"));
2598	2736	{
	2737	#line 482
2599	2738	op_push(NOT); ;
2600	2739	}
2601	2740	#undef yythunkpos

2609	2748	#define yythunkpos yy->__thunkpos
2610	2749	yyprintf((stderr, "do yy_3_INFIX_OP\n"));
2611	2750	{
	2751	#line 481
2612	2752	op_push(XOR); ;
2613	2753	}
2614	2754	#undef yythunkpos

2622	2762	#define yythunkpos yy->__thunkpos
2623	2763	yyprintf((stderr, "do yy_2_INFIX_OP\n"));
2624	2764	{
	2765	#line 480
2625	2766	op_push(OR); ;
2626	2767	}
2627	2768	#undef yythunkpos

2635	2776	#define yythunkpos yy->__thunkpos
2636	2777	yyprintf((stderr, "do yy_1_INFIX_OP\n"));
2637	2778	{
	2779	#line 479
2638	2780	op_push(AND); ;
2639	2781	}
2640	2782	#undef yythunkpos

2648	2790	#define yythunkpos yy->__thunkpos
2649	2791	yyprintf((stderr, "do yy_2_POSTFIX_OP\n"));
2650	2792	{
	2793	#line 475
2651	2794	op_push(IS_NOT_NULL); ;
2652	2795	}
2653	2796	#undef yythunkpos

2661	2804	#define yythunkpos yy->__thunkpos
2662	2805	yyprintf((stderr, "do yy_1_POSTFIX_OP\n"));
2663	2806	{
	2807	#line 474
2664	2808	op_push(IS_NULL); ;
2665	2809	}
2666	2810	#undef yythunkpos

2674	2818	#define yythunkpos yy->__thunkpos
2675	2819	yyprintf((stderr, "do yy_3_PREFIX_OP\n"));
2676	2820	{
	2821	#line 470
2677	2822	op_push(UNARY_MINUS); ;
2678	2823	}
2679	2824	#undef yythunkpos

2687	2832	#define yythunkpos yy->__thunkpos
2688	2833	yyprintf((stderr, "do yy_2_PREFIX_OP\n"));
2689	2834	{
	2835	#line 469
2690	2836	op_push(UNARY_PLUS); ;
2691	2837	}
2692	2838	#undef yythunkpos

2700	2846	#define yythunkpos yy->__thunkpos
2701	2847	yyprintf((stderr, "do yy_1_PREFIX_OP\n"));
2702	2848	{
	2849	#line 468
2703	2850	op_push(NOT); ;
2704	2851	}
2705	2852	#undef yythunkpos

2715	2862	#define yythunkpos yy->__thunkpos
2716	2863	yyprintf((stderr, "do yy_2_property_expression\n"));
2717	2864	{
	2865	#line 462
2718	2866	__ = p; ;
2719	2867	}
2720	2868	#undef yythunkpos

2732	2880	#define yythunkpos yy->__thunkpos
2733	2881	yyprintf((stderr, "do yy_1_property_expression\n"));
2734	2882	{
	2883	#line 461
2735	2884	p = property_operator(p, n); ;
2736	2885	}
2737	2886	#undef yythunkpos

2748	2897	#define yythunkpos yy->__thunkpos
2749	2898	yyprintf((stderr, "do yy_1_atom\n"));
2750	2899	{
	2900	#line 455
2751	2901	__ = e; ;
2752	2902	}
2753	2903	#undef yythunkpos

2767	2917	#define yythunkpos yy->__thunkpos
2768	2918	yyprintf((stderr, "do yy_12__expression\n"));
2769	2919	{
	2920	#line 431
2770	2921	__ = l; ;
2771	2922	}
2772	2923	#undef yythunkpos

2790	2941	#define yythunkpos yy->__thunkpos
2791	2942	yyprintf((stderr, "do yy_11__expression\n"));
2792	2943	{
	2944	#line 430
2793	2945	l = labels_operator(l); ;
2794	2946	}
2795	2947	#undef yythunkpos

2813	2965	#define yythunkpos yy->__thunkpos
2814	2966	yyprintf((stderr, "do yy_10__expression\n"));
2815	2967	{
	2968	#line 429
2816	2969	sequence_add(n); ;
2817	2970	}
2818	2971	#undef yythunkpos

2836	2989	#define yythunkpos yy->__thunkpos
2837	2990	yyprintf((stderr, "do yy_9__expression\n"));
2838	2991	{
	2992	#line 427
2839	2993	l = slice_operator(l, s, e); ;
2840	2994	}
2841	2995	#undef yythunkpos

2859	3013	#define yythunkpos yy->__thunkpos
2860	3014	yyprintf((stderr, "do yy_8__expression\n"));
2861	3015	{
	3016	#line 423
2862	3017	l = subscript_operator(l, r); ;
2863	3018	}
2864	3019	#undef yythunkpos

2882	3037	#define yythunkpos yy->__thunkpos
2883	3038	yyprintf((stderr, "do yy_7__expression\n"));
2884	3039	{
	3040	#line 420
2885	3041	l = unary_operator(op_pop(), l); ;
2886	3042	}
2887	3043	#undef yythunkpos

2905	3061	#define yythunkpos yy->__thunkpos
2906	3062	yyprintf((stderr, "do yy_6__expression\n"));
2907	3063	{
	3064	#line 418
2908	3065	l = comparison_operator(); ;
2909	3066	}
2910	3067	#undef yythunkpos

2928	3085	#define yythunkpos yy->__thunkpos
2929	3086	yyprintf((stderr, "do yy_5__expression\n"));
2930	3087	{
	3088	#line 417
2931	3089	sequence_add(r); ;
2932	3090	}
2933	3091	#undef yythunkpos

2951	3109	#define yythunkpos yy->__thunkpos
2952	3110	yyprintf((stderr, "do yy_4__expression\n"));
2953	3111	{
	3112	#line 415
2954	3113	sequence_add(l); ;
2955	3114	}
2956	3115	#undef yythunkpos

2974	3133	#define yythunkpos yy->__thunkpos
2975	3134	yyprintf((stderr, "do yy_3__expression\n"));
2976	3135	{
	3136	#line 414
2977	3137	l = binary_operator(op_pop(), l, r); ;
2978	3138	}
2979	3139	#undef yythunkpos

2997	3157	#define yythunkpos yy->__thunkpos
2998	3158	yyprintf((stderr, "do yy_2__expression\n"));
2999	3159	{
	3160	#line 412
3000	3161	l = property_operator(l, n); ;
3001	3162	}
3002	3163	#undef yythunkpos

3020	3181	#define yythunkpos yy->__thunkpos
3021	3182	yyprintf((stderr, "do yy_1__expression\n"));
3022	3183	{
	3184	#line 409
3023	3185	__ = unary_operator(op_pop(), r); ;
3024	3186	}
3025	3187	#undef yythunkpos

3039	3201	#define yythunkpos yy->__thunkpos
3040	3202	yyprintf((stderr, "do yy_1__prec_expression\n"));
3041	3203	{
	3204	#line 406
3042	3205	__ = e; ;
3043	3206	}
3044	3207	#undef yythunkpos

3054	3217	#define yythunkpos yy->__thunkpos
3055	3218	yyprintf((stderr, "do yy_1_expression\n"));
3056	3219	{
	3220	#line 404
3057	3221	__ = e; ;
3058	3222	}
3059	3223	#undef yythunkpos

3068	3232	#define yythunkpos yy->__thunkpos
3069	3233	yyprintf((stderr, "do yy_2_union_clause\n"));
3070	3234	{
	3235	#line 394
3071	3236	__ = union_clause(false); ;
3072	3237	}
3073	3238	#undef yythunkpos

3081	3246	#define yythunkpos yy->__thunkpos
3082	3247	yyprintf((stderr, "do yy_1_union_clause\n"));
3083	3248	{
	3249	#line 393
3084	3250	__ = union_clause(true); ;
3085	3251	}
3086	3252	#undef yythunkpos

3095	3261	#define yythunkpos yy->__thunkpos
3096	3262	yyprintf((stderr, "do yy_1_limit\n"));
3097	3263	{
	3264	#line 389
3098	3265	__ = e ;
3099	3266	}
3100	3267	#undef yythunkpos

3110	3277	#define yythunkpos yy->__thunkpos
3111	3278	yyprintf((stderr, "do yy_1_skip\n"));
3112	3279	{
	3280	#line 388
3113	3281	__ = e ;
3114	3282	}
3115	3283	#undef yythunkpos

3125	3293	#define yythunkpos yy->__thunkpos
3126	3294	yyprintf((stderr, "do yy_2_sort_item\n"));
3127	3295	{
	3296	#line 385
3128	3297	__ = sort_item(e, true); ;
3129	3298	}
3130	3299	#undef yythunkpos

3140	3309	#define yythunkpos yy->__thunkpos
3141	3310	yyprintf((stderr, "do yy_1_sort_item\n"));
3142	3311	{
	3312	#line 384
3143	3313	__ = sort_item(e, false); ;
3144	3314	}
3145	3315	#undef yythunkpos

3155	3325	#define yythunkpos yy->__thunkpos
3156	3326	yyprintf((stderr, "do yy_3_order_by\n"));
3157	3327	{
	3328	#line 380
3158	3329	__ = order_by(); ;
3159	3330	}
3160	3331	#undef yythunkpos

3170	3341	#define yythunkpos yy->__thunkpos
3171	3342	yyprintf((stderr, "do yy_2_order_by\n"));
3172	3343	{
	3344	#line 379
3173	3345	sequence_add(s); ;
3174	3346	}
3175	3347	#undef yythunkpos

3185	3357	#define yythunkpos yy->__thunkpos
3186	3358	yyprintf((stderr, "do yy_1_order_by\n"));
3187	3359	{
	3360	#line 378
3188	3361	sequence_add(s); ;
3189	3362	}
3190	3363	#undef yythunkpos

3201	3374	#define yythunkpos yy->__thunkpos
3202	3375	yyprintf((stderr, "do yy_2_return_projection\n"));
3203	3376	{
	3377	#line 376
3204	3378	__ = projection(e, i); ;
3205	3379	}
3206	3380	#undef yythunkpos

3218	3392	#define yythunkpos yy->__thunkpos
3219	3393	yyprintf((stderr, "do yy_1_return_projection\n"));
3220	3394	{
	3395	#line 370
3221	3396	if (!cypher_astnode_instanceof(
3222	3397	e, CYPHER_AST_IDENTIFIER))
3223	3398	{

3239	3414	#define yythunkpos yy->__thunkpos
3240	3415	yyprintf((stderr, "do yy_1_additional_return_projections\n"));
3241	3416	{
	3417	#line 364
3242	3418	sequence_add(i); ;
3243	3419	}
3244	3420	#undef yythunkpos

3257	3433	#define yythunkpos yy->__thunkpos
3258	3434	yyprintf((stderr, "do yy_6_return_clause\n"));
3259	3435	{
	3436	#line 361
3260	3437	__ = return_clause(false,false,o,s,l); ;
3261	3438	}
3262	3439	#undef yythunkpos

3278	3455	#define yythunkpos yy->__thunkpos
3279	3456	yyprintf((stderr, "do yy_5_return_clause\n"));
3280	3457	{
	3458	#line 358
3281	3459	sequence_add(i); ;
3282	3460	}
3283	3461	#undef yythunkpos

3299	3477	#define yythunkpos yy->__thunkpos
3300	3478	yyprintf((stderr, "do yy_4_return_clause\n"));
3301	3479	{
	3480	#line 357
3302	3481	__ = return_clause(false,true,o,s,l); ;
3303	3482	}
3304	3483	#undef yythunkpos

3320	3499	#define yythunkpos yy->__thunkpos
3321	3500	yyprintf((stderr, "do yy_3_return_clause\n"));
3322	3501	{
	3502	#line 353
3323	3503	__ = return_clause(true,false,o,s,l); ;
3324	3504	}
3325	3505	#undef yythunkpos

3341	3521	#define yythunkpos yy->__thunkpos
3342	3522	yyprintf((stderr, "do yy_2_return_clause\n"));
3343	3523	{
	3524	#line 350
3344	3525	sequence_add(i); ;
3345	3526	}
3346	3527	#undef yythunkpos

3362	3543	#define yythunkpos yy->__thunkpos
3363	3544	yyprintf((stderr, "do yy_1_return_clause\n"));
3364	3545	{
	3546	#line 349
3365	3547	__ = return_clause(true,true,o,s,l); ;
3366	3548	}
3367	3549	#undef yythunkpos

3381	3563	#define yythunkpos yy->__thunkpos
3382	3564	yyprintf((stderr, "do yy_2_proc_projection\n"));
3383	3565	{
	3566	#line 342
3384	3567	__ = projection(r, NULL); ;
3385	3568	}
3386	3569	#undef yythunkpos

3398	3581	#define yythunkpos yy->__thunkpos
3399	3582	yyprintf((stderr, "do yy_1_proc_projection\n"));
3400	3583	{
	3584	#line 341
3401	3585	__ = projection(r, i); ;
3402	3586	}
3403	3587	#undef yythunkpos

3416	3600	#define yythunkpos yy->__thunkpos
3417	3601	yyprintf((stderr, "do yy_5_call_clause\n"));
3418	3602	{
	3603	#line 338
3419	3604	__ = call_clause(p); ;
3420	3605	}
3421	3606	#undef yythunkpos

3435	3620	#define yythunkpos yy->__thunkpos
3436	3621	yyprintf((stderr, "do yy_4_call_clause\n"));
3437	3622	{
	3623	#line 336
3438	3624	sequence_add(r); ;
3439	3625	}
3440	3626	#undef yythunkpos

3454	3640	#define yythunkpos yy->__thunkpos
3455	3641	yyprintf((stderr, "do yy_3_call_clause\n"));
3456	3642	{
	3643	#line 335
3457	3644	sequence_add(r); ;
3458	3645	}
3459	3646	#undef yythunkpos

3473	3660	#define yythunkpos yy->__thunkpos
3474	3661	yyprintf((stderr, "do yy_2_call_clause\n"));
3475	3662	{
	3663	#line 330
3476	3664	sequence_add(e); ;
3477	3665	}
3478	3666	#undef yythunkpos

3492	3680	#define yythunkpos yy->__thunkpos
3493	3681	yyprintf((stderr, "do yy_1_call_clause\n"));
3494	3682	{
	3683	#line 329
3495	3684	sequence_add(e); ;
3496	3685	}
3497	3686	#undef yythunkpos

3510	3699	#define yythunkpos yy->__thunkpos
3511	3700	yyprintf((stderr, "do yy_1_unwind_clause\n"));
3512	3701	{
	3702	#line 320
3513	3703	__ = unwind_clause(e, i); ;
3514	3704	}
3515	3705	#undef yythunkpos

3527	3717	#define yythunkpos yy->__thunkpos
3528	3718	yyprintf((stderr, "do yy_2_with_projection\n"));
3529	3719	{
	3720	#line 316
3530	3721	__ = projection(e, NULL); ;
3531	3722	}
3532	3723	#undef yythunkpos

3544	3735	#define yythunkpos yy->__thunkpos
3545	3736	yyprintf((stderr, "do yy_1_with_projection\n"));
3546	3737	{
	3738	#line 315
3547	3739	__ = projection(e, i); ;
3548	3740	}
3549	3741	#undef yythunkpos

3560	3752	#define yythunkpos yy->__thunkpos
3561	3753	yyprintf((stderr, "do yy_1_additional_with_projections\n"));
3562	3754	{
	3755	#line 310
3563	3756	sequence_add(i); ;
3564	3757	}
3565	3758	#undef yythunkpos

3579	3772	#define yythunkpos yy->__thunkpos
3580	3773	yyprintf((stderr, "do yy_6_with_clause\n"));
3581	3774	{
	3775	#line 307
3582	3776	__ = with_clause(false,false,o,s,l,p); ;
3583	3777	}
3584	3778	#undef yythunkpos

3602	3796	#define yythunkpos yy->__thunkpos
3603	3797	yyprintf((stderr, "do yy_5_with_clause\n"));
3604	3798	{
	3799	#line 303
3605	3800	sequence_add(i); ;
3606	3801	}
3607	3802	#undef yythunkpos

3625	3820	#define yythunkpos yy->__thunkpos
3626	3821	yyprintf((stderr, "do yy_4_with_clause\n"));
3627	3822	{
	3823	#line 302
3628	3824	__ = with_clause(false,true,o,s,l,p); ;
3629	3825	}
3630	3826	#undef yythunkpos

3648	3844	#define yythunkpos yy->__thunkpos
3649	3845	yyprintf((stderr, "do yy_3_with_clause\n"));
3650	3846	{
	3847	#line 297
3651	3848	__ = with_clause(true,false,o,s,l,p); ;
3652	3849	}
3653	3850	#undef yythunkpos

3671	3868	#define yythunkpos yy->__thunkpos
3672	3869	yyprintf((stderr, "do yy_2_with_clause\n"));
3673	3870	{
	3871	#line 293
3674	3872	sequence_add(i); ;
3675	3873	}
3676	3874	#undef yythunkpos

3694	3892	#define yythunkpos yy->__thunkpos
3695	3893	yyprintf((stderr, "do yy_1_with_clause\n"));
3696	3894	{
	3895	#line 292
3697	3896	__ = with_clause(true,true,o,s,l,p); ;
3698	3897	}
3699	3898	#undef yythunkpos

3715	3914	#define yythunkpos yy->__thunkpos
3716	3915	yyprintf((stderr, "do yy_2_foreach_clause\n"));
3717	3916	{
	3917	#line 283
3718	3918	__ = foreach_clause(i, e); ;
3719	3919	}
3720	3920	#undef yythunkpos

3734	3934	#define yythunkpos yy->__thunkpos
3735	3935	yyprintf((stderr, "do yy_1_foreach_clause\n"));
3736	3936	{
	3937	#line 282
3737	3938	sequence_add(c); ;
3738	3939	}
3739	3940	#undef yythunkpos

3753	3954	#define yythunkpos yy->__thunkpos
3754	3955	yyprintf((stderr, "do yy_3_remove_item\n"));
3755	3956	{
	3957	#line 278
3756	3958	__ = remove_labels(i); ;
3757	3959	}
3758	3960	#undef yythunkpos

3772	3974	#define yythunkpos yy->__thunkpos
3773	3975	yyprintf((stderr, "do yy_2_remove_item\n"));
3774	3976	{
	3977	#line 277
3775	3978	sequence_add(l); ;
3776	3979	}
3777	3980	#undef yythunkpos

3791	3994	#define yythunkpos yy->__thunkpos
3792	3995	yyprintf((stderr, "do yy_1_remove_item\n"));
3793	3996	{
	3997	#line 276
3794	3998	__ = remove_property(p); ;
3795	3999	}
3796	4000	#undef yythunkpos

3808	4012	#define yythunkpos yy->__thunkpos
3809	4013	yyprintf((stderr, "do yy_3_remove_clause\n"));
3810	4014	{
	4015	#line 273
3811	4016	__ = remove_clause(); ;
3812	4017	}
3813	4018	#undef yythunkpos

3823	4028	#define yythunkpos yy->__thunkpos
3824	4029	yyprintf((stderr, "do yy_2_remove_clause\n"));
3825	4030	{
	4031	#line 272
3826	4032	sequence_add(i); ;
3827	4033	}
3828	4034	#undef yythunkpos

3838	4044	#define yythunkpos yy->__thunkpos
3839	4045	yyprintf((stderr, "do yy_1_remove_clause\n"));
3840	4046	{
	4047	#line 271
3841	4048	sequence_add(i); ;
3842	4049	}
3843	4050	#undef yythunkpos

3853	4060	#define yythunkpos yy->__thunkpos
3854	4061	yyprintf((stderr, "do yy_6_delete_clause\n"));
3855	4062	{
	4063	#line 268
3856	4064	__ = delete(false); ;
3857	4065	}
3858	4066	#undef yythunkpos

3868	4076	#define yythunkpos yy->__thunkpos
3869	4077	yyprintf((stderr, "do yy_5_delete_clause\n"));
3870	4078	{
	4079	#line 267
3871	4080	sequence_add(e); ;
3872	4081	}
3873	4082	#undef yythunkpos

3883	4092	#define yythunkpos yy->__thunkpos
3884	4093	yyprintf((stderr, "do yy_4_delete_clause\n"));
3885	4094	{
	4095	#line 266
3886	4096	sequence_add(e); ;
3887	4097	}
3888	4098	#undef yythunkpos

3898	4108	#define yythunkpos yy->__thunkpos
3899	4109	yyprintf((stderr, "do yy_3_delete_clause\n"));
3900	4110	{
	4111	#line 265
3901	4112	__ = delete(true); ;
3902	4113	}
3903	4114	#undef yythunkpos

3913	4124	#define yythunkpos yy->__thunkpos
3914	4125	yyprintf((stderr, "do yy_2_delete_clause\n"));
3915	4126	{
	4127	#line 264
3916	4128	sequence_add(e); ;
3917	4129	}
3918	4130	#undef yythunkpos

3928	4140	#define yythunkpos yy->__thunkpos
3929	4141	yyprintf((stderr, "do yy_1_delete_clause\n"));
3930	4142	{
	4143	#line 263
3931	4144	sequence_add(e); ;
3932	4145	}
3933	4146	#undef yythunkpos

3946	4159	#define yythunkpos yy->__thunkpos
3947	4160	yyprintf((stderr, "do yy_5_set_item\n"));
3948	4161	{
	4162	#line 260
3949	4163	__ = set_labels(i); ;
3950	4164	}
3951	4165	#undef yythunkpos

3967	4181	#define yythunkpos yy->__thunkpos
3968	4182	yyprintf((stderr, "do yy_4_set_item\n"));
3969	4183	{
	4184	#line 259
3970	4185	sequence_add(l); ;
3971	4186	}
3972	4187	#undef yythunkpos

3988	4203	#define yythunkpos yy->__thunkpos
3989	4204	yyprintf((stderr, "do yy_3_set_item\n"));
3990	4205	{
	4206	#line 258
3991	4207	__ = merge_properties(i, e); ;
3992	4208	}
3993	4209	#undef yythunkpos

4009	4225	#define yythunkpos yy->__thunkpos
4010	4226	yyprintf((stderr, "do yy_2_set_item\n"));
4011	4227	{
	4228	#line 256
4012	4229	__ = set_all_properties(i, e); ;
4013	4230	}
4014	4231	#undef yythunkpos

4030	4247	#define yythunkpos yy->__thunkpos
4031	4248	yyprintf((stderr, "do yy_1_set_item\n"));
4032	4249	{
	4250	#line 254
4033	4251	__ = set_property(p, e); ;
4034	4252	}
4035	4253	#undef yythunkpos

4048	4266	#define yythunkpos yy->__thunkpos
4049	4267	yyprintf((stderr, "do yy_3_set_clause\n"));
4050	4268	{
	4269	#line 250
4051	4270	__ = set_clause(); ;
4052	4271	}
4053	4272	#undef yythunkpos

4063	4282	#define yythunkpos yy->__thunkpos
4064	4283	yyprintf((stderr, "do yy_2_set_clause\n"));
4065	4284	{
	4285	#line 249
4066	4286	sequence_add(i); ;
4067	4287	}
4068	4288	#undef yythunkpos

4078	4298	#define yythunkpos yy->__thunkpos
4079	4299	yyprintf((stderr, "do yy_1_set_clause\n"));
4080	4300	{
	4301	#line 248
4081	4302	sequence_add(i); ;
4082	4303	}
4083	4304	#undef yythunkpos

4093	4314	#define yythunkpos yy->__thunkpos
4094	4315	yyprintf((stderr, "do yy_2_create_clause\n"));
4095	4316	{
	4317	#line 245
4096	4318	__ = create_clause(false, p); ;
4097	4319	}
4098	4320	#undef yythunkpos

4108	4330	#define yythunkpos yy->__thunkpos
4109	4331	yyprintf((stderr, "do yy_1_create_clause\n"));
4110	4332	{
	4333	#line 244
4111	4334	__ = create_clause(true, p); ;
4112	4335	}
4113	4336	#undef yythunkpos

4123	4346	#define yythunkpos yy->__thunkpos
4124	4347	yyprintf((stderr, "do yy_2_merge_action_set\n"));
4125	4348	{
	4349	#line 240
4126	4350	sequence_add(i); ;
4127	4351	}
4128	4352	#undef yythunkpos

4138	4362	#define yythunkpos yy->__thunkpos
4139	4363	yyprintf((stderr, "do yy_1_merge_action_set\n"));
4140	4364	{
	4365	#line 239
4141	4366	sequence_add(i); ;
4142	4367	}
4143	4368	#undef yythunkpos

4152	4377	#define yythunkpos yy->__thunkpos
4153	4378	yyprintf((stderr, "do yy_2_merge_action\n"));
4154	4379	{
	4380	#line 237
4155	4381	__ = on_create(); ;
4156	4382	}
4157	4383	#undef yythunkpos

4165	4391	#define yythunkpos yy->__thunkpos
4166	4392	yyprintf((stderr, "do yy_1_merge_action\n"));
4167	4393	{
	4394	#line 236
4168	4395	__ = on_match(); ;
4169	4396	}
4170	4397	#undef yythunkpos

4180	4407	#define yythunkpos yy->__thunkpos
4181	4408	yyprintf((stderr, "do yy_2_merge_clause\n"));
4182	4409	{
	4410	#line 232
4183	4411	__ = merge_clause(p); ;
4184	4412	}
4185	4413	#undef yythunkpos

4197	4425	#define yythunkpos yy->__thunkpos
4198	4426	yyprintf((stderr, "do yy_1_merge_clause\n"));
4199	4427	{
	4428	#line 231
4200	4429	sequence_add(a); ;
4201	4430	}
4202	4431	#undef yythunkpos

4215	4444	#define yythunkpos yy->__thunkpos
4216	4445	yyprintf((stderr, "do yy_5_hint\n"));
4217	4446	{
	4447	#line 227
4218	4448	__ = using_scan(i, l); ;
4219	4449	}
4220	4450	#undef yythunkpos

4234	4464	#define yythunkpos yy->__thunkpos
4235	4465	yyprintf((stderr, "do yy_4_hint\n"));
4236	4466	{
	4467	#line 225
4237	4468	__ = using_join(); ;
4238	4469	}
4239	4470	#undef yythunkpos

4253	4484	#define yythunkpos yy->__thunkpos
4254	4485	yyprintf((stderr, "do yy_3_hint\n"));
4255	4486	{
	4487	#line 224
4256	4488	sequence_add(i); ;
4257	4489	}
4258	4490	#undef yythunkpos

4272	4504	#define yythunkpos yy->__thunkpos
4273	4505	yyprintf((stderr, "do yy_2_hint\n"));
4274	4506	{
	4507	#line 223
4275	4508	sequence_add(i); ;
4276	4509	}
4277	4510	#undef yythunkpos

4291	4524	#define yythunkpos yy->__thunkpos
4292	4525	yyprintf((stderr, "do yy_1_hint\n"));
4293	4526	{
	4527	#line 222
4294	4528	__ = using_index(i, l, p); ;
4295	4529	}
4296	4530	#undef yythunkpos

4310	4544	#define yythunkpos yy->__thunkpos
4311	4545	yyprintf((stderr, "do yy_4_match_clause\n"));
4312	4546	{
	4547	#line 217
4313	4548	__ = match_clause(false, p, c); ;
4314	4549	}
4315	4550	#undef yythunkpos

4329	4564	#define yythunkpos yy->__thunkpos
4330	4565	yyprintf((stderr, "do yy_3_match_clause\n"));
4331	4566	{
	4567	#line 215
4332	4568	sequence_add(h); ;
4333	4569	}
4334	4570	#undef yythunkpos

4348	4584	#define yythunkpos yy->__thunkpos
4349	4585	yyprintf((stderr, "do yy_2_match_clause\n"));
4350	4586	{
	4587	#line 213
4351	4588	__ = match_clause(true, p, c); ;
4352	4589	}
4353	4590	#undef yythunkpos

4367	4604	#define yythunkpos yy->__thunkpos
4368	4605	yyprintf((stderr, "do yy_1_match_clause\n"));
4369	4606	{
	4607	#line 211
4370	4608	sequence_add(h); ;
4371	4609	}
4372	4610	#undef yythunkpos

4384	4622	#define yythunkpos yy->__thunkpos
4385	4623	yyprintf((stderr, "do yy_2_node_ids\n"));
4386	4624	{
	4625	#line 206
4387	4626	sequence_add(i); ;
4388	4627	}
4389	4628	#undef yythunkpos

4399	4638	#define yythunkpos yy->__thunkpos
4400	4639	yyprintf((stderr, "do yy_1_node_ids\n"));
4401	4640	{
	4641	#line 205
4402	4642	sequence_add(i); ;
4403	4643	}
4404	4644	#undef yythunkpos

4417	4657	#define yythunkpos yy->__thunkpos
4418	4658	yyprintf((stderr, "do yy_8_start_point\n"));
4419	4659	{
	4660	#line 199
4420	4661	__ = all_rels_scan(i); ;
4421	4662	}
4422	4663	#undef yythunkpos

4438	4679	#define yythunkpos yy->__thunkpos
4439	4680	yyprintf((stderr, "do yy_7_start_point\n"));
4440	4681	{
	4682	#line 198
4441	4683	__ = rel_id_lookup(i); ;
4442	4684	}
4443	4685	#undef yythunkpos

4459	4701	#define yythunkpos yy->__thunkpos
4460	4702	yyprintf((stderr, "do yy_6_start_point\n"));
4461	4703	{
	4704	#line 195
4462	4705	__ = rel_index_query(i, x, l); ;
4463	4706	}
4464	4707	#undef yythunkpos

4480	4723	#define yythunkpos yy->__thunkpos
4481	4724	yyprintf((stderr, "do yy_5_start_point\n"));
4482	4725	{
	4726	#line 193
4483	4727	__ = rel_index_lookup(i, x, p, l); ;
4484	4728	}
4485	4729	#undef yythunkpos

4501	4745	#define yythunkpos yy->__thunkpos
4502	4746	yyprintf((stderr, "do yy_4_start_point\n"));
4503	4747	{
	4748	#line 187
4504	4749	__ = all_nodes_scan(i); ;
4505	4750	}
4506	4751	#undef yythunkpos

4522	4767	#define yythunkpos yy->__thunkpos
4523	4768	yyprintf((stderr, "do yy_3_start_point\n"));
4524	4769	{
	4770	#line 186
4525	4771	__ = node_id_lookup(i); ;
4526	4772	}
4527	4773	#undef yythunkpos

4543	4789	#define yythunkpos yy->__thunkpos
4544	4790	yyprintf((stderr, "do yy_2_start_point\n"));
4545	4791	{
	4792	#line 183
4546	4793	__ = node_index_query(i, x, l); ;
4547	4794	}
4548	4795	#undef yythunkpos

4564	4811	#define yythunkpos yy->__thunkpos
4565	4812	yyprintf((stderr, "do yy_1_start_point\n"));
4566	4813	{
	4814	#line 181
4567	4815	__ = node_index_lookup(i, x, p, l); ;
4568	4816	}
4569	4817	#undef yythunkpos

4583	4831	#define yythunkpos yy->__thunkpos
4584	4832	yyprintf((stderr, "do yy_3_start_clause\n"));
4585	4833	{
	4834	#line 175
4586	4835	__ = start_clause(c); ;
4587	4836	}
4588	4837	#undef yythunkpos

4600	4849	#define yythunkpos yy->__thunkpos
4601	4850	yyprintf((stderr, "do yy_2_start_clause\n"));
4602	4851	{
	4852	#line 173
4603	4853	sequence_add(s); ;
4604	4854	}
4605	4855	#undef yythunkpos

4617	4867	#define yythunkpos yy->__thunkpos
4618	4868	yyprintf((stderr, "do yy_1_start_clause\n"));
4619	4869	{
	4870	#line 172
4620	4871	sequence_add(s); ;
4621	4872	}
4622	4873	#undef yythunkpos

4635	4886	#define yythunkpos yy->__thunkpos
4636	4887	yyprintf((stderr, "do yy_2_loadcsv_clause\n"));
4637	4888	{
	4889	#line 169
4638	4890	__ = load_csv(false, u, i, t); ;
4639	4891	}
4640	4892	#undef yythunkpos

4654	4906	#define yythunkpos yy->__thunkpos
4655	4907	yyprintf((stderr, "do yy_1_loadcsv_clause\n"));
4656	4908	{
	4909	#line 166
4657	4910	__ = load_csv(true, u, i, t); ;
4658	4911	}
4659	4912	#undef yythunkpos

4671	4924	#define yythunkpos yy->__thunkpos
4672	4925	yyprintf((stderr, "do yy_1_periodic_commit\n"));
4673	4926	{
	4927	#line 144
4674	4928	__ = using_periodic_commit(l); ;
4675	4929	}
4676	4930	#undef yythunkpos

4686	4940	#define yythunkpos yy->__thunkpos
4687	4941	yyprintf((stderr, "do yy_1__clauses\n"));
4688	4942	{
	4943	#line 138
4689	4944	sequence_add(c); ;
4690	4945	}
4691	4946	#undef yythunkpos

4701	4956	#define yythunkpos yy->__thunkpos
4702	4957	yyprintf((stderr, "do yy_1_clauses\n"));
4703	4958	{
	4959	#line 133
4704	4960	sequence_add(c); ;
4705	4961	}
4706	4962	#undef yythunkpos

4716	4972	#define yythunkpos yy->__thunkpos
4717	4973	yyprintf((stderr, "do yy_1_query_hints\n"));
4718	4974	{
	4975	#line 130
4719	4976	sequence_add(c); ;
4720	4977	}
4721	4978	#undef yythunkpos

4730	4987	#define yythunkpos yy->__thunkpos
4731	4988	yyprintf((stderr, "do yy_1_query\n"));
4732	4989	{
	4990	#line 128
4733	4991	__ = query(); ;
4734	4992	}
4735	4993	#undef yythunkpos

4747	5005	#define yythunkpos yy->__thunkpos
4748	5006	yyprintf((stderr, "do yy_3_drop_constraint\n"));
4749	5007	{
	5008	#line 124
4750	5009	__ = drop_rel_prop_constraint(i,t,e,false); ;
4751	5010	}
4752	5011	#undef yythunkpos

4768	5027	#define yythunkpos yy->__thunkpos
4769	5028	yyprintf((stderr, "do yy_2_drop_constraint\n"));
4770	5029	{
	5030	#line 118
4771	5031	__ = drop_node_prop_constraint(i,l,e,false); ;
4772	5032	}
4773	5033	#undef yythunkpos

4789	5049	#define yythunkpos yy->__thunkpos
4790	5050	yyprintf((stderr, "do yy_1_drop_constraint\n"));
4791	5051	{
	5052	#line 116
4792	5053	__ = drop_node_prop_constraint(i,l,e,true); ;
4793	5054	}
4794	5055	#undef yythunkpos

4808	5069	#define yythunkpos yy->__thunkpos
4809	5070	yyprintf((stderr, "do yy_1_drop_index\n"));
4810	5071	{
	5072	#line 109
4811	5073	__ = drop_index(l, p); ;
4812	5074	}
4813	5075	#undef yythunkpos

4827	5089	#define yythunkpos yy->__thunkpos
4828	5090	yyprintf((stderr, "do yy_3_create_constraint\n"));
4829	5091	{
	5092	#line 104
4830	5093	__ = create_rel_prop_constraint(i,t,e,false); ;
4831	5094	}
4832	5095	#undef yythunkpos

4848	5111	#define yythunkpos yy->__thunkpos
4849	5112	yyprintf((stderr, "do yy_2_create_constraint\n"));
4850	5113	{
	5114	#line 98
4851	5115	__ = create_node_prop_constraint(i,l,e,false); ;
4852	5116	}
4853	5117	#undef yythunkpos

4869	5133	#define yythunkpos yy->__thunkpos
4870	5134	yyprintf((stderr, "do yy_1_create_constraint\n"));
4871	5135	{
	5136	#line 96
4872	5137	__ = create_node_prop_constraint(i,l,e,true); ;
4873	5138	}
4874	5139	#undef yythunkpos

4888	5153	#define yythunkpos yy->__thunkpos
4889	5154	yyprintf((stderr, "do yy_1_create_index\n"));
4890	5155	{
	5156	#line 89
4891	5157	__ = create_index(l, p); ;
4892	5158	}
4893	5159	#undef yythunkpos

4903	5169	#define yythunkpos yy->__thunkpos
4904	5170	yyprintf((stderr, "do yy_1_explain_option\n"));
4905	5171	{
	5172	#line 77
4906	5173	__ = explain_option(); ;
4907	5174	}
4908	5175	#undef yythunkpos

4916	5183	#define yythunkpos yy->__thunkpos
4917	5184	yyprintf((stderr, "do yy_1_profile_option\n"));
4918	5185	{
	5186	#line 76
4919	5187	__ = profile_option(); ;
4920	5188	}
4921	5189	#undef yythunkpos

4929	5197	#define yythunkpos yy->__thunkpos
4930	5198	yyprintf((stderr, "do yy_1_cypher_param_val\n"));
4931	5199	{
	5200	#line 74
4932	5201	__ = block_string(); ;
4933	5202	}
4934	5203	#undef yythunkpos

4942	5211	#define yythunkpos yy->__thunkpos
4943	5212	yyprintf((stderr, "do yy_1_cypher_param_name\n"));
4944	5213	{
	5214	#line 73
4945	5215	__ = block_string(); ;
4946	5216	}
4947	5217	#undef yythunkpos

4957	5227	#define yythunkpos yy->__thunkpos
4958	5228	yyprintf((stderr, "do yy_1_cypher_param\n"));
4959	5229	{
	5230	#line 72
4960	5231	__ = cypher_option_param(n, v); ;
4961	5232	}
4962	5233	#undef yythunkpos

4972	5243	#define yythunkpos yy->__thunkpos
4973	5244	yyprintf((stderr, "do yy_1_cypher_version\n"));
4974	5245	{
	5246	#line 70
4975	5247	__ = block_string(); ;
4976	5248	}
4977	5249	#undef yythunkpos

4987	5259	#define yythunkpos yy->__thunkpos
4988	5260	yyprintf((stderr, "do yy_2_cypher_option\n"));
4989	5261	{
	5262	#line 67
4990	5263	__ = cypher_option(v); ;
4991	5264	}
4992	5265	#undef yythunkpos

5004	5277	#define yythunkpos yy->__thunkpos
5005	5278	yyprintf((stderr, "do yy_1_cypher_option\n"));
5006	5279	{
	5280	#line 66
5007	5281	sequence_add(p); ;
5008	5282	}
5009	5283	#undef yythunkpos

5020	5294	#define yythunkpos yy->__thunkpos
5021	5295	yyprintf((stderr, "do yy_1_statement_option\n"));
5022	5296	{
	5297	#line 62
5023	5298	sequence_add(o); ;
5024	5299	}
5025	5300	#undef yythunkpos

5035	5310	#define yythunkpos yy->__thunkpos
5036	5311	yyprintf((stderr, "do yy_1_cypher_statement\n"));
5037	5312	{
	5313	#line 58
5038	5314	__ = statement(b); ;
5039	5315	}
5040	5316	#undef yythunkpos

5050	5326	#define yythunkpos yy->__thunkpos
5051	5327	yyprintf((stderr, "do yy_3___statement\n"));
5052	5328	{
	5329	#line 49
5053	5330	yy->result = d; ;
5054	5331	}
5055	5332	#undef yythunkpos

5065	5342	#define yythunkpos yy->__thunkpos
5066	5343	yyprintf((stderr, "do yy_2___statement\n"));
5067	5344	{
	5345	#line 48
5068	5346	yy->result = NULL; ;
5069	5347	}
5070	5348	#undef yythunkpos

5080	5358	#define yythunkpos yy->__thunkpos
5081	5359	yyprintf((stderr, "do yy_1___statement\n"));
5082	5360	{
	5361	#line 47
5083	5362	yy->result = NULL; ;
5084	5363	}
5085	5364	#undef yythunkpos

5094	5373	#define yythunkpos yy->__thunkpos
5095	5374	yyprintf((stderr, "do yy_1__statement\n"));
5096	5375	{
	5376	#line 43
5097	5377	finished(yy); ;
5098	5378	}
5099	5379	#undef yythunkpos

5108	5388	#define yythunkpos yy->__thunkpos
5109	5389	yyprintf((stderr, "do yy_4___directive\n"));
5110	5390	{
	5391	#line 38
5111	5392	yy->result = d; ;
5112	5393	}
5113	5394	#undef yythunkpos

5123	5404	#define yythunkpos yy->__thunkpos
5124	5405	yyprintf((stderr, "do yy_3___directive\n"));
5125	5406	{
	5407	#line 37
5126	5408	yy->result = d; ;
5127	5409	}
5128	5410	#undef yythunkpos

5138	5420	#define yythunkpos yy->__thunkpos
5139	5421	yyprintf((stderr, "do yy_2___directive\n"));
5140	5422	{
	5423	#line 36
5141	5424	yy->result = NULL; ;
5142	5425	}
5143	5426	#undef yythunkpos

5153	5436	#define yythunkpos yy->__thunkpos
5154	5437	yyprintf((stderr, "do yy_1___directive\n"));
5155	5438	{
	5439	#line 35
5156	5440	yy->result = NULL; ;
5157	5441	}
5158	5442	#undef yythunkpos

5167	5451	#define yythunkpos yy->__thunkpos
5168	5452	yyprintf((stderr, "do yy_1__directive\n"));
5169	5453	{
	5454	#line 31
5170	5455	finished(yy); ;
5171	5456	}
5172	5457	#undef yythunkpos

-1

src/lib/quick_parser_leg.c less more

0		/* A recursive-descent parser generated by peg 0.1.15 */
	0	/* A recursive-descent parser generated by peg 0.1.18 */
1	1
2	2	#include <stdio.h>
3	3	#include <stdlib.h>

300	300	#define yythunkpos yy->__thunkpos
301	301	yyprintf((stderr, "do yy_1_EOF\n"));
302	302	{
	303	#line 59
303	304	yy->eof = true; ;
304	305	}
305	306	#undef yythunkpos

313	314	#define yythunkpos yy->__thunkpos
314	315	yyprintf((stderr, "do yy_1_statement\n"));
315	316	{
	317	#line 32
316	318	segment(true, yy); ;
317	319	}
318	320	#undef yythunkpos

326	328	#define yythunkpos yy->__thunkpos
327	329	yyprintf((stderr, "do yy_1_client_command\n"));
328	330	{
	331	#line 20
329	332	segment(false, yy); ;
330	333	}
331	334	#undef yythunkpos

+71

-0

tests/check_errors.c less more

229	229	END_TEST
230	230
231	231
	232	START_TEST (track_error_position_across_statements)
	233	{
	234	struct cypher_input_position last = cypher_input_position_zero;
	235	result = cypher_parse(
	236	"match (n) return n;\n"
	237	"m atch (n) return n;\n"
	238	"match (d) return d;\n"
	239	"match (bc e) return a;\n",
	240	&last, NULL, 0);
	241	ck_assert_ptr_ne(result, NULL);
	242	ck_assert_int_eq(last.offset, 84);
	243
	244	ck_assert(cypher_parse_result_fprint_ast(result, memstream, 0, NULL, 0) == 0);
	245	fflush(memstream);
	246	const char *expected = "\n"
	247	" @0 0..19 statement body=@1\n"
	248	" @1 0..19 > query clauses=[@2, @7]\n"
	249	" @2 0..10 > > MATCH pattern=@3\n"
	250	" @3 6..9 > > > pattern paths=[@4]\n"
	251	" @4 6..9 > > > > pattern path (@5)\n"
	252	" @5 6..9 > > > > > node pattern (@6)\n"
	253	" @6 7..8 > > > > > > identifier `n`\n"
	254	" @7 10..18 > > RETURN projections=[@8]\n"
	255	" @8 17..18 > > > projection expression=@9\n"
	256	" @9 17..18 > > > > identifier `n`\n"
	257	"@10 20..30 error >>m atch (n)<<\n"
	258	"@11 30..40 statement body=@12\n"
	259	"@12 31..40 > query clauses=[@13]\n"
	260	"@13 31..39 > > RETURN projections=[@14]\n"
	261	"@14 38..39 > > > projection expression=@15\n"
	262	"@15 38..39 > > > > identifier `n`\n"
	263	"@16 41..60 statement body=@17\n"
	264	"@17 41..60 > query clauses=[@18, @23]\n"
	265	"@18 41..51 > > MATCH pattern=@19\n"
	266	"@19 47..50 > > > pattern paths=[@20]\n"
	267	"@20 47..50 > > > > pattern path (@21)\n"
	268	"@21 47..50 > > > > > node pattern (@22)\n"
	269	"@22 48..49 > > > > > > identifier `d`\n"
	270	"@23 51..59 > > RETURN projections=[@24]\n"
	271	"@24 58..59 > > > projection expression=@25\n"
	272	"@25 58..59 > > > > identifier `d`\n"
	273	"@26 61..73 error >>match (bc e)<<\n"
	274	"@27 73..83 statement body=@28\n"
	275	"@28 74..83 > query clauses=[@29]\n"
	276	"@29 74..82 > > RETURN projections=[@30]\n"
	277	"@30 81..82 > > > projection expression=@31\n"
	278	"@31 81..82 > > > > identifier `a`\n";
	279	ck_assert_str_eq(memstream_buffer, expected);
	280
	281	ck_assert_int_eq(cypher_parse_result_nerrors(result), 2);
	282
	283	const cypher_parse_error_t *err = cypher_parse_result_get_error(result, 0);
	284	struct cypher_input_position pos = cypher_parse_error_position(err);
	285	ck_assert_int_eq(pos.line, 2);
	286	ck_assert_int_eq(pos.column, 2);
	287	ck_assert_int_eq(pos.offset, 21);
	288	ck_assert_str_eq(cypher_parse_error_message(err),
	289	"Invalid input ' ': expected MATCH or MERGE");
	290
	291	err = cypher_parse_result_get_error(result, 1);
	292	pos = cypher_parse_error_position(err);
	293	ck_assert_int_eq(pos.line, 4);
	294	ck_assert_int_eq(pos.column, 11);
	295	ck_assert_int_eq(pos.offset, 71);
	296	ck_assert_str_eq(cypher_parse_error_message(err),
	297	"Invalid input 'e': expected a label, '{', a parameter or ')'");
	298	}
	299	END_TEST
	300
	301
232	302	TCase* errors_tcase(void)
233	303	{
234	304	TCase *tc = tcase_create("errors");

239	309	tcase_add_test(tc, parse_invalid_query_and_resync);
240	310	tcase_add_test(tc, parse_single_invalid_query);
241	311	tcase_add_test(tc, track_error_position_over_embedded_newline);
	312	tcase_add_test(tc, track_error_position_across_statements);
242	313	return tc;
243	314	}