perl5.git.perl.org Git - perl5.git/blame_incremental

... / ...

Commit	Line	Data
	1	/* -- buffer-read-only: t --
	2	!!!!!!! DO NOT EDIT THIS FILE !!!!!!!
	3	This file is built by regen_perly.pl from perly.y.
	4	Any changes made here will be lost!
	5	*/
	6
	7	case 2:
	8	#line 136 "perly.y"
	9	{
	10	parser->expect = XSTATE;
	11	(yyval.ival) = 0;
	12	}
	13
	14	break;
	15
	16	case 3:
	17	#line 141 "perly.y"
	18	{
	19	newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
	20	PL_compiling.cop_seq = 0;
	21	(yyval.ival) = 0;
	22	}
	23
	24	break;
	25
	26	case 4:
	27	#line 147 "perly.y"
	28	{
	29	parser->expect = XTERM;
	30	(yyval.ival) = 0;
	31	}
	32
	33	break;
	34
	35	case 5:
	36	#line 152 "perly.y"
	37	{
	38	PL_eval_root = (ps[0].val.opval);
	39	(yyval.ival) = 0;
	40	}
	41
	42	break;
	43
	44	case 6:
	45	#line 157 "perly.y"
	46	{
	47	parser->expect = XBLOCK;
	48	(yyval.ival) = 0;
	49	}
	50
	51	break;
	52
	53	case 7:
	54	#line 162 "perly.y"
	55	{
	56	PL_pad_reset_pending = TRUE;
	57	PL_eval_root = (ps[0].val.opval);
	58	(yyval.ival) = 0;
	59	yyunlex();
	60	parser->yychar = yytoken = YYEOF;
	61	}
	62
	63	break;
	64
	65	case 8:
	66	#line 170 "perly.y"
	67	{
	68	parser->expect = XSTATE;
	69	(yyval.ival) = 0;
	70	}
	71
	72	break;
	73
	74	case 9:
	75	#line 175 "perly.y"
	76	{
	77	PL_pad_reset_pending = TRUE;
	78	PL_eval_root = (ps[0].val.opval);
	79	(yyval.ival) = 0;
	80	yyunlex();
	81	parser->yychar = yytoken = YYEOF;
	82	}
	83
	84	break;
	85
	86	case 10:
	87	#line 183 "perly.y"
	88	{
	89	parser->expect = XSTATE;
	90	(yyval.ival) = 0;
	91	}
	92
	93	break;
	94
	95	case 11:
	96	#line 188 "perly.y"
	97	{
	98	PL_pad_reset_pending = TRUE;
	99	PL_eval_root = (ps[0].val.opval);
	100	(yyval.ival) = 0;
	101	yyunlex();
	102	parser->yychar = yytoken = YYEOF;
	103	}
	104
	105	break;
	106
	107	case 12:
	108	#line 196 "perly.y"
	109	{
	110	parser->expect = XSTATE;
	111	(yyval.ival) = 0;
	112	}
	113
	114	break;
	115
	116	case 13:
	117	#line 201 "perly.y"
	118	{
	119	PL_eval_root = (ps[0].val.opval);
	120	(yyval.ival) = 0;
	121	}
	122
	123	break;
	124
	125	case 14:
	126	#line 206 "perly.y"
	127	{
	128	parser->expect = XSTATE;
	129	(yyval.ival) = 0;
	130	}
	131
	132	break;
	133
	134	case 15:
	135	#line 211 "perly.y"
	136	{
	137	PL_eval_root = (ps[0].val.opval);
	138	(yyval.ival) = 0;
	139	}
	140
	141	break;
	142
	143	case 16:
	144	#line 219 "perly.y"
	145	{ if (parser->copline > (line_t)(ps[-3].val.ival))
	146	parser->copline = (line_t)(ps[-3].val.ival);
	147	(yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
	148	}
	149
	150	break;
	151
	152	case 17:
	153	#line 227 "perly.y"
	154	{ if (parser->copline > (line_t)(ps[-6].val.ival))
	155	parser->copline = (line_t)(ps[-6].val.ival);
	156	(yyval.opval) = block_end((ps[-5].val.ival), (ps[-2].val.opval));
	157	}
	158
	159	break;
	160
	161	case 18:
	162	#line 234 "perly.y"
	163	{ (yyval.ival) = block_start(TRUE);
	164	parser->parsed_sub = 0; }
	165
	166	break;
	167
	168	case 19:
	169	#line 239 "perly.y"
	170	{ if (parser->copline > (line_t)(ps[-3].val.ival))
	171	parser->copline = (line_t)(ps[-3].val.ival);
	172	(yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
	173	}
	174
	175	break;
	176
	177	case 20:
	178	#line 246 "perly.y"
	179	{ (yyval.ival) = block_start(FALSE);
	180	parser->parsed_sub = 0; }
	181
	182	break;
	183
	184	case 21:
	185	#line 252 "perly.y"
	186	{ (yyval.opval) = NULL; }
	187
	188	break;
	189
	190	case 22:
	191	#line 254 "perly.y"
	192	{ (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
	193	PL_pad_reset_pending = TRUE;
	194	if ((ps[-1].val.opval) && (ps[0].val.opval))
	195	PL_hints \|= HINT_BLOCK_SCOPE;
	196	}
	197
	198	break;
	199
	200	case 23:
	201	#line 263 "perly.y"
	202	{ (yyval.opval) = NULL; }
	203
	204	break;
	205
	206	case 24:
	207	#line 265 "perly.y"
	208	{ (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
	209	PL_pad_reset_pending = TRUE;
	210	if ((ps[-1].val.opval) && (ps[0].val.opval))
	211	PL_hints \|= HINT_BLOCK_SCOPE;
	212	}
	213
	214	break;
	215
	216	case 25:
	217	#line 274 "perly.y"
	218	{
	219	(yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0, NULL, (ps[0].val.opval)) : NULL;
	220	}
	221
	222	break;
	223
	224	case 26:
	225	#line 278 "perly.y"
	226	{ (yyval.opval) = (ps[0].val.opval); }
	227
	228	break;
	229
	230	case 27:
	231	#line 282 "perly.y"
	232	{
	233	SV *label = cSVOPx_sv((ps[-1].val.opval));
	234	(yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
	235	savepv(SvPVX_const(label)), (ps[0].val.opval));
	236	op_free((ps[-1].val.opval));
	237	}
	238
	239	break;
	240
	241	case 28:
	242	#line 289 "perly.y"
	243	{
	244	SV *label = cSVOPx_sv((ps[-1].val.opval));
	245	(yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
	246	savepv(SvPVX_const(label)), (ps[0].val.opval));
	247	op_free((ps[-1].val.opval));
	248	}
	249
	250	break;
	251
	252	case 29:
	253	#line 299 "perly.y"
	254	{ (yyval.opval) = (ps[0].val.opval); }
	255
	256	break;
	257
	258	case 30:
	259	#line 301 "perly.y"
	260	{
	261	CV *fmtcv = PL_compcv;
	262	newFORM((ps[-2].val.ival), (ps[-1].val.opval), (ps[0].val.opval));
	263	(yyval.opval) = NULL;
	264	if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
	265	pad_add_weakref(fmtcv);
	266	}
	267	parser->parsed_sub = 1;
	268	}
	269
	270	break;
	271
	272	case 31:
	273	#line 313 "perly.y"
	274	{
	275	init_named_cv(PL_compcv, (ps[-1].val.opval));
	276	parser->in_my = 0;
	277	parser->in_my_stash = NULL;
	278	}
	279
	280	break;
	281
	282	case 32:
	283	#line 319 "perly.y"
	284	{
	285	SvREFCNT_inc_simple_void(PL_compcv);
	286	(ps[-5].val.opval)->op_type == OP_CONST
	287	? newATTRSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
	288	: newMYSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
	289	;
	290	(yyval.opval) = NULL;
	291	intro_my();
	292	parser->parsed_sub = 1;
	293	}
	294
	295	break;
	296
	297	case 33:
	298	#line 334 "perly.y"
	299	{
	300	init_named_cv(PL_compcv, (ps[-1].val.opval));
	301	parser->in_my = 0;
	302	parser->in_my_stash = NULL;
	303	}
	304
	305	break;
	306
	307	case 34:
	308	#line 340 "perly.y"
	309	{
	310	SvREFCNT_inc_simple_void(PL_compcv);
	311	(ps[-4].val.opval)->op_type == OP_CONST
	312	? newATTRSUB((ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
	313	: newMYSUB( (ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
	314	;
	315	(yyval.opval) = NULL;
	316	intro_my();
	317	parser->parsed_sub = 1;
	318	}
	319
	320	break;
	321
	322	case 35:
	323	#line 351 "perly.y"
	324	{
	325	package((ps[-1].val.opval));
	326	if ((ps[-2].val.opval))
	327	package_version((ps[-2].val.opval));
	328	(yyval.opval) = NULL;
	329	}
	330
	331	break;
	332
	333	case 36:
	334	#line 358 "perly.y"
	335	{ CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
	336
	337	break;
	338
	339	case 37:
	340	#line 360 "perly.y"
	341	{
	342	SvREFCNT_inc_simple_void(PL_compcv);
	343	utilize((ps[-6].val.ival), (ps[-5].val.ival), (ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
	344	parser->parsed_sub = 1;
	345	(yyval.opval) = NULL;
	346	}
	347
	348	break;
	349
	350	case 38:
	351	#line 367 "perly.y"
	352	{
	353	(yyval.opval) = block_end((ps[-4].val.ival),
	354	newCONDOP(0, (ps[-3].val.opval), op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
	355	parser->copline = (line_t)(ps[-6].val.ival);
	356	}
	357
	358	break;
	359
	360	case 39:
	361	#line 373 "perly.y"
	362	{
	363	(yyval.opval) = block_end((ps[-4].val.ival),
	364	newCONDOP(0, (ps[-3].val.opval), (ps[0].val.opval), op_scope((ps[-1].val.opval))));
	365	parser->copline = (line_t)(ps[-6].val.ival);
	366	}
	367
	368	break;
	369
	370	case 40:
	371	#line 379 "perly.y"
	372	{
	373	(yyval.opval) = block_end((ps[-3].val.ival), newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
	374	parser->copline = (line_t)(ps[-5].val.ival);
	375	}
	376
	377	break;
	378
	379	case 41:
	380	#line 384 "perly.y"
	381	{ (yyval.opval) = block_end((ps[-3].val.ival), newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
	382
	383	break;
	384
	385	case 42:
	386	#line 386 "perly.y"
	387	{ (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
	388
	389	break;
	390
	391	case 43:
	392	#line 388 "perly.y"
	393	{
	394	(yyval.opval) = block_end((ps[-5].val.ival),
	395	newWHILEOP(0, 1, NULL,
	396	(ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
	397	parser->copline = (line_t)(ps[-7].val.ival);
	398	}
	399
	400	break;
	401
	402	case 44:
	403	#line 395 "perly.y"
	404	{
	405	(yyval.opval) = block_end((ps[-5].val.ival),
	406	newWHILEOP(0, 1, NULL,
	407	(ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
	408	parser->copline = (line_t)(ps[-7].val.ival);
	409	}
	410
	411	break;
	412
	413	case 45:
	414	#line 402 "perly.y"
	415	{ parser->expect = XTERM; }
	416
	417	break;
	418
	419	case 46:
	420	#line 404 "perly.y"
	421	{ parser->expect = XTERM; }
	422
	423	break;
	424
	425	case 47:
	426	#line 407 "perly.y"
	427	{
	428	OP *initop = (ps[-9].val.opval);
	429	OP *forop = newWHILEOP(0, 1, NULL,
	430	scalar((ps[-6].val.opval)), (ps[0].val.opval), (ps[-2].val.opval), (ps[-3].val.ival));
	431	if (initop) {
	432	forop = op_prepend_elem(OP_LINESEQ, initop,
	433	op_append_elem(OP_LINESEQ,
	434	newOP(OP_UNSTACK, OPf_SPECIAL),
	435	forop));
	436	}
	437	PL_hints \|= HINT_BLOCK_SCOPE;
	438	(yyval.opval) = block_end((ps[-10].val.ival), forop);
	439	parser->copline = (line_t)(ps[-12].val.ival);
	440	}
	441
	442	break;
	443
	444	case 48:
	445	#line 422 "perly.y"
	446	{
	447	(yyval.opval) = block_end((ps[-6].val.ival), newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
	448	parser->copline = (line_t)(ps[-8].val.ival);
	449	}
	450
	451	break;
	452
	453	case 49:
	454	#line 427 "perly.y"
	455	{
	456	(yyval.opval) = block_end((ps[-4].val.ival), newFOROP(0,
	457	op_lvalue((ps[-6].val.opval), OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
	458	parser->copline = (line_t)(ps[-7].val.ival);
	459	}
	460
	461	break;
	462
	463	case 50:
	464	#line 433 "perly.y"
	465	{ parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
	466
	467	break;
	468
	469	case 51:
	470	#line 435 "perly.y"
	471	{
	472	(yyval.opval) = block_end(
	473	(ps[-7].val.ival),
	474	newFOROP(0,
	475	op_lvalue(
	476	newUNOP(OP_REFGEN, 0,
	477	(ps[-5].val.opval)),
	478	OP_ENTERLOOP),
	479	(ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
	480	);
	481	parser->copline = (line_t)(ps[-9].val.ival);
	482	}
	483
	484	break;
	485
	486	case 52:
	487	#line 448 "perly.y"
	488	{
	489	(yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
	490	0, op_lvalue(newUNOP(OP_REFGEN, 0,
	491	(ps[-6].val.opval)),
	492	OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
	493	parser->copline = (line_t)(ps[-8].val.ival);
	494	}
	495
	496	break;
	497
	498	case 53:
	499	#line 456 "perly.y"
	500	{
	501	(yyval.opval) = block_end((ps[-4].val.ival),
	502	newFOROP(0, NULL, (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
	503	parser->copline = (line_t)(ps[-6].val.ival);
	504	}
	505
	506	break;
	507
	508	case 54:
	509	#line 462 "perly.y"
	510	{
	511	/* a block is a loop that happens once */
	512	(yyval.opval) = newWHILEOP(0, 1, NULL,
	513	NULL, (ps[-1].val.opval), (ps[0].val.opval), 0);
	514	}
	515
	516	break;
	517
	518	case 55:
	519	#line 468 "perly.y"
	520	{
	521	package((ps[-2].val.opval));
	522	if ((ps[-3].val.opval)) {
	523	package_version((ps[-3].val.opval));
	524	}
	525	}
	526
	527	break;
	528
	529	case 56:
	530	#line 475 "perly.y"
	531	{
	532	/* a block is a loop that happens once */
	533	(yyval.opval) = newWHILEOP(0, 1, NULL,
	534	NULL, block_end((ps[-3].val.ival), (ps[-1].val.opval)), NULL, 0);
	535	if (parser->copline > (line_t)(ps[-4].val.ival))
	536	parser->copline = (line_t)(ps[-4].val.ival);
	537	}
	538
	539	break;
	540
	541	case 57:
	542	#line 483 "perly.y"
	543	{
	544	(yyval.opval) = (ps[-1].val.opval);
	545	}
	546
	547	break;
	548
	549	case 58:
	550	#line 487 "perly.y"
	551	{
	552	(yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
	553	newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
	554	}
	555
	556	break;
	557
	558	case 59:
	559	#line 492 "perly.y"
	560	{
	561	(yyval.opval) = NULL;
	562	parser->copline = NOLINE;
	563	}
	564
	565	break;
	566
	567	case 60:
	568	#line 500 "perly.y"
	569	{ OP *list;
	570	if ((ps[0].val.opval)) {
	571	OP *term = (ps[0].val.opval);
	572	list = op_append_elem(OP_LIST, (ps[-1].val.opval), term);
	573	}
	574	else {
	575	list = (ps[-1].val.opval);
	576	}
	577	if (parser->copline == NOLINE)
	578	parser->copline = CopLINE(PL_curcop)-1;
	579	else parser->copline--;
	580	(yyval.opval) = newSTATEOP(0, NULL,
	581	op_convert_list(OP_FORMLINE, 0, list));
	582	}
	583
	584	break;
	585
	586	case 61:
	587	#line 517 "perly.y"
	588	{ (yyval.opval) = NULL; }
	589
	590	break;
	591
	592	case 62:
	593	#line 519 "perly.y"
	594	{ (yyval.opval) = op_unscope((ps[-1].val.opval)); }
	595
	596	break;
	597
	598	case 64:
	599	#line 527 "perly.y"
	600	{ (yyval.opval) = NULL; }
	601
	602	break;
	603
	604	case 65:
	605	#line 529 "perly.y"
	606	{ (yyval.opval) = (ps[0].val.opval); }
	607
	608	break;
	609
	610	case 66:
	611	#line 531 "perly.y"
	612	{ (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
	613
	614	break;
	615
	616	case 67:
	617	#line 533 "perly.y"
	618	{ (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
	619
	620	break;
	621
	622	case 68:
	623	#line 535 "perly.y"
	624	{ (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
	625
	626	break;
	627
	628	case 69:
	629	#line 537 "perly.y"
	630	{ (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
	631
	632	break;
	633
	634	case 70:
	635	#line 539 "perly.y"
	636	{ (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
	637	parser->copline = (line_t)(ps[-1].val.ival); }
	638
	639	break;
	640
	641	case 71:
	642	#line 542 "perly.y"
	643	{ (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
	644
	645	break;
	646
	647	case 72:
	648	#line 547 "perly.y"
	649	{ (yyval.opval) = NULL; }
	650
	651	break;
	652
	653	case 73:
	654	#line 549 "perly.y"
	655	{
	656	((ps[0].val.opval))->op_flags \|= OPf_PARENS;
	657	(yyval.opval) = op_scope((ps[0].val.opval));
	658	}
	659
	660	break;
	661
	662	case 74:
	663	#line 554 "perly.y"
	664	{ parser->copline = (line_t)(ps[-5].val.ival);
	665	(yyval.opval) = newCONDOP(0,
	666	newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
	667	op_scope((ps[-1].val.opval)), (ps[0].val.opval));
	668	PL_hints \|= HINT_BLOCK_SCOPE;
	669	}
	670
	671	break;
	672
	673	case 75:
	674	#line 564 "perly.y"
	675	{ (yyval.opval) = NULL; }
	676
	677	break;
	678
	679	case 76:
	680	#line 566 "perly.y"
	681	{ (yyval.opval) = op_scope((ps[0].val.opval)); }
	682
	683	break;
	684
	685	case 77:
	686	#line 571 "perly.y"
	687	{ (yyval.ival) = (PL_min_intro_pending &&
	688	PL_max_intro_pending >= PL_min_intro_pending);
	689	intro_my(); }
	690
	691	break;
	692
	693	case 78:
	694	#line 577 "perly.y"
	695	{ (yyval.opval) = NULL; }
	696
	697	break;
	698
	699	case 80:
	700	#line 583 "perly.y"
	701	{ YYSTYPE tmplval;
	702	(void)scan_num("1", &tmplval);
	703	(yyval.opval) = tmplval.opval; }
	704
	705	break;
	706
	707	case 82:
	708	#line 591 "perly.y"
	709	{ (yyval.opval) = invert(scalar((ps[0].val.opval))); }
	710
	711	break;
	712
	713	case 83:
	714	#line 596 "perly.y"
	715	{ (yyval.opval) = (ps[0].val.opval); intro_my(); }
	716
	717	break;
	718
	719	case 84:
	720	#line 600 "perly.y"
	721	{ (yyval.opval) = (ps[0].val.opval); intro_my(); }
	722
	723	break;
	724
	725	case 85:
	726	#line 603 "perly.y"
	727	{ (yyval.opval) = (ps[0].val.opval); }
	728
	729	break;
	730
	731	case 86:
	732	#line 604 "perly.y"
	733	{ (yyval.opval) = NULL; }
	734
	735	break;
	736
	737	case 87:
	738	#line 608 "perly.y"
	739	{ (yyval.ival) = start_subparse(FALSE, 0);
	740	SAVEFREESV(PL_compcv); }
	741
	742	break;
	743
	744	case 88:
	745	#line 614 "perly.y"
	746	{ (yyval.ival) = start_subparse(FALSE, CVf_ANON);
	747	SAVEFREESV(PL_compcv); }
	748
	749	break;
	750
	751	case 89:
	752	#line 619 "perly.y"
	753	{ (yyval.ival) = start_subparse(TRUE, 0);
	754	SAVEFREESV(PL_compcv); }
	755
	756	break;
	757
	758	case 92:
	759	#line 630 "perly.y"
	760	{ (yyval.opval) = NULL; }
	761
	762	break;
	763
	764	case 94:
	765	#line 636 "perly.y"
	766	{ (yyval.opval) = NULL; }
	767
	768	break;
	769
	770	case 95:
	771	#line 638 "perly.y"
	772	{ (yyval.opval) = (ps[0].val.opval); }
	773
	774	break;
	775
	776	case 96:
	777	#line 640 "perly.y"
	778	{ (yyval.opval) = NULL; }
	779
	780	break;
	781
	782	case 97:
	783	#line 645 "perly.y"
	784	{ (yyval.opval) = (ps[0].val.opval); }
	785
	786	break;
	787
	788	case 98:
	789	#line 647 "perly.y"
	790	{ (yyval.opval) = NULL; }
	791
	792	break;
	793
	794	case 99:
	795	#line 658 "perly.y"
	796	{ parser->in_my = 0; (yyval.opval) = NULL; }
	797
	798	break;
	799
	800	case 100:
	801	#line 660 "perly.y"
	802	{ parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
	803
	804	break;
	805
	806	case 101:
	807	#line 665 "perly.y"
	808	{ (yyval.ival) = '@'; }
	809
	810	break;
	811
	812	case 102:
	813	#line 667 "perly.y"
	814	{ (yyval.ival) = '%'; }
	815
	816	break;
	817
	818	case 103:
	819	#line 671 "perly.y"
	820	{
	821	I32 sigil = (ps[-2].val.ival);
	822	OP *var = (ps[-1].val.opval);
	823	OP *defexpr = (ps[0].val.opval);
	824
	825	if (parser->sig_slurpy)
	826	yyerror("Multiple slurpy parameters not allowed");
	827	parser->sig_slurpy = (char)sigil;
	828
	829	if (defexpr)
	830	yyerror("A slurpy parameter may not have "
	831	"a default value");
	832
	833	(yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
	834	}
	835
	836	break;
	837
	838	case 104:
	839	#line 690 "perly.y"
	840	{ (yyval.opval) = NULL; }
	841
	842	break;
	843
	844	case 105:
	845	#line 692 "perly.y"
	846	{ (yyval.opval) = newOP(OP_NULL, 0); }
	847
	848	break;
	849
	850	case 106:
	851	#line 694 "perly.y"
	852	{ (yyval.opval) = (ps[0].val.opval); }
	853
	854	break;
	855
	856	case 107:
	857	#line 700 "perly.y"
	858	{
	859	OP *var = (ps[-1].val.opval);
	860	OP *defexpr = (ps[0].val.opval);
	861
	862	if (parser->sig_slurpy)
	863	yyerror("Slurpy parameter not last");
	864
	865	parser->sig_elems++;
	866
	867	if (defexpr) {
	868	parser->sig_optelems++;
	869
	870	if ( defexpr->op_type == OP_NULL
	871	&& !(defexpr->op_flags & OPf_KIDS))
	872	{
	873	/* handle '$=' special case */
	874	if (var)
	875	yyerror("Optional parameter "
	876	"lacks default expression");
	877	op_free(defexpr);
	878	}
	879	else {
	880	/* a normal '=default' expression */
	881	OP defop = (OP)alloc_LOGOP(OP_ARGDEFELEM,
	882	defexpr,
	883	LINKLIST(defexpr));
	884	/* re-purpose op_targ to hold @_ index */
	885	defop->op_targ =
	886	(PADOFFSET)(parser->sig_elems - 1);
	887
	888	if (var) {
	889	var->op_flags \|= OPf_STACKED;
	890	(void)op_sibling_splice(var,
	891	NULL, 0, defop);
	892	scalar(defop);
	893	}
	894	else
	895	var = newUNOP(OP_NULL, 0, defop);
	896
	897	LINKLIST(var);
	898	/* NB: normally the first child of a
	899	* logop is executed before the logop,
	900	* and it pushes a boolean result
	901	* ready for the logop. For ARGDEFELEM,
	902	* the op itself does the boolean
	903	* calculation, so set the first op to
	904	* it instead.
	905	*/
	906	var->op_next = defop;
	907	defexpr->op_next = var;
	908	}
	909	}
	910	else {
	911	if (parser->sig_optelems)
	912	yyerror("Mandatory parameter "
	913	"follows optional parameter");
	914	}
	915
	916	(yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
	917	}
	918
	919	break;
	920
	921	case 108:
	922	#line 765 "perly.y"
	923	{ parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
	924
	925	break;
	926
	927	case 109:
	928	#line 767 "perly.y"
	929	{ parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
	930
	931	break;
	932
	933	case 110:
	934	#line 773 "perly.y"
	935	{ (yyval.opval) = (ps[-1].val.opval); }
	936
	937	break;
	938
	939	case 111:
	940	#line 775 "perly.y"
	941	{
	942	(yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
	943	}
	944
	945	break;
	946
	947	case 112:
	948	#line 779 "perly.y"
	949	{ (yyval.opval) = (ps[0].val.opval); }
	950
	951	break;
	952
	953	case 113:
	954	#line 784 "perly.y"
	955	{ (yyval.opval) = NULL; }
	956
	957	break;
	958
	959	case 114:
	960	#line 786 "perly.y"
	961	{ (yyval.opval) = (ps[0].val.opval); }
	962
	963	break;
	964
	965	case 115:
	966	#line 790 "perly.y"
	967	{ (yyval.opval) = NULL; }
	968
	969	break;
	970
	971	case 116:
	972	#line 792 "perly.y"
	973	{ (yyval.opval) = (ps[0].val.opval); }
	974
	975	break;
	976
	977	case 117:
	978	#line 796 "perly.y"
	979	{ (yyval.opval) = (ps[-1].val.opval); }
	980
	981	break;
	982
	983	case 118:
	984	#line 799 "perly.y"
	985	{
	986	ENTER;
	987	SAVEIV(parser->sig_elems);
	988	SAVEIV(parser->sig_optelems);
	989	SAVEI8(parser->sig_slurpy);
	990	parser->sig_elems = 0;
	991	parser->sig_optelems = 0;
	992	parser->sig_slurpy = 0;
	993	parser->in_my = KEY_sigvar;
	994	}
	995
	996	break;
	997
	998	case 119:
	999	#line 810 "perly.y"
	1000	{
	1001	OP *sigops = (ps[0].val.opval);
	1002	struct op_argcheck_aux *aux;
	1003	OP *check;
	1004
	1005	if (!FEATURE_SIGNATURES_IS_ENABLED)
	1006	Perl_croak(aTHX_ "Experimental "
	1007	"subroutine signatures not enabled");
	1008
	1009	/* We shouldn't get here otherwise */
	1010	Perl_ck_warner_d(aTHX_
	1011	packWARN(WARN_EXPERIMENTAL__SIGNATURES),
	1012	"The signatures feature is experimental");
	1013
	1014	aux = (struct op_argcheck_aux*)
	1015	PerlMemShared_malloc(
	1016	sizeof(struct op_argcheck_aux));
	1017	aux->params = parser->sig_elems;
	1018	aux->opt_params = parser->sig_optelems;
	1019	aux->slurpy = parser->sig_slurpy;
	1020	check = newUNOP_AUX(OP_ARGCHECK, 0, NULL,
	1021	(UNOP_AUX_item *)aux);
	1022	sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
	1023	sigops = op_prepend_elem(OP_LINESEQ,
	1024	newSTATEOP(0, NULL, NULL),
	1025	sigops);
	1026	/* a nextstate at the end handles context
	1027	* correctly for an empty sub body */
	1028	sigops = op_append_elem(OP_LINESEQ,
	1029	sigops,
	1030	newSTATEOP(0, NULL, NULL));
	1031	/* wrap the list of arg ops in a NULL aux op.
	1032	This serves two purposes. First, it makes
	1033	the arg list a separate subtree from the
	1034	body of the sub, and secondly the null op
	1035	may in future be upgraded to an OP_SIGNATURE
	1036	when implemented. For now leave it as
	1037	ex-argcheck */
	1038	(yyval.opval) = newUNOP_AUX(OP_ARGCHECK, 0, sigops, NULL);
	1039	op_null((yyval.opval));
	1040
	1041	parser->in_my = 0;
	1042	/* tell the toker that attrributes can follow
	1043	* this sig, but only so that the toker
	1044	* can skip through any (illegal) trailing
	1045	* attribute text then give a useful error
	1046	* message about "attributes before sig",
	1047	* rather than falling over ina mess at
	1048	* unrecognised syntax.
	1049	*/
	1050	parser->expect = XATTRBLOCK;
	1051	parser->sig_seen = TRUE;
	1052	LEAVE;
	1053	}
	1054
	1055	break;
	1056
	1057	case 120:
	1058	#line 867 "perly.y"
	1059	{ (yyval.opval) = (ps[0].val.opval); }
	1060
	1061	break;
	1062
	1063	case 121:
	1064	#line 868 "perly.y"
	1065	{ (yyval.opval) = NULL; }
	1066
	1067	break;
	1068
	1069	case 122:
	1070	#line 874 "perly.y"
	1071	{
	1072	if (parser->copline > (line_t)(ps[-2].val.ival))
	1073	parser->copline = (line_t)(ps[-2].val.ival);
	1074	(yyval.opval) = block_end((ps[-3].val.ival), (ps[-1].val.opval));
	1075	}
	1076
	1077	break;
	1078
	1079	case 123:
	1080	#line 884 "perly.y"
	1081	{ (yyval.opval) = (ps[0].val.opval); }
	1082
	1083	break;
	1084
	1085	case 124:
	1086	#line 885 "perly.y"
	1087	{ (yyval.opval) = NULL; }
	1088
	1089	break;
	1090
	1091	case 125:
	1092	#line 889 "perly.y"
	1093	{
	1094	if (parser->copline > (line_t)(ps[-2].val.ival))
	1095	parser->copline = (line_t)(ps[-2].val.ival);
	1096	(yyval.opval) = block_end((ps[-4].val.ival),
	1097	op_append_list(OP_LINESEQ, (ps[-3].val.opval), (ps[-1].val.opval)));
	1098	}
	1099
	1100	break;
	1101
	1102	case 126:
	1103	#line 900 "perly.y"
	1104	{ (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
	1105
	1106	break;
	1107
	1108	case 127:
	1109	#line 902 "perly.y"
	1110	{ (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
	1111
	1112	break;
	1113
	1114	case 128:
	1115	#line 904 "perly.y"
	1116	{ (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
	1117
	1118	break;
	1119
	1120	case 130:
	1121	#line 910 "perly.y"
	1122	{ (yyval.opval) = (ps[-1].val.opval); }
	1123
	1124	break;
	1125
	1126	case 131:
	1127	#line 912 "perly.y"
	1128	{
	1129	OP* term = (ps[0].val.opval);
	1130	(yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
	1131	}
	1132
	1133	break;
	1134
	1135	case 133:
	1136	#line 921 "perly.y"
	1137	{ (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
	1138	op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
	1139	}
	1140
	1141	break;
	1142
	1143	case 134:
	1144	#line 925 "perly.y"
	1145	{ (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
	1146	op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
	1147	}
	1148
	1149	break;
	1150
	1151	case 135:
	1152	#line 929 "perly.y"
	1153	{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
	1154	op_append_elem(OP_LIST,
	1155	op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
	1156	newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
	1157	}
	1158
	1159	break;
	1160
	1161	case 136:
	1162	#line 935 "perly.y"
	1163	{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
	1164	op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
	1165	newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
	1166	}
	1167
	1168	break;
	1169
	1170	case 137:
	1171	#line 940 "perly.y"
	1172	{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
	1173	op_append_elem(OP_LIST,
	1174	op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
	1175	newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
	1176	}
	1177
	1178	break;
	1179
	1180	case 138:
	1181	#line 946 "perly.y"
	1182	{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
	1183	op_append_elem(OP_LIST,
	1184	op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
	1185	newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
	1186	}
	1187
	1188	break;
	1189
	1190	case 139:
	1191	#line 952 "perly.y"
	1192	{ (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
	1193
	1194	break;
	1195
	1196	case 140:
	1197	#line 954 "perly.y"
	1198	{ (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
	1199
	1200	break;
	1201
	1202	case 141:
	1203	#line 956 "perly.y"
	1204	{ (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
	1205
	1206	break;
	1207
	1208	case 142:
	1209	#line 958 "perly.y"
	1210	{ SvREFCNT_inc_simple_void(PL_compcv);
	1211	(yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
	1212
	1213	break;
	1214
	1215	case 143:
	1216	#line 961 "perly.y"
	1217	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1218	op_append_elem(OP_LIST,
	1219	op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
	1220	}
	1221
	1222	break;
	1223
	1224	case 146:
	1225	#line 976 "perly.y"
	1226	{ (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
	1227
	1228	break;
	1229
	1230	case 147:
	1231	#line 978 "perly.y"
	1232	{ (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
	1233	}
	1234
	1235	break;
	1236
	1237	case 148:
	1238	#line 981 "perly.y"
	1239	{ (yyval.opval) = newBINOP(OP_AELEM, 0,
	1240	ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
	1241	scalar((ps[-1].val.opval)));
	1242	}
	1243
	1244	break;
	1245
	1246	case 149:
	1247	#line 986 "perly.y"
	1248	{ (yyval.opval) = newBINOP(OP_AELEM, 0,
	1249	ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
	1250	scalar((ps[-1].val.opval)));
	1251	}
	1252
	1253	break;
	1254
	1255	case 150:
	1256	#line 991 "perly.y"
	1257	{ (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
	1258	}
	1259
	1260	break;
	1261
	1262	case 151:
	1263	#line 994 "perly.y"
	1264	{ (yyval.opval) = newBINOP(OP_HELEM, 0,
	1265	ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
	1266	jmaybe((ps[-2].val.opval))); }
	1267
	1268	break;
	1269
	1270	case 152:
	1271	#line 998 "perly.y"
	1272	{ (yyval.opval) = newBINOP(OP_HELEM, 0,
	1273	ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
	1274	jmaybe((ps[-2].val.opval))); }
	1275
	1276	break;
	1277
	1278	case 153:
	1279	#line 1002 "perly.y"
	1280	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1281	newCVREF(0, scalar((ps[-3].val.opval))));
	1282	if (parser->expect == XBLOCK)
	1283	parser->expect = XOPERATOR;
	1284	}
	1285
	1286	break;
	1287
	1288	case 154:
	1289	#line 1008 "perly.y"
	1290	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1291	op_append_elem(OP_LIST, (ps[-1].val.opval),
	1292	newCVREF(0, scalar((ps[-4].val.opval)))));
	1293	if (parser->expect == XBLOCK)
	1294	parser->expect = XOPERATOR;
	1295	}
	1296
	1297	break;
	1298
	1299	case 155:
	1300	#line 1016 "perly.y"
	1301	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1302	op_append_elem(OP_LIST, (ps[-1].val.opval),
	1303	newCVREF(0, scalar((ps[-3].val.opval)))));
	1304	if (parser->expect == XBLOCK)
	1305	parser->expect = XOPERATOR;
	1306	}
	1307
	1308	break;
	1309
	1310	case 156:
	1311	#line 1023 "perly.y"
	1312	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1313	newCVREF(0, scalar((ps[-2].val.opval))));
	1314	if (parser->expect == XBLOCK)
	1315	parser->expect = XOPERATOR;
	1316	}
	1317
	1318	break;
	1319
	1320	case 157:
	1321	#line 1029 "perly.y"
	1322	{ (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
	1323
	1324	break;
	1325
	1326	case 158:
	1327	#line 1031 "perly.y"
	1328	{ (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
	1329
	1330	break;
	1331
	1332	case 159:
	1333	#line 1033 "perly.y"
	1334	{ (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
	1335
	1336	break;
	1337
	1338	case 160:
	1339	#line 1038 "perly.y"
	1340	{ (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
	1341
	1342	break;
	1343
	1344	case 161:
	1345	#line 1040 "perly.y"
	1346	{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1347
	1348	break;
	1349
	1350	case 162:
	1351	#line 1042 "perly.y"
	1352	{ if ((ps[-1].val.ival) != OP_REPEAT)
	1353	scalar((ps[-2].val.opval));
	1354	(yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
	1355	}
	1356
	1357	break;
	1358
	1359	case 163:
	1360	#line 1047 "perly.y"
	1361	{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1362
	1363	break;
	1364
	1365	case 164:
	1366	#line 1049 "perly.y"
	1367	{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1368
	1369	break;
	1370
	1371	case 165:
	1372	#line 1051 "perly.y"
	1373	{ (yyval.opval) = (ps[0].val.opval); }
	1374
	1375	break;
	1376
	1377	case 166:
	1378	#line 1053 "perly.y"
	1379	{ (yyval.opval) = (ps[0].val.opval); }
	1380
	1381	break;
	1382
	1383	case 167:
	1384	#line 1055 "perly.y"
	1385	{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1386
	1387	break;
	1388
	1389	case 168:
	1390	#line 1057 "perly.y"
	1391	{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1392
	1393	break;
	1394
	1395	case 169:
	1396	#line 1059 "perly.y"
	1397	{ (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1398
	1399	break;
	1400
	1401	case 170:
	1402	#line 1061 "perly.y"
	1403	{ (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
	1404
	1405	break;
	1406
	1407	case 171:
	1408	#line 1063 "perly.y"
	1409	{ (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
	1410
	1411	break;
	1412
	1413	case 172:
	1414	#line 1065 "perly.y"
	1415	{ (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
	1416
	1417	break;
	1418
	1419	case 173:
	1420	#line 1067 "perly.y"
	1421	{ (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
	1422
	1423	break;
	1424
	1425	case 174:
	1426	#line 1071 "perly.y"
	1427	{ (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
	1428
	1429	break;
	1430
	1431	case 175:
	1432	#line 1073 "perly.y"
	1433	{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1434
	1435	break;
	1436
	1437	case 176:
	1438	#line 1075 "perly.y"
	1439	{ yyerror("syntax error"); YYERROR; }
	1440
	1441	break;
	1442
	1443	case 177:
	1444	#line 1077 "perly.y"
	1445	{ yyerror("syntax error"); YYERROR; }
	1446
	1447	break;
	1448
	1449	case 178:
	1450	#line 1081 "perly.y"
	1451	{ (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
	1452
	1453	break;
	1454
	1455	case 179:
	1456	#line 1083 "perly.y"
	1457	{ (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
	1458
	1459	break;
	1460
	1461	case 180:
	1462	#line 1087 "perly.y"
	1463	{ (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
	1464
	1465	break;
	1466
	1467	case 181:
	1468	#line 1089 "perly.y"
	1469	{ (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
	1470
	1471	break;
	1472
	1473	case 182:
	1474	#line 1091 "perly.y"
	1475	{ yyerror("syntax error"); YYERROR; }
	1476
	1477	break;
	1478
	1479	case 183:
	1480	#line 1093 "perly.y"
	1481	{ yyerror("syntax error"); YYERROR; }
	1482
	1483	break;
	1484
	1485	case 184:
	1486	#line 1097 "perly.y"
	1487	{ (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
	1488
	1489	break;
	1490
	1491	case 185:
	1492	#line 1099 "perly.y"
	1493	{ (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
	1494
	1495	break;
	1496
	1497	case 186:
	1498	#line 1104 "perly.y"
	1499	{ (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
	1500
	1501	break;
	1502
	1503	case 187:
	1504	#line 1106 "perly.y"
	1505	{ (yyval.opval) = (ps[0].val.opval); }
	1506
	1507	break;
	1508
	1509	case 188:
	1510	#line 1109 "perly.y"
	1511	{ (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
	1512
	1513	break;
	1514
	1515	case 189:
	1516	#line 1111 "perly.y"
	1517	{ (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
	1518
	1519	break;
	1520
	1521	case 190:
	1522	#line 1113 "perly.y"
	1523	{ (yyval.opval) = newUNOP(OP_POSTINC, 0,
	1524	op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
	1525
	1526	break;
	1527
	1528	case 191:
	1529	#line 1116 "perly.y"
	1530	{ (yyval.opval) = newUNOP(OP_POSTDEC, 0,
	1531	op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
	1532
	1533	break;
	1534
	1535	case 192:
	1536	#line 1119 "perly.y"
	1537	{ (yyval.opval) = op_convert_list(OP_JOIN, 0,
	1538	op_append_elem(
	1539	OP_LIST,
	1540	newSVREF(scalar(
	1541	newSVOP(OP_CONST,0,
	1542	newSVpvs("\""))
	1543	)),
	1544	(ps[-1].val.opval)
	1545	));
	1546	}
	1547
	1548	break;
	1549
	1550	case 193:
	1551	#line 1130 "perly.y"
	1552	{ (yyval.opval) = newUNOP(OP_PREINC, 0,
	1553	op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
	1554
	1555	break;
	1556
	1557	case 194:
	1558	#line 1133 "perly.y"
	1559	{ (yyval.opval) = newUNOP(OP_PREDEC, 0,
	1560	op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
	1561
	1562	break;
	1563
	1564	case 195:
	1565	#line 1140 "perly.y"
	1566	{ (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
	1567
	1568	break;
	1569
	1570	case 196:
	1571	#line 1142 "perly.y"
	1572	{ (yyval.opval) = newANONLIST(NULL);}
	1573
	1574	break;
	1575
	1576	case 197:
	1577	#line 1144 "perly.y"
	1578	{ (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
	1579
	1580	break;
	1581
	1582	case 198:
	1583	#line 1146 "perly.y"
	1584	{ (yyval.opval) = newANONHASH(NULL); }
	1585
	1586	break;
	1587
	1588	case 199:
	1589	#line 1148 "perly.y"
	1590	{ SvREFCNT_inc_simple_void(PL_compcv);
	1591	(yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
	1592
	1593	break;
	1594
	1595	case 200:
	1596	#line 1151 "perly.y"
	1597	{ SvREFCNT_inc_simple_void(PL_compcv);
	1598	(yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); }
	1599
	1600	break;
	1601
	1602	case 201:
	1603	#line 1157 "perly.y"
	1604	{ (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
	1605
	1606	break;
	1607
	1608	case 202:
	1609	#line 1159 "perly.y"
	1610	{ (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
	1611
	1612	break;
	1613
	1614	case 207:
	1615	#line 1167 "perly.y"
	1616	{ (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
	1617
	1618	break;
	1619
	1620	case 208:
	1621	#line 1169 "perly.y"
	1622	{ (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
	1623
	1624	break;
	1625
	1626	case 209:
	1627	#line 1171 "perly.y"
	1628	{ (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
	1629
	1630	break;
	1631
	1632	case 210:
	1633	#line 1173 "perly.y"
	1634	{ (yyval.opval) = (ps[0].val.opval); }
	1635
	1636	break;
	1637
	1638	case 211:
	1639	#line 1175 "perly.y"
	1640	{ (yyval.opval) = localize((ps[0].val.opval),0); }
	1641
	1642	break;
	1643
	1644	case 212:
	1645	#line 1177 "perly.y"
	1646	{ (yyval.opval) = sawparens((ps[-1].val.opval)); }
	1647
	1648	break;
	1649
	1650	case 213:
	1651	#line 1179 "perly.y"
	1652	{ (yyval.opval) = (ps[0].val.opval); }
	1653
	1654	break;
	1655
	1656	case 214:
	1657	#line 1181 "perly.y"
	1658	{ (yyval.opval) = sawparens(newNULLLIST()); }
	1659
	1660	break;
	1661
	1662	case 215:
	1663	#line 1183 "perly.y"
	1664	{ (yyval.opval) = (ps[0].val.opval); }
	1665
	1666	break;
	1667
	1668	case 216:
	1669	#line 1185 "perly.y"
	1670	{ (yyval.opval) = (ps[0].val.opval); }
	1671
	1672	break;
	1673
	1674	case 217:
	1675	#line 1187 "perly.y"
	1676	{ (yyval.opval) = (ps[0].val.opval); }
	1677
	1678	break;
	1679
	1680	case 218:
	1681	#line 1189 "perly.y"
	1682	{ (yyval.opval) = (ps[0].val.opval); }
	1683
	1684	break;
	1685
	1686	case 219:
	1687	#line 1191 "perly.y"
	1688	{ (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
	1689
	1690	break;
	1691
	1692	case 220:
	1693	#line 1193 "perly.y"
	1694	{ (yyval.opval) = (ps[0].val.opval); }
	1695
	1696	break;
	1697
	1698	case 221:
	1699	#line 1195 "perly.y"
	1700	{ (yyval.opval) = op_prepend_elem(OP_ASLICE,
	1701	newOP(OP_PUSHMARK, 0),
	1702	newLISTOP(OP_ASLICE, 0,
	1703	list((ps[-1].val.opval)),
	1704	ref((ps[-3].val.opval), OP_ASLICE)));
	1705	if ((yyval.opval) && (ps[-3].val.opval))
	1706	(yyval.opval)->op_private \|=
	1707	(ps[-3].val.opval)->op_private & OPpSLICEWARNING;
	1708	}
	1709
	1710	break;
	1711
	1712	case 222:
	1713	#line 1205 "perly.y"
	1714	{ (yyval.opval) = op_prepend_elem(OP_KVASLICE,
	1715	newOP(OP_PUSHMARK, 0),
	1716	newLISTOP(OP_KVASLICE, 0,
	1717	list((ps[-1].val.opval)),
	1718	ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
	1719	if ((yyval.opval) && (ps[-3].val.opval))
	1720	(yyval.opval)->op_private \|=
	1721	(ps[-3].val.opval)->op_private & OPpSLICEWARNING;
	1722	}
	1723
	1724	break;
	1725
	1726	case 223:
	1727	#line 1215 "perly.y"
	1728	{ (yyval.opval) = op_prepend_elem(OP_HSLICE,
	1729	newOP(OP_PUSHMARK, 0),
	1730	newLISTOP(OP_HSLICE, 0,
	1731	list((ps[-2].val.opval)),
	1732	ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
	1733	if ((yyval.opval) && (ps[-4].val.opval))
	1734	(yyval.opval)->op_private \|=
	1735	(ps[-4].val.opval)->op_private & OPpSLICEWARNING;
	1736	}
	1737
	1738	break;
	1739
	1740	case 224:
	1741	#line 1225 "perly.y"
	1742	{ (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
	1743	newOP(OP_PUSHMARK, 0),
	1744	newLISTOP(OP_KVHSLICE, 0,
	1745	list((ps[-2].val.opval)),
	1746	ref((ps[-4].val.opval), OP_KVHSLICE)));
	1747	if ((yyval.opval) && (ps[-4].val.opval))
	1748	(yyval.opval)->op_private \|=
	1749	(ps[-4].val.opval)->op_private & OPpSLICEWARNING;
	1750	}
	1751
	1752	break;
	1753
	1754	case 225:
	1755	#line 1235 "perly.y"
	1756	{ (yyval.opval) = (ps[0].val.opval); }
	1757
	1758	break;
	1759
	1760	case 226:
	1761	#line 1237 "perly.y"
	1762	{ (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
	1763
	1764	break;
	1765
	1766	case 227:
	1767	#line 1239 "perly.y"
	1768	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
	1769	}
	1770
	1771	break;
	1772
	1773	case 228:
	1774	#line 1242 "perly.y"
	1775	{
	1776	(yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1777	op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
	1778	}
	1779
	1780	break;
	1781
	1782	case 229:
	1783	#line 1247 "perly.y"
	1784	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1785	op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
	1786	}
	1787
	1788	break;
	1789
	1790	case 230:
	1791	#line 1251 "perly.y"
	1792	{ (yyval.opval) = newSVREF((ps[-3].val.opval)); }
	1793
	1794	break;
	1795
	1796	case 231:
	1797	#line 1253 "perly.y"
	1798	{ (yyval.opval) = newAVREF((ps[-3].val.opval)); }
	1799
	1800	break;
	1801
	1802	case 232:
	1803	#line 1255 "perly.y"
	1804	{ (yyval.opval) = newHVREF((ps[-3].val.opval)); }
	1805
	1806	break;
	1807
	1808	case 233:
	1809	#line 1257 "perly.y"
	1810	{ (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
	1811	scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
	1812
	1813	break;
	1814
	1815	case 234:
	1816	#line 1260 "perly.y"
	1817	{ (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
	1818
	1819	break;
	1820
	1821	case 235:
	1822	#line 1262 "perly.y"
	1823	{ (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
	1824	PL_hints \|= HINT_BLOCK_SCOPE; }
	1825
	1826	break;
	1827
	1828	case 236:
	1829	#line 1265 "perly.y"
	1830	{ (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
	1831
	1832	break;
	1833
	1834	case 237:
	1835	#line 1267 "perly.y"
	1836	{ (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
	1837
	1838	break;
	1839
	1840	case 238:
	1841	#line 1269 "perly.y"
	1842	{ (yyval.opval) = newOP((ps[0].val.ival), 0); }
	1843
	1844	break;
	1845
	1846	case 239:
	1847	#line 1271 "perly.y"
	1848	{ (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
	1849
	1850	break;
	1851
	1852	case 240:
	1853	#line 1273 "perly.y"
	1854	{ (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
	1855
	1856	break;
	1857
	1858	case 241:
	1859	#line 1275 "perly.y"
	1860	{ (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
	1861
	1862	break;
	1863
	1864	case 242:
	1865	#line 1277 "perly.y"
	1866	{ (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
	1867
	1868	break;
	1869
	1870	case 243:
	1871	#line 1279 "perly.y"
	1872	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
	1873
	1874	break;
	1875
	1876	case 244:
	1877	#line 1281 "perly.y"
	1878	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
	1879	op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
	1880
	1881	break;
	1882
	1883	case 245:
	1884	#line 1284 "perly.y"
	1885	{ (yyval.opval) = newOP((ps[0].val.ival), 0); }
	1886
	1887	break;
	1888
	1889	case 246:
	1890	#line 1286 "perly.y"
	1891	{ (yyval.opval) = newOP((ps[-2].val.ival), 0);}
	1892
	1893	break;
	1894
	1895	case 247:
	1896	#line 1288 "perly.y"
	1897	{ (yyval.opval) = (ps[0].val.opval); }
	1898
	1899	break;
	1900
	1901	case 248:
	1902	#line 1290 "perly.y"
	1903	{ (yyval.opval) = (ps[-2].val.opval); }
	1904
	1905	break;
	1906
	1907	case 249:
	1908	#line 1292 "perly.y"
	1909	{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
	1910
	1911	break;
	1912
	1913	case 250:
	1914	#line 1294 "perly.y"
	1915	{ (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
	1916	? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
	1917	: newOP((ps[-2].val.ival), OPf_SPECIAL); }
	1918
	1919	break;
	1920
	1921	case 251:
	1922	#line 1298 "perly.y"
	1923	{ (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
	1924
	1925	break;
	1926
	1927	case 252:
	1928	#line 1300 "perly.y"
	1929	{
	1930	if ( (ps[0].val.opval)->op_type != OP_TRANS
	1931	&& (ps[0].val.opval)->op_type != OP_TRANSR
	1932	&& (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
	1933	{
	1934	(yyval.ival) = start_subparse(FALSE, CVf_ANON);
	1935	SAVEFREESV(PL_compcv);
	1936	} else
	1937	(yyval.ival) = 0;
	1938	}
	1939
	1940	break;
	1941
	1942	case 253:
	1943	#line 1311 "perly.y"
	1944	{ (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
	1945
	1946	break;
	1947
	1948	case 257:
	1949	#line 1319 "perly.y"
	1950	{ (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
	1951
	1952	break;
	1953
	1954	case 258:
	1955	#line 1321 "perly.y"
	1956	{ (yyval.opval) = localize((ps[0].val.opval),1); }
	1957
	1958	break;
	1959
	1960	case 259:
	1961	#line 1323 "perly.y"
	1962	{ (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
	1963
	1964	break;
	1965
	1966	case 260:
	1967	#line 1328 "perly.y"
	1968	{ (yyval.opval) = sawparens((ps[-1].val.opval)); }
	1969
	1970	break;
	1971
	1972	case 261:
	1973	#line 1330 "perly.y"
	1974	{ (yyval.opval) = sawparens(newNULLLIST()); }
	1975
	1976	break;
	1977
	1978	case 262:
	1979	#line 1333 "perly.y"
	1980	{ (yyval.opval) = (ps[0].val.opval); }
	1981
	1982	break;
	1983
	1984	case 263:
	1985	#line 1335 "perly.y"
	1986	{ (yyval.opval) = (ps[0].val.opval); }
	1987
	1988	break;
	1989
	1990	case 264:
	1991	#line 1337 "perly.y"
	1992	{ (yyval.opval) = (ps[0].val.opval); }
	1993
	1994	break;
	1995
	1996	case 265:
	1997	#line 1342 "perly.y"
	1998	{ (yyval.opval) = NULL; }
	1999
	2000	break;
	2001
	2002	case 266:
	2003	#line 1344 "perly.y"
	2004	{ (yyval.opval) = (ps[0].val.opval); }
	2005
	2006	break;
	2007
	2008	case 267:
	2009	#line 1348 "perly.y"
	2010	{ (yyval.opval) = NULL; }
	2011
	2012	break;
	2013
	2014	case 268:
	2015	#line 1350 "perly.y"
	2016	{ (yyval.opval) = (ps[0].val.opval); }
	2017
	2018	break;
	2019
	2020	case 269:
	2021	#line 1354 "perly.y"
	2022	{ (yyval.opval) = NULL; }
	2023
	2024	break;
	2025
	2026	case 270:
	2027	#line 1356 "perly.y"
	2028	{ (yyval.opval) = (ps[0].val.opval); }
	2029
	2030	break;
	2031
	2032	case 271:
	2033	#line 1362 "perly.y"
	2034	{ parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
	2035
	2036	break;
	2037
	2038	case 279:
	2039	#line 1379 "perly.y"
	2040	{ (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
	2041
	2042	break;
	2043
	2044	case 280:
	2045	#line 1383 "perly.y"
	2046	{ (yyval.opval) = newSVREF((ps[0].val.opval)); }
	2047
	2048	break;
	2049
	2050	case 281:
	2051	#line 1387 "perly.y"
	2052	{ (yyval.opval) = newAVREF((ps[0].val.opval));
	2053	if ((yyval.opval)) (yyval.opval)->op_private \|= (ps[-1].val.ival);
	2054	}
	2055
	2056	break;
	2057
	2058	case 282:
	2059	#line 1393 "perly.y"
	2060	{ (yyval.opval) = newHVREF((ps[0].val.opval));
	2061	if ((yyval.opval)) (yyval.opval)->op_private \|= (ps[-1].val.ival);
	2062	}
	2063
	2064	break;
	2065
	2066	case 283:
	2067	#line 1399 "perly.y"
	2068	{ (yyval.opval) = newAVREF((ps[0].val.opval)); }
	2069
	2070	break;
	2071
	2072	case 284:
	2073	#line 1401 "perly.y"
	2074	{ (yyval.opval) = newAVREF((ps[-3].val.opval)); }
	2075
	2076	break;
	2077
	2078	case 285:
	2079	#line 1405 "perly.y"
	2080	{ (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
	2081
	2082	break;
	2083
	2084	case 287:
	2085	#line 1410 "perly.y"
	2086	{ (yyval.opval) = newAVREF((ps[-2].val.opval)); }
	2087
	2088	break;
	2089
	2090	case 289:
	2091	#line 1415 "perly.y"
	2092	{ (yyval.opval) = newHVREF((ps[-2].val.opval)); }
	2093
	2094	break;
	2095
	2096	case 291:
	2097	#line 1420 "perly.y"
	2098	{ (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
	2099
	2100	break;
	2101
	2102	case 292:
	2103	#line 1425 "perly.y"
	2104	{ (yyval.opval) = scalar((ps[0].val.opval)); }
	2105
	2106	break;
	2107
	2108	case 293:
	2109	#line 1427 "perly.y"
	2110	{ (yyval.opval) = scalar((ps[0].val.opval)); }
	2111
	2112	break;
	2113
	2114	case 294:
	2115	#line 1429 "perly.y"
	2116	{ (yyval.opval) = op_scope((ps[0].val.opval)); }
	2117
	2118	break;
	2119
	2120	case 295:
	2121	#line 1432 "perly.y"
	2122	{ (yyval.opval) = (ps[0].val.opval); }
	2123
	2124	break;
	2125
	2126
	2127
	2128
	2129	default: break;
	2130
	2131
	2132	/* Generated from:
	2133	* 7422f72c5dfff4e2c8cd87e56299968b4a39681f2cc3b81767c0ccd50b4e2054 perly.y
	2134	* acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
	2135	* ex: set ro: */