Remove MAD.

MAD = Misc Attribute Decoration; unmaintained attempt at preserving
the Perl parse tree more faithfully so that automatic conversion to
Perl 6 would have been easier.

1 files changed, 160 insertions, 601 deletions

diff --git a/perly.y b/perly.y
index 10479136bf..de90b2adca 100644
--- a/perly.y
+++ b/perly.y
@@ -20,20 +20,6 @@
  * to run regen_perly.pl, which re-creates the files perly.h, perly.tab
  * and perly.act which are derived from this.
  *
- * Note that these derived files are included and compiled twice; once
- * from perly.c, and once from madly.c. The second time, a number of MAD
- * macros are defined, which compile in extra code that allows the parse
- * tree to be accurately dumped. In particular:
- *
- * MAD            defined if compiling madly.c
- * DO_MAD(A)      expands to A  under madly.c, to null otherwise
- * IF_MAD(a,b)    expands to A under madly.c, to B otherwise
- * TOKEN_GETMAD() expands to token_getmad() under madly.c, to null otherwise
- * TOKEN_FREE()   similarly
- * OP_GETMAD()    similarly
- * IVAL(i)        expands to (i)->tk_lval.ival or (i)
- * PVAL(p)        expands to (p)->tk_lval.pval or (p)
- *
  * The main job of of this grammar is to call the various newFOO()
  * functions in op.c to build a syntax tree of OP structs.
  * It relies on the lexer in toke.c to do the tokenizing.
@@ -47,8 +33,6 @@
 
 %pure_parser
 
-/* FIXME for MAD - is the new mintro on while and until important?  */
-
 %start grammar
 
 %union {
@@ -57,39 +41,29 @@
     char *pval;
     OP *opval;
     GV *gvval;
-#ifdef PERL_IN_MADLY_C
-    TOKEN* p_tkval;
-    TOKEN* i_tkval;
-#else
-    char *p_tkval;
-    I32	i_tkval;
-#endif
-#ifdef PERL_MAD
-    TOKEN* tkval;
-#endif
 }
 
 %token <ival> GRAMPROG GRAMEXPR GRAMBLOCK GRAMBARESTMT GRAMFULLSTMT GRAMSTMTSEQ
 
-%token <i_tkval> '{' '}' '[' ']' '-' '+' '$' '@' '%' '*' '&' ';' '=' '.'
+%token <ival> '{' '}' '[' ']' '-' '+' '$' '@' '%' '*' '&' ';' '=' '.'
 
 %token <opval> WORD METHOD FUNCMETH THING PMFUNC PRIVATEREF QWLIST
 %token <opval> FUNC0OP FUNC0SUB UNIOPSUB LSTOPSUB
 %token <opval> PLUGEXPR PLUGSTMT
-%token <p_tkval> LABEL
-%token <i_tkval> FORMAT SUB ANONSUB PACKAGE USE
-%token <i_tkval> WHILE UNTIL IF UNLESS ELSE ELSIF CONTINUE FOR
-%token <i_tkval> GIVEN WHEN DEFAULT
-%token <i_tkval> LOOPEX DOTDOT YADAYADA
-%token <i_tkval> FUNC0 FUNC1 FUNC UNIOP LSTOP
-%token <i_tkval> RELOP EQOP MULOP ADDOP
-%token <i_tkval> DOLSHARP DO HASHBRACK NOAMP
-%token <i_tkval> LOCAL MY REQUIRE
-%token <i_tkval> COLONATTR FORMLBRACK FORMRBRACK
+%token <pval> LABEL
+%token <ival> FORMAT SUB ANONSUB PACKAGE USE
+%token <ival> WHILE UNTIL IF UNLESS ELSE ELSIF CONTINUE FOR
+%token <ival> GIVEN WHEN DEFAULT
+%token <ival> LOOPEX DOTDOT YADAYADA
+%token <ival> FUNC0 FUNC1 FUNC UNIOP LSTOP
+%token <ival> RELOP EQOP MULOP ADDOP
+%token <ival> DOLSHARP DO HASHBRACK NOAMP
+%token <ival> LOCAL MY REQUIRE
+%token <ival> COLONATTR FORMLBRACK FORMRBRACK
 
 %type <ival> grammar remember mremember
 %type <ival>  startsub startanonsub startformsub
-/* FIXME for MAD - are these two ival? */
+
 %type <ival> mintro
 
 %type <opval> stmtseq fullstmt labfullstmt barestmt block mblock else
@@ -102,39 +76,37 @@
 %type <opval> realsubbody subsignature termbinop termunop anonymous termdo
 %type <opval> formstmtseq formline formarg
 
-%nonassoc <i_tkval> PREC_LOW
+%nonassoc <ival> PREC_LOW
 %nonassoc LOOPEX
 
-%left <i_tkval> OROP DOROP
-%left <i_tkval> ANDOP
-%right <i_tkval> NOTOP
+%left <ival> OROP DOROP
+%left <ival> ANDOP
+%right <ival> NOTOP
 %nonassoc LSTOP LSTOPSUB
-%left <i_tkval> ','
-%right <i_tkval> ASSIGNOP
-%right <i_tkval> '?' ':'
+%left <ival> ','
+%right <ival> ASSIGNOP
+%right <ival> '?' ':'
 %nonassoc DOTDOT YADAYADA
-%left <i_tkval> OROR DORDOR
-%left <i_tkval> ANDAND
-%left <i_tkval> BITOROP
-%left <i_tkval> BITANDOP
+%left <ival> OROR DORDOR
+%left <ival> ANDAND
+%left <ival> BITOROP
+%left <ival> BITANDOP
 %nonassoc EQOP
 %nonassoc RELOP
 %nonassoc UNIOP UNIOPSUB
 %nonassoc REQUIRE
-%left <i_tkval> SHIFTOP
+%left <ival> SHIFTOP
 %left ADDOP
 %left MULOP
-%left <i_tkval> MATCHOP
-%right <i_tkval> '!' '~' UMINUS REFGEN
-%right <i_tkval> POWOP
-%nonassoc <i_tkval> PREINC PREDEC POSTINC POSTDEC POSTJOIN
-%left <i_tkval> ARROW
-%nonassoc <i_tkval> ')'
-%left <i_tkval> '('
+%left <ival> MATCHOP
+%right <ival> '!' '~' UMINUS REFGEN
+%right <ival> POWOP
+%nonassoc <ival> PREINC PREDEC POSTINC POSTDEC POSTJOIN
+%left <ival> ARROW
+%nonassoc <ival> ')'
+%left <ival> '('
 %left '[' '{'
 
-%token <i_tkval> PEG
-
 %% /* RULES */
 
 /* Top-level choice of what kind of thing yyparse was called to parse */
@@ -205,21 +177,17 @@ grammar	:	GRAMPROG
 
 /* An ordinary block */
 block	:	'{' remember stmtseq '}'
-			{ if (PL_parser->copline > (line_t)IVAL($1))
-			      PL_parser->copline = (line_t)IVAL($1);
+			{ if (PL_parser->copline > (line_t)$1)
+			      PL_parser->copline = (line_t)$1;
 			  $$ = block_end($2, $3);
-			  TOKEN_GETMAD($1,$$,'{');
-			  TOKEN_GETMAD($4,$$,'}');
 			}
 	;
 
 /* format body */
 formblock:	'=' remember ';' FORMRBRACK formstmtseq ';' '.'
-			{ if (PL_parser->copline > (line_t)IVAL($1))
-			      PL_parser->copline = (line_t)IVAL($1);
+			{ if (PL_parser->copline > (line_t)$1)
+			      PL_parser->copline = (line_t)$1;
 			  $$ = block_end($2, $5);
-			  TOKEN_GETMAD($1,$$,'{');
-			  TOKEN_GETMAD($7,$$,'}');
 			}
 	;
 
@@ -228,11 +196,9 @@ remember:	/* NULL */	/* start a full lexical scope */
 	;
 
 mblock	:	'{' mremember stmtseq '}'
-			{ if (PL_parser->copline > (line_t)IVAL($1))
-			      PL_parser->copline = (line_t)IVAL($1);
+			{ if (PL_parser->copline > (line_t)$1)
+			      PL_parser->copline = (line_t)$1;
 			  $$ = block_end($2, $3);
-			  TOKEN_GETMAD($1,$$,'{');
-			  TOKEN_GETMAD($4,$$,'}');
 			}
 	;
 
@@ -265,11 +231,7 @@ formstmtseq:	/* NULL */
 /* A statement in the program, including optional labels */
 fullstmt:	barestmt
 			{
-			  if($1) {
-			      $$ = newSTATEOP(0, NULL, $1);
-			  } else {
-			      $$ = IF_MAD(newOP(OP_NULL, 0), NULL);
-			  }
+			  $$ = $1 ? newSTATEOP(0, NULL, $1) : NULL;
 			}
 	|	labfullstmt
 			{ $$ = $1; }
@@ -277,41 +239,22 @@ fullstmt:	barestmt
 
 labfullstmt:	LABEL barestmt
 			{
-			  $$ = newSTATEOP(SVf_UTF8
-					   * PVAL($1)[strlen(PVAL($1))+1],
-					  PVAL($1), $2);
-			  TOKEN_GETMAD($1,
-			      $2 ? cLISTOPx($$)->op_first : $$, 'L');
+			  $$ = newSTATEOP(SVf_UTF8 * $1[strlen($1)+1], $1, $2);
 			}
 	|	LABEL labfullstmt
 			{
-			  $$ = newSTATEOP(SVf_UTF8
-					   * PVAL($1)[strlen(PVAL($1))+1],
-					  PVAL($1), $2);
-			  TOKEN_GETMAD($1, cLISTOPx($$)->op_first, 'L');
+			  $$ = newSTATEOP(SVf_UTF8 * $1[strlen($1)+1], $1, $2);
 			}
 	;
 
 /* A bare statement, lacking label and other aspects of state op */
 barestmt:	PLUGSTMT
 			{ $$ = $1; }
-	|	PEG
-			{
-			  $$ = newOP(OP_NULL,0);
-			  TOKEN_GETMAD($1,$$,'p');
-			}
 	|	FORMAT startformsub formname formblock
 			{
 			  CV *fmtcv = PL_compcv;
-#ifdef MAD
-			  $$ = newFORM($2, $3, $4);
-			  prepend_madprops($1->tk_mad, $$, 'F');
-			  $1->tk_mad = 0;
-			  token_free($1);
-#else
 			  newFORM($2, $3, $4);
 			  $$ = (OP*)NULL;
-#endif
 			  if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
 			      SvREFCNT_inc_simple_void(fmtcv);
 			      pad_add_anon(fmtcv, OP_NULL);
@@ -342,80 +285,39 @@ barestmt:	PLUGSTMT
 		proto subattrlist optsubbody
 			{
 			  SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-			  {
-			      OP* o = newSVOP(OP_ANONCODE, 0,
-				(SV*)(
-#endif
 			  $2->op_type == OP_CONST
 			      ? newATTRSUB($3, $2, $5, $6, $7)
 			      : newMYSUB($3, $2, $5, $6, $7)
-#ifdef MAD
-				));
-			      $$ = newOP(OP_NULL,0);
-			      op_getmad(o,$$,'&');
-			      op_getmad($2,$$,'n');
-			      op_getmad($5,$$,'s');
-			      op_getmad($6,$$,'a');
-			      token_getmad($1,$$,'d');
-			      append_madprops($7->op_madprop, $$, 0);
-			      $7->op_madprop = 0;
-			  }
-#else
 			  ;
 			  $$ = (OP*)NULL;
-#endif
 			  intro_my();
 			}
 	|	PACKAGE WORD WORD ';'
 			{
-#ifdef MAD
-			  $$ = package($3);
-			  token_getmad($1,$$,'o');
-			  if ($2)
-			      package_version($2);
-			  token_getmad($4,$$,';');
-#else
 			  package($3);
 			  if ($2)
 			      package_version($2);
 			  $$ = (OP*)NULL;
-#endif
 			}
 	|	USE startsub
 			{ CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
 		WORD WORD optlistexpr ';'
 			{
 			  SvREFCNT_inc_simple_void(PL_compcv);
-#ifdef MAD
-			  $$ = utilize(IVAL($1), $2, $4, $5, $6);
-			  token_getmad($1,$$,'o');
-			  token_getmad($7,$$,';');
-			  if (PL_parser->rsfp_filters &&
-				      AvFILLp(PL_parser->rsfp_filters) >= 0)
-			      append_madprops(newMADPROP('!', MAD_NULL, NULL, 0), $$, 0);
-#else
-			  utilize(IVAL($1), $2, $4, $5, $6);
+			  utilize($1, $2, $4, $5, $6);
 			  $$ = (OP*)NULL;
-#endif
 			}
 	|	IF '(' remember mexpr ')' mblock else
 			{
 			  $$ = block_end($3,
 			      newCONDOP(0, $4, op_scope($6), $7));
-			  TOKEN_GETMAD($1,$$,'I');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	UNLESS '(' remember miexpr ')' mblock else
 			{
 			  $$ = block_end($3,
 			      newCONDOP(0, $4, op_scope($6), $7));
-			  TOKEN_GETMAD($1,$$,'I');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	GIVEN '(' remember mexpr ')' mblock
 			{
@@ -426,7 +328,7 @@ barestmt:	PLUGSTMT
 				    || PAD_COMPNAME_FLAGS_isOUR(offset)
 				      ? 0
 				      : offset));
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	WHEN '(' remember mexpr ')' mblock
 			{ $$ = block_end($3, newWHENOP($4, op_scope($6))); }
@@ -437,25 +339,19 @@ barestmt:	PLUGSTMT
 			  $$ = block_end($3,
 				  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				      $4, $7, $8, $6));
-			  TOKEN_GETMAD($1,$$,'W');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	UNTIL '(' remember iexpr ')' mintro mblock cont
 			{
 			  $$ = block_end($3,
 				  newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				      $4, $7, $8, $6));
-			  TOKEN_GETMAD($1,$$,'W');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	FOR '(' remember mnexpr ';' texpr ';' mintro mnexpr ')'
 		mblock
 			{
-			  OP *initop = IF_MAD($4 ? $4 : newOP(OP_NULL, 0), $4);
+			  OP *initop = $4;
 			  OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				      scalar($6), $11, $9, $8);
 			  if (initop) {
@@ -464,41 +360,25 @@ barestmt:	PLUGSTMT
 				      newOP(OP_UNSTACK, OPf_SPECIAL),
 				      forop));
 			  }
-			  DO_MAD({ forop = newUNOP(OP_NULL, 0, forop); })
 			  $$ = block_end($3, forop);
-			  TOKEN_GETMAD($1,$$,'3');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($5,$$,'1');
-			  TOKEN_GETMAD($7,$$,'2');
-			  TOKEN_GETMAD($10,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	FOR MY remember my_scalar '(' mexpr ')' mblock cont
 			{
 			  $$ = block_end($3, newFOROP(0, $4, $6, $8, $9));
-			  TOKEN_GETMAD($1,$$,'W');
-			  TOKEN_GETMAD($2,$$,'d');
-			  TOKEN_GETMAD($5,$$,'(');
-			  TOKEN_GETMAD($7,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	FOR scalar '(' remember mexpr ')' mblock cont
 			{
 			  $$ = block_end($4, newFOROP(0,
 				      op_lvalue($2, OP_ENTERLOOP), $5, $7, $8));
-			  TOKEN_GETMAD($1,$$,'W');
-			  TOKEN_GETMAD($3,$$,'(');
-			  TOKEN_GETMAD($6,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	FOR '(' remember mexpr ')' mblock cont
 			{
 			  $$ = block_end($3,
 				  newFOROP(0, (OP*)NULL, $4, $6, $7));
-			  TOKEN_GETMAD($1,$$,'W');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
-			  PL_parser->copline = (line_t)IVAL($1);
+			  PL_parser->copline = (line_t)$1;
 			}
 	|	block cont
 			{
@@ -518,22 +398,18 @@ barestmt:	PLUGSTMT
 			  /* a block is a loop that happens once */
 			  $$ = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
 				  (OP*)NULL, block_end($5, $7), (OP*)NULL, 0);
-			  TOKEN_GETMAD($4,$$,'{');
-			  TOKEN_GETMAD($8,$$,'}');
-			  if (PL_parser->copline > (line_t)IVAL($4))
-			      PL_parser->copline = (line_t)IVAL($4);
+			  if (PL_parser->copline > (line_t)$4)
+			      PL_parser->copline = (line_t)$4;
 			}
 	|	sideff ';'
 			{
 			  PL_parser->expect = XSTATE;
 			  $$ = $1;
-			  TOKEN_GETMAD($2,$$,';');
 			}
 	|	';'
 			{
 			  PL_parser->expect = XSTATE;
-			  $$ = IF_MAD(newOP(OP_NULL, 0), (OP*)NULL);
-			  TOKEN_GETMAD($1,$$,';');
+			  $$ = (OP*)NULL;
 			  PL_parser->copline = NOLINE;
 			}
 	;
@@ -543,16 +419,10 @@ formline:	THING formarg
 			{ OP *list;
 			  if ($2) {
 			      OP *term = $2;
-			      DO_MAD(term = newUNOP(OP_NULL, 0, term));
 			      list = op_append_elem(OP_LIST, $1, term);
 			  }
 			  else {
-#ifdef MAD
-			      OP *op = newNULLLIST();
-			      list = op_append_elem(OP_LIST, $1, op);
-#else
 			      list = $1;
-#endif
 			  }
 			  if (PL_parser->copline == NOLINE)
 			       PL_parser->copline = CopLINE(PL_curcop)-1;
@@ -574,26 +444,16 @@ sideff	:	error
 	|	expr
 			{ $$ = $1; }
 	|	expr IF expr
-			{ $$ = newLOGOP(OP_AND, 0, $3, $1);
-			  TOKEN_GETMAD($2,$$,'i');
-			}
+			{ $$ = newLOGOP(OP_AND, 0, $3, $1); }
 	|	expr UNLESS expr
-			{ $$ = newLOGOP(OP_OR, 0, $3, $1);
-			  TOKEN_GETMAD($2,$$,'i');
-			}
+			{ $$ = newLOGOP(OP_OR, 0, $3, $1); }
 	|	expr WHILE expr
-			{ $$ = newLOOPOP(OPf_PARENS, 1, scalar($3), $1);
-			  TOKEN_GETMAD($2,$$,'w');
-			}
+			{ $$ = newLOOPOP(OPf_PARENS, 1, scalar($3), $1); }
 	|	expr UNTIL iexpr
-			{ $$ = newLOOPOP(OPf_PARENS, 1, $3, $1);
-			  TOKEN_GETMAD($2,$$,'w');
-			}
+			{ $$ = newLOOPOP(OPf_PARENS, 1, $3, $1); }
 	|	expr FOR expr
 			{ $$ = newFOROP(0, (OP*)NULL, $3, $1, (OP*)NULL);
-			  TOKEN_GETMAD($2,$$,'w');
-			  PL_parser->copline = (line_t)IVAL($2);
-			}
+			  PL_parser->copline = (line_t)$2; }
 	|	expr WHEN expr
 			{ $$ = newWHENOP($3, op_scope($1)); }
 	;
@@ -605,17 +465,13 @@ else	:	/* NULL */
 			{
 			  ($2)->op_flags |= OPf_PARENS;
 			  $$ = op_scope($2);
-			  TOKEN_GETMAD($1,$$,'o');
 			}
 	|	ELSIF '(' mexpr ')' mblock else
-			{ PL_parser->copline = (line_t)IVAL($1);
+			{ PL_parser->copline = (line_t)$1;
 			    $$ = newCONDOP(0,
 				newSTATEOP(OPf_SPECIAL,NULL,$3),
 				op_scope($5), $6);
 			  PL_hints |= HINT_BLOCK_SCOPE;
-			  TOKEN_GETMAD($1,$$,'I');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($4,$$,')');
 			}
 	;
 
@@ -623,10 +479,7 @@ else	:	/* NULL */
 cont	:	/* NULL */
 			{ $$ = (OP*)NULL; }
 	|	CONTINUE block
-			{
-			  $$ = op_scope($2);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = op_scope($2); }
 	;
 
 /* determine whether there are any new my declarations */
@@ -702,30 +555,16 @@ proto	:	/* NULL */
 subattrlist:	/* NULL */
 			{ $$ = (OP*)NULL; }
 	|	COLONATTR THING
-			{ $$ = $2;
-			  TOKEN_GETMAD($1,$$,':');
-			}
+			{ $$ = $2; }
 	|	COLONATTR
-			{ $$ = IF_MAD(
-				    newOP(OP_NULL, 0),
-				    (OP*)NULL
-				);
-			  TOKEN_GETMAD($1,$$,':');
-			}
+			{ $$ = (OP*)NULL; }
 	;
 
 /* List of attributes for a "my" variable declaration */
 myattrlist:	COLONATTR THING
-			{ $$ = $2;
-			  TOKEN_GETMAD($1,$$,':');
-			}
+			{ $$ = $2; }
 	|	COLONATTR
-			{ $$ = IF_MAD(
-				    newOP(OP_NULL, 0),
-				    (OP*)NULL
-				);
-			  TOKEN_GETMAD($1,$$,':');
-			}
+			{ $$ = (OP*)NULL; }
 	;
 
 /* Optional subroutine signature */
@@ -751,60 +590,36 @@ subsignature:	/* NULL */ { $$ = (OP*)NULL; }
 /* Subroutine body - block with optional signature */
 realsubbody:	remember subsignature '{' stmtseq '}'
 			{
-			  if (PL_parser->copline > (line_t)IVAL($3))
-			      PL_parser->copline = (line_t)IVAL($3);
+			  if (PL_parser->copline > (line_t)$3)
+			      PL_parser->copline = (line_t)$3;
 			  $$ = block_end($1,
 				op_append_list(OP_LINESEQ, $2, $4));
-			  TOKEN_GETMAD($3,$$,'{');
-			  TOKEN_GETMAD($5,$$,'}');
 			}
 	;
 
 /* Optional subroutine body, for named subroutine declaration */
 optsubbody:	realsubbody { $$ = $1; }
-	|	';'	{ $$ = IF_MAD(
-				    newOP(OP_NULL,0),
-				    (OP*)NULL
-				);
+	|	';'	{ $$ = (OP*)NULL;
 			  PL_parser->expect = XSTATE;
-			  TOKEN_GETMAD($1,$$,';');
 			}
 	;
 
 /* Ordinary expressions; logical combinations */
 expr	:	expr ANDOP expr
-			{ $$ = newLOGOP(OP_AND, 0, $1, $3);
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newLOGOP(OP_AND, 0, $1, $3); }
 	|	expr OROP expr
-			{ $$ = newLOGOP(IVAL($2), 0, $1, $3);
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newLOGOP($2, 0, $1, $3); }
 	|	expr DOROP expr
-			{ $$ = newLOGOP(OP_DOR, 0, $1, $3);
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newLOGOP(OP_DOR, 0, $1, $3); }
 	|	listexpr %prec PREC_LOW
 	;
 
 /* Expressions are a list of terms joined by commas */
 listexpr:	listexpr ','
-			{
-#ifdef MAD
-			  OP* op = newNULLLIST();
-			  token_getmad($2,op,',');
-			  $$ = op_append_elem(OP_LIST, $1, op);
-#else
-			  $$ = $1;
-#endif
-			}
+			{ $$ = $1; }
 	|	listexpr ',' term
 			{ 
 			  OP* term = $3;
-			  DO_MAD(
-			      term = newUNOP(OP_NULL, 0, term);
-			      token_getmad($2,term,',');
-			  )
 			  $$ = op_append_elem(OP_LIST, $1, term);
 			}
 	|	term %prec PREC_LOW
@@ -812,31 +627,23 @@ listexpr:	listexpr ','
 
 /* List operators */
 listop	:	LSTOP indirob listexpr /* map {...} @args or print $fh @args */
-			{ $$ = convert(IVAL($1), OPf_STACKED,
-				op_prepend_elem(OP_LIST, newGVREF(IVAL($1),$2), $3) );
-			  TOKEN_GETMAD($1,$$,'o');
+			{ $$ = convert($1, OPf_STACKED,
+				op_prepend_elem(OP_LIST, newGVREF($1,$2), $3) );
 			}
 	|	FUNC '(' indirob expr ')'      /* print ($fh @args */
-			{ $$ = convert(IVAL($1), OPf_STACKED,
-				op_prepend_elem(OP_LIST, newGVREF(IVAL($1),$3), $4) );
-			  TOKEN_GETMAD($1,$$,'o');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
+			{ $$ = convert($1, OPf_STACKED,
+				op_prepend_elem(OP_LIST, newGVREF($1,$3), $4) );
 			}
 	|	term ARROW method '(' optexpr ')' /* $foo->bar(list) */
 			{ $$ = convert(OP_ENTERSUB, OPf_STACKED,
 				op_append_elem(OP_LIST,
 				    op_prepend_elem(OP_LIST, scalar($1), $5),
 				    newUNOP(OP_METHOD, 0, $3)));
-			  TOKEN_GETMAD($2,$$,'A');
-			  TOKEN_GETMAD($4,$$,'(');
-			  TOKEN_GETMAD($6,$$,')');
 			}
 	|	term ARROW method                     /* $foo->bar */
 			{ $$ = convert(OP_ENTERSUB, OPf_STACKED,
 				op_append_elem(OP_LIST, scalar($1),
 				    newUNOP(OP_METHOD, 0, $3)));
-			  TOKEN_GETMAD($2,$$,'A');
 			}
 	|	METHOD indirob optlistexpr           /* new Class @args */
 			{ $$ = convert(OP_ENTERSUB, OPf_STACKED,
@@ -849,19 +656,11 @@ listop	:	LSTOP indirob listexpr /* map {...} @args or print $fh @args */
 				op_append_elem(OP_LIST,
 				    op_prepend_elem(OP_LIST, $2, $4),
 				    newUNOP(OP_METHOD, 0, $1)));
-			  TOKEN_GETMAD($3,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
 			}
 	|	LSTOP optlistexpr                    /* print @args */
-			{ $$ = convert(IVAL($1), 0, $2);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = convert($1, 0, $2); }
 	|	FUNC '(' optexpr ')'                 /* print (@args) */
-			{ $$ = convert(IVAL($1), 0, $3);
-			  TOKEN_GETMAD($1,$$,'o');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($4,$$,')');
-			}
+			{ $$ = convert($1, 0, $3); }
 	|	LSTOPSUB startanonsub block /* sub f(&@);   f { foo } ... */
 			{ SvREFCNT_inc_simple_void(PL_compcv);
 			  $<opval>$ = newANONATTRSUB($2, 0, (OP*)NULL, $3); }
@@ -883,208 +682,109 @@ subscripted:    gelem '{' expr ';' '}'        /* *main::{something} */
                          * provided by the tokeniser */
 			{ $$ = newBINOP(OP_GELEM, 0, $1, scalar($3));
 			    PL_parser->expect = XOPERATOR;
-			  TOKEN_GETMAD($2,$$,'{');
-			  TOKEN_GETMAD($4,$$,';');
-			  TOKEN_GETMAD($5,$$,'}');
 			}
 	|	scalar '[' expr ']'          /* $array[$element] */
 			{ $$ = newBINOP(OP_AELEM, 0, oopsAV($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'[');
-			  TOKEN_GETMAD($4,$$,']');
 			}
 	|	term ARROW '[' expr ']'      /* somearef->[$element] */
 			{ $$ = newBINOP(OP_AELEM, 0,
 					ref(newAVREF($1),OP_RV2AV),
 					scalar($4));
-			  TOKEN_GETMAD($2,$$,'a');
-			  TOKEN_GETMAD($3,$$,'[');
-			  TOKEN_GETMAD($5,$$,']');
 			}
 	|	subscripted '[' expr ']'    /* $foo->[$bar]->[$baz] */
 			{ $$ = newBINOP(OP_AELEM, 0,
 					ref(newAVREF($1),OP_RV2AV),
 					scalar($3));
-			  TOKEN_GETMAD($2,$$,'[');
-			  TOKEN_GETMAD($4,$$,']');
 			}
 	|	scalar '{' expr ';' '}'    /* $foo{bar();} */
 			{ $$ = newBINOP(OP_HELEM, 0, oopsHV($1), jmaybe($3));
 			    PL_parser->expect = XOPERATOR;
-			  TOKEN_GETMAD($2,$$,'{');
-			  TOKEN_GETMAD($4,$$,';');
-			  TOKEN_GETMAD($5,$$,'}');
 			}
 	|	term ARROW '{' expr ';' '}' /* somehref->{bar();} */
 			{ $$ = newBINOP(OP_HELEM, 0,
 					ref(newHVREF($1),OP_RV2HV),
 					jmaybe($4));
 			    PL_parser->expect = XOPERATOR;
-			  TOKEN_GETMAD($2,$$,'a');
-			  TOKEN_GETMAD($3,$$,'{');
-			  TOKEN_GETMAD($5,$$,';');
-			  TOKEN_GETMAD($6,$$,'}');
 			}
 	|	subscripted '{' expr ';' '}' /* $foo->[bar]->{baz;} */
 			{ $$ = newBINOP(OP_HELEM, 0,
 					ref(newHVREF($1),OP_RV2HV),
 					jmaybe($3));
 			    PL_parser->expect = XOPERATOR;
-			  TOKEN_GETMAD($2,$$,'{');
-			  TOKEN_GETMAD($4,$$,';');
-			  TOKEN_GETMAD($5,$$,'}');
 			}
 	|	term ARROW '(' ')'          /* $subref->() */
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-				   newCVREF(0, scalar($1)));
-			  TOKEN_GETMAD($2,$$,'a');
-			  TOKEN_GETMAD($3,$$,'(');
-			  TOKEN_GETMAD($4,$$,')');
-			}
+				   newCVREF(0, scalar($1))); }
 	|	term ARROW '(' expr ')'     /* $subref->(@args) */
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
 				   op_append_elem(OP_LIST, $4,
-				       newCVREF(0, scalar($1))));
-			  TOKEN_GETMAD($2,$$,'a');
-			  TOKEN_GETMAD($3,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
-			}
+				       newCVREF(0, scalar($1)))); }
 
 	|	subscripted '(' expr ')'   /* $foo->{bar}->(@args) */
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
 				   op_append_elem(OP_LIST, $3,
-					       newCVREF(0, scalar($1))));
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($4,$$,')');
-			}
+					       newCVREF(0, scalar($1)))); }
 	|	subscripted '(' ')'        /* $foo->{bar}->() */
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-				   newCVREF(0, scalar($1)));
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
-			}
+				   newCVREF(0, scalar($1))); }
 	|	'(' expr ')' '[' expr ']'            /* list slice */
-			{ $$ = newSLICEOP(0, $5, $2);
-			  TOKEN_GETMAD($1,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
-			  TOKEN_GETMAD($4,$$,'[');
-			  TOKEN_GETMAD($6,$$,']');
-			}
+			{ $$ = newSLICEOP(0, $5, $2); }
 	|	QWLIST '[' expr ']'            /* list literal slice */
-			{ $$ = newSLICEOP(0, $3, $1);
-			  TOKEN_GETMAD($2,$$,'[');
-			  TOKEN_GETMAD($4,$$,']');
-			}
+			{ $$ = newSLICEOP(0, $3, $1); }
 	|	'(' ')' '[' expr ']'                 /* empty list slice! */
-			{ $$ = newSLICEOP(0, $4, (OP*)NULL);
-			  TOKEN_GETMAD($1,$$,'(');
-			  TOKEN_GETMAD($2,$$,')');
-			  TOKEN_GETMAD($3,$$,'[');
-			  TOKEN_GETMAD($5,$$,']');
-			}
+			{ $$ = newSLICEOP(0, $4, (OP*)NULL); }
     ;
 
 /* Binary operators between terms */
 termbinop:	term ASSIGNOP term                     /* $x = $y */
-			{ $$ = newASSIGNOP(OPf_STACKED, $1, IVAL($2), $3);
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newASSIGNOP(OPf_STACKED, $1, $2, $3); }
 	|	term POWOP term                        /* $x ** $y */
-			{ $$ = newBINOP(IVAL($2), 0, scalar($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
 	|	term MULOP term                        /* $x * $y, $x x $y */
-			{   if (IVAL($2) != OP_REPEAT)
+			{   if ($2 != OP_REPEAT)
 				scalar($1);
-			    $$ = newBINOP(IVAL($2), 0, $1, scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
+			    $$ = newBINOP($2, 0, $1, scalar($3));
 			}
 	|	term ADDOP term                        /* $x + $y */
-			{ $$ = newBINOP(IVAL($2), 0, scalar($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
 	|	term SHIFTOP term                      /* $x >> $y, $x << $y */
-			{ $$ = newBINOP(IVAL($2), 0, scalar($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
 	|	term RELOP term                        /* $x > $y, etc. */
-			{ $$ = newBINOP(IVAL($2), 0, scalar($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
 	|	term EQOP term                         /* $x == $y, $x eq $y */
-			{ $$ = newBINOP(IVAL($2), 0, scalar($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
 	|	term BITANDOP term                     /* $x & $y */
-			{ $$ = newBINOP(IVAL($2), 0, scalar($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
 	|	term BITOROP term                      /* $x | $y */
-			{ $$ = newBINOP(IVAL($2), 0, scalar($1), scalar($3));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
 	|	term DOTDOT term                       /* $x..$y, $x...$y */
-			{
-			  $$ = newRANGE(IVAL($2), scalar($1), scalar($3));
-			  DO_MAD({
-			      UNOP *op;
-			      op = (UNOP*)$$;
-			      op = (UNOP*)op->op_first;	/* get to flop */
-			      op = (UNOP*)op->op_first;	/* get to flip */
-			      op = (UNOP*)op->op_first;	/* get to range */
-			      token_getmad($2,(OP*)op,'o');
-			    });
-			}
+			{ $$ = newRANGE($2, scalar($1), scalar($3)); }
 	|	term ANDAND term                       /* $x && $y */
-			{ $$ = newLOGOP(OP_AND, 0, $1, $3);
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newLOGOP(OP_AND, 0, $1, $3); }
 	|	term OROR term                         /* $x || $y */
-			{ $$ = newLOGOP(OP_OR, 0, $1, $3);
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newLOGOP(OP_OR, 0, $1, $3); }
 	|	term DORDOR term                       /* $x // $y */
-			{ $$ = newLOGOP(OP_DOR, 0, $1, $3);
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+			{ $$ = newLOGOP(OP_DOR, 0, $1, $3); }
 	|	term MATCHOP term                      /* $x =~ /$y/ */
-			{ $$ = bind_match(IVAL($2), $1, $3);
-			  TOKEN_GETMAD($2,
-				($$->op_type == OP_NOT
-				    ? ((UNOP*)$$)->op_first : $$),
-				'~');
-			}
+			{ $$ = bind_match($2, $1, $3); }
     ;
 
 /* Unary operators and terms */
 termunop : '-' term %prec UMINUS                       /* -$x */
-			{ $$ = newUNOP(OP_NEGATE, 0, scalar($2));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP(OP_NEGATE, 0, scalar($2)); }
 	|	'+' term %prec UMINUS                  /* +$x */
-			{ $$ = IF_MAD(
-				    newUNOP(OP_NULL, 0, $2),
-				    $2
-				);
-			  TOKEN_GETMAD($1,$$,'+');
-			}
+			{ $$ = $2; }
+
 	|	'!' term                               /* !$x */
-			{ $$ = newUNOP(OP_NOT, 0, scalar($2));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP(OP_NOT, 0, scalar($2)); }
 	|	'~' term                               /* ~$x */
-			{ $$ = newUNOP(OP_COMPLEMENT, 0, scalar($2));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP(OP_COMPLEMENT, 0, scalar($2)); }
 	|	term POSTINC                           /* $x++ */
 			{ $$ = newUNOP(OP_POSTINC, 0,
-					op_lvalue(scalar($1), OP_POSTINC));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+					op_lvalue(scalar($1), OP_POSTINC)); }
 	|	term POSTDEC                           /* $x-- */
 			{ $$ = newUNOP(OP_POSTDEC, 0,
-					op_lvalue(scalar($1), OP_POSTDEC));
-			  TOKEN_GETMAD($2,$$,'o');
-			}
+					op_lvalue(scalar($1), OP_POSTDEC));}
 	|	term POSTJOIN    /* implicit join after interpolated ->@ */
 			{ $$ = convert(OP_JOIN, 0,
 				       op_append_elem(
@@ -1095,63 +795,36 @@ termunop : '-' term %prec UMINUS                       /* -$x */
 					)),
 					$1
 				       ));
-			  TOKEN_GETMAD($2,$$,'o');
 			}
 	|	PREINC term                            /* ++$x */
 			{ $$ = newUNOP(OP_PREINC, 0,
-					op_lvalue(scalar($2), OP_PREINC));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+					op_lvalue(scalar($2), OP_PREINC)); }
 	|	PREDEC term                            /* --$x */
 			{ $$ = newUNOP(OP_PREDEC, 0,
-					op_lvalue(scalar($2), OP_PREDEC));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+					op_lvalue(scalar($2), OP_PREDEC)); }
 
     ;
 
 /* Constructors for anonymous data */
 anonymous:	'[' expr ']'
-			{ $$ = newANONLIST($2);
-			  TOKEN_GETMAD($1,$$,'[');
-			  TOKEN_GETMAD($3,$$,']');
-			}
+			{ $$ = newANONLIST($2); }
 	|	'[' ']'
-			{ $$ = newANONLIST((OP*)NULL);
-			  TOKEN_GETMAD($1,$$,'[');
-			  TOKEN_GETMAD($2,$$,']');
-			}
+			{ $$ = newANONLIST((OP*)NULL);}
 	|	HASHBRACK expr ';' '}'	%prec '(' /* { foo => "Bar" } */
-			{ $$ = newANONHASH($2);
-			  TOKEN_GETMAD($1,$$,'{');
-			  TOKEN_GETMAD($3,$$,';');
-			  TOKEN_GETMAD($4,$$,'}');
-			}
+			{ $$ = newANONHASH($2); }
 	|	HASHBRACK ';' '}'	%prec '(' /* { } (';' by tokener) */
-			{ $$ = newANONHASH((OP*)NULL);
-			  TOKEN_GETMAD($1,$$,'{');
-			  TOKEN_GETMAD($2,$$,';');
-			  TOKEN_GETMAD($3,$$,'}');
-			}
+			{ $$ = newANONHASH((OP*)NULL); }
 	|	ANONSUB startanonsub proto subattrlist realsubbody	%prec '('
 			{ SvREFCNT_inc_simple_void(PL_compcv);
-			  $$ = newANONATTRSUB($2, $3, $4, $5);
-			  TOKEN_GETMAD($1,$$,'o');
-			  OP_GETMAD($3,$$,'s');
-			  OP_GETMAD($4,$$,'a');
-			}
+			  $$ = newANONATTRSUB($2, $3, $4, $5); }
 
     ;
 
 /* Things called with "do" */
 termdo	:       DO term	%prec UNIOP                     /* do $filename */
-			{ $$ = dofile($2, IVAL($1));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = dofile($2, $1);}
 	|	DO block	%prec '('               /* do { code */
-			{ $$ = newUNOP(OP_NULL, OPf_SPECIAL, op_scope($2));
-			  TOKEN_GETMAD($1,$$,'D');
-			}
+			{ $$ = newUNOP(OP_NULL, OPf_SPECIAL, op_scope($2));}
         ;
 
 term	:	termbinop
@@ -1159,32 +832,19 @@ term	:	termbinop
 	|	anonymous
 	|	termdo
 	|	term '?' term ':' term
-			{ $$ = newCONDOP(0, $1, $3, $5);
-			  TOKEN_GETMAD($2,$$,'?');
-			  TOKEN_GETMAD($4,$$,':');
-			}
+			{ $$ = newCONDOP(0, $1, $3, $5); }
 	|	REFGEN term                          /* \$x, \@y, \%z */
-			{ $$ = newUNOP(OP_REFGEN, 0, op_lvalue($2,OP_REFGEN));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP(OP_REFGEN, 0, op_lvalue($2,OP_REFGEN)); }
 	|	myattrterm	%prec UNIOP
 			{ $$ = $1; }
 	|	LOCAL term	%prec UNIOP
-			{ $$ = localize($2,IVAL($1));
-			  TOKEN_GETMAD($1,$$,'k');
-			}
+			{ $$ = localize($2,$1); }
 	|	'(' expr ')'
-			{ $$ = sawparens(IF_MAD(newUNOP(OP_NULL,0,$2), $2));
-			  TOKEN_GETMAD($1,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
-			}
+			{ $$ = sawparens($2); }
 	|	QWLIST
-			{ $$ = IF_MAD(newUNOP(OP_NULL,0,$1), $1); }
+			{ $$ = $1; }
 	|	'(' ')'
-			{ $$ = sawparens(newNULLLIST());
-			  TOKEN_GETMAD($1,$$,'(');
-			  TOKEN_GETMAD($2,$$,')');
-			}
+			{ $$ = sawparens(newNULLLIST()); }
 	|	scalar	%prec '('
 			{ $$ = $1; }
 	|	star	%prec '('
@@ -1206,8 +866,6 @@ term	:	termbinop
 			  if ($$ && $1)
 			      $$->op_private |=
 				  $1->op_private & OPpSLICEWARNING;
-			  TOKEN_GETMAD($2,$$,'[');
-			  TOKEN_GETMAD($4,$$,']');
 			}
 	|	kvslice '[' expr ']'                 /* array key/value slice */
 			{ $$ = op_prepend_elem(OP_KVASLICE,
@@ -1218,8 +876,6 @@ term	:	termbinop
 			  if ($$ && $1)
 			      $$->op_private |=
 				  $1->op_private & OPpSLICEWARNING;
-			  TOKEN_GETMAD($2,$$,'[');
-			  TOKEN_GETMAD($4,$$,']');
 			}
 	|	sliceme '{' expr ';' '}'                 /* @hash{@keys} */
 			{ $$ = op_prepend_elem(OP_HSLICE,
@@ -1231,9 +887,6 @@ term	:	termbinop
 			      $$->op_private |=
 				  $1->op_private & OPpSLICEWARNING;
 			    PL_parser->expect = XOPERATOR;
-			  TOKEN_GETMAD($2,$$,'{');
-			  TOKEN_GETMAD($4,$$,';');
-			  TOKEN_GETMAD($5,$$,'}');
 			}
 	|	kvslice '{' expr ';' '}'                 /* %hash{@keys} */
 			{ $$ = op_prepend_elem(OP_KVHSLICE,
@@ -1245,9 +898,6 @@ term	:	termbinop
 			      $$->op_private |=
 				  $1->op_private & OPpSLICEWARNING;
 			    PL_parser->expect = XOPERATOR;
-			  TOKEN_GETMAD($2,$$,'{');
-			  TOKEN_GETMAD($4,$$,';');
-			  TOKEN_GETMAD($5,$$,'}');
 			}
 	|	THING	%prec '('
 			{ $$ = $1; }
@@ -1255,121 +905,65 @@ term	:	termbinop
 			{ $$ = newUNOP(OP_ENTERSUB, 0, scalar($1)); }
 	|	amper '(' ')'                 /* &foo() or foo() */
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar($1));
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
 			}
 	|	amper '(' expr ')'          /* &foo(@args) or foo(@args) */
 			{
 			  $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
 				op_append_elem(OP_LIST, $3, scalar($1)));
-			  DO_MAD({
-			      OP* op = $$;
-			      if (op->op_type == OP_CONST) { /* defeat const fold */
-				op = (OP*)op->op_madprop->mad_val;
-			      }
-			      token_getmad($2,op,'(');
-			      token_getmad($4,op,')');
-			  });
 			}
 	|	NOAMP subname optlistexpr       /* foo @args (no parens) */
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
 			    op_append_elem(OP_LIST, $3, scalar($2)));
-			  TOKEN_GETMAD($1,$$,'o');
 			}
 	|	term ARROW '$' '*'
-			{ $$ = newSVREF($1);
-			  TOKEN_GETMAD($3,$$,'$');
-			}
+			{ $$ = newSVREF($1); }
 	|	term ARROW '@' '*'
-			{ $$ = newAVREF($1);
-			  TOKEN_GETMAD($3,$$,'@');
-			}
+			{ $$ = newAVREF($1); }
 	|	term ARROW '%' '*'
-			{ $$ = newHVREF($1);
-			  TOKEN_GETMAD($3,$$,'%');
-			}
+			{ $$ = newHVREF($1); }
 	|	term ARROW '&' '*'
 			{ $$ = newUNOP(OP_ENTERSUB, 0,
-				       scalar(newCVREF(IVAL($3),$1)));
-			  TOKEN_GETMAD($3,$$,'&');
-			}
+				       scalar(newCVREF($3,$1))); }
 	|	term ARROW '*' '*'	%prec '('
-			{ $$ = newGVREF(0,$1);
-			  TOKEN_GETMAD($3,$$,'*');
-			}
+			{ $$ = newGVREF(0,$1); }
 	|	LOOPEX  /* loop exiting command (goto, last, dump, etc) */
-			{ $$ = newOP(IVAL($1), OPf_SPECIAL);
-			    PL_hints |= HINT_BLOCK_SCOPE;
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newOP($1, OPf_SPECIAL);
+			    PL_hints |= HINT_BLOCK_SCOPE; }
 	|	LOOPEX term
-			{ $$ = newLOOPEX(IVAL($1),$2);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newLOOPEX($1,$2); }
 	|	NOTOP listexpr                       /* not $foo */
-			{ $$ = newUNOP(OP_NOT, 0, scalar($2));
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP(OP_NOT, 0, scalar($2)); }
 	|	UNIOP                                /* Unary op, $_ implied */
-			{ $$ = newOP(IVAL($1), 0);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newOP($1, 0); }
 	|	UNIOP block                          /* eval { foo }* */
-			{ $$ = newUNOP(IVAL($1), 0, $2);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP($1, 0, $2); }
 	|	UNIOP term                           /* Unary op */
-			{ $$ = newUNOP(IVAL($1), 0, $2);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP($1, 0, $2); }
 	|	REQUIRE                              /* require, $_ implied */
-			{ $$ = newOP(OP_REQUIRE, $1 ? OPf_SPECIAL : 0);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newOP(OP_REQUIRE, $1 ? OPf_SPECIAL : 0); }
 	|	REQUIRE term                         /* require Foo */
-			{ $$ = newUNOP(OP_REQUIRE, $1 ? OPf_SPECIAL : 0, $2);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newUNOP(OP_REQUIRE, $1 ? OPf_SPECIAL : 0, $2); }
 	|	UNIOPSUB
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar($1)); }
 	|	UNIOPSUB term                        /* Sub treated as unop */
 			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
 			    op_append_elem(OP_LIST, $2, scalar($1))); }
 	|	FUNC0                                /* Nullary operator */
-			{ $$ = newOP(IVAL($1), 0);
-			  TOKEN_GETMAD($1,$$,'o');
-			}
+			{ $$ = newOP($1, 0); }
 	|	FUNC0 '(' ')'
-			{ $$ = newOP(IVAL($1), 0);
-			  TOKEN_GETMAD($1,$$,'o');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
-			}
+			{ $$ = newOP($1, 0);}
 	|	FUNC0OP       /* Same as above, but op created in toke.c */
 			{ $$ = $1; }
 	|	FUNC0OP '(' ')'
-			{ $$ = $1;
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
-			}
+			{ $$ = $1; }
 	|	FUNC0SUB                             /* Sub treated as nullop */
-			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED,
-				scalar($1)); }
+			{ $$ = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar($1)); }
 	|	FUNC1 '(' ')'                        /* not () */
-			{ $$ = (IVAL($1) == OP_NOT)
-			    ? newUNOP(IVAL($1), 0, newSVOP(OP_CONST, 0, newSViv(0)))
-			    : newOP(IVAL($1), OPf_SPECIAL);
-
-			  TOKEN_GETMAD($1,$$,'o');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
-			}
+			{ $$ = ($1 == OP_NOT)
+                          ? newUNOP($1, 0, newSVOP(OP_CONST, 0, newSViv(0)))
+                          : newOP($1, OPf_SPECIAL); }
 	|	FUNC1 '(' expr ')'                   /* not($foo) */
-			{ $$ = newUNOP(IVAL($1), 0, $3);
-			  TOKEN_GETMAD($1,$$,'o');
-			  TOKEN_GETMAD($2,$$,'(');
-			  TOKEN_GETMAD($4,$$,')');
-			}
+			{ $$ = newUNOP($1, 0, $3); }
 	|	PMFUNC /* m//, s///, qr//, tr/// */
 			{
 			    if (   $1->op_type != OP_TRANS
@@ -1382,47 +976,30 @@ term	:	termbinop
 				$<ival>$ = 0;
 			}
 		    '(' listexpr ')'
-			{ $$ = pmruntime($1, $4, 1, $<ival>2);
-			  TOKEN_GETMAD($3,$$,'(');
-			  TOKEN_GETMAD($5,$$,')');
-			}
+			{ $$ = pmruntime($1, $4, 1, $<ival>2); }
 	|	WORD
 	|	listop
 	|	YADAYADA
 			{
 			  $$ = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
 				newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
-			  TOKEN_GETMAD($1,$$,'X');
 			}
 	|	PLUGEXPR
 	;
 
 /* "my" declarations, with optional attributes */
 myattrterm:	MY myterm myattrlist
-			{ $$ = my_attrs($2,$3);
-			  DO_MAD(
-			      token_getmad($1,$$,'d');
-			      append_madprops($3->op_madprop, $$, 'a');
-			      $3->op_madprop = 0;
-			  );
-			}
+			{ $$ = my_attrs($2,$3); }
 	|	MY myterm
-			{ $$ = localize($2,IVAL($1));
-			  TOKEN_GETMAD($1,$$,'d');
-			}
+			{ $$ = localize($2,$1); }
 	;
 
 /* Things that can be "my"'d */
 myterm	:	'(' expr ')'
-			{ $$ = sawparens($2);
-			  TOKEN_GETMAD($1,$$,'(');
-			  TOKEN_GETMAD($3,$$,')');
-			}
+			{ $$ = sawparens($2); }
 	|	'(' ')'
-			{ $$ = sawparens(newNULLLIST());
-			  TOKEN_GETMAD($1,$$,'(');
-			  TOKEN_GETMAD($2,$$,')');
-			}
+			{ $$ = sawparens(newNULLLIST()); }
+
 	|	scalar	%prec '('
 			{ $$ = $1; }
 	|	hsh 	%prec '('
@@ -1451,66 +1028,48 @@ my_scalar:	scalar
 	;
 
 amper	:	'&' indirob
-			{ $$ = newCVREF(IVAL($1),$2);
-			  TOKEN_GETMAD($1,$$,'&');
-			}
+			{ $$ = newCVREF($1,$2); }
 	;
 
 scalar	:	'$' indirob
-			{ $$ = newSVREF($2);
-			  TOKEN_GETMAD($1,$$,'$');
-			}
+			{ $$ = newSVREF($2); }
 	;
 
 ary	:	'@' indirob
 			{ $$ = newAVREF($2);
-			  if ($$) $$->op_private |= IVAL($1);
-			  TOKEN_GETMAD($1,$$,'@');
+			  if ($$) $$->op_private |= $1;
 			}
 	;
 
 hsh	:	'%' indirob
 			{ $$ = newHVREF($2);
-			  if ($$) $$->op_private |= IVAL($1);
-			  TOKEN_GETMAD($1,$$,'%');
+			  if ($$) $$->op_private |= $1;
 			}
 	;
 
 arylen	:	DOLSHARP indirob
-			{ $$ = newAVREF($2);
-			  TOKEN_GETMAD($1,$$,'l');
-			}
+			{ $$ = newAVREF($2); }
 	|	term ARROW DOLSHARP '*'
-			{ $$ = newAVREF($1);
-			  TOKEN_GETMAD($3,$$,'l');
-			}
+			{ $$ = newAVREF($1); }
 	;
 
 star	:	'*' indirob
-			{ $$ = newGVREF(0,$2);
-			  TOKEN_GETMAD($1,$$,'*');
-			}
+			{ $$ = newGVREF(0,$2); }
 	;
 
 sliceme	:	ary
 	|	term ARROW '@'
-			{ $$ = newAVREF($1);
-			  TOKEN_GETMAD($3,$$,'@');
-			}
+			{ $$ = newAVREF($1); }
 	;
 
 kvslice	:	hsh
 	|	term ARROW '%'
-			{ $$ = newHVREF($1);
-			  TOKEN_GETMAD($3,$$,'@');
-			}
+			{ $$ = newHVREF($1); }
 	;
 
 gelem	:	star
 	|	term ARROW '*'
-			{ $$ = newGVREF(0,$1);
-			  TOKEN_GETMAD($3,$$,'*');
-			}
+			{ $$ = newGVREF(0,$1); }
 	;
 
 /* Indirect objects */