int Parser::parseLangEl()

in ragel/src/ragel/rlparse.cpp [3877:6881]

• 2,372 lines of code
• 315 McCabe index (conditional complexity)

int Parser::parseLangEl( int type, const Token *token )
{
	#line 3880 "rlparse.cpp"
#define reject() induceReject = 1

	int pos, targState;
	unsigned int *action;
	int rhsLen;
	struct Parser_LangEl *rhs[32];
	struct Parser_LangEl *lel = 0;
	struct Parser_LangEl *input = 0;
	struct Parser_LangEl *queue = 0;
	char induceReject;

	if ( curs < 0 )
		return 0;

	if ( pool == 0 ) {
		if ( freshPos == 8128 ) {
			struct Parser_Block* newBlock  = (struct Parser_Block*) malloc( sizeof(struct Parser_Block) );
			newBlock->next = block;
			block = newBlock;
			freshEl = newBlock->data;
			#ifdef KELBT_LOG_ACTIONS
			cerr << "allocating 8128 LangEls" << endl;
			#endif
			freshPos = 0;
		}
		queue = freshEl + freshPos++;
	}
	else {
		queue = pool;
		pool = pool->next;
	}
	numNodes += 1;

	queue->type = type;
	queue->user.token = *token;
	queue->next = 0;
	queue->retry = 0;
	queue->child = 0;
	queue->causeReduce = 0;

again:
	if ( input == 0 ) {
		if ( queue == 0 )
			goto _out;

		input = queue;
		queue = queue->next;
		input->next = 0;
	}

	lel = input;
	if ( lel->type < Parser_keys[curs<<1] || lel->type > Parser_keys[(curs<<1)+1] )
		goto parseError;

	pos = Parser_indicies[Parser_offsets[curs] + (lel->type - Parser_keys[curs<<1])];
	if ( pos < 0 )
		goto parseError;

	induceReject = 0;
	targState = Parser_targs[pos];
	action = Parser_actions + Parser_actInds[pos];
	if ( lel->retry & 0x0000ffff )
		action += (lel->retry & 0x0000ffff);

	if ( *action & 0x1 ) {
		#ifdef KELBT_LOG_ACTIONS
		cerr << "shifted: " << Parser_lelNames[lel->type];
		#endif
		input = input->next;
		lel->state = curs;
		lel->next = stackTop;
		stackTop = lel;

		if ( action[1] == 0 )
			lel->retry &= 0xffff0000;
		else {
			lel->retry += 1;
			numRetry += 1;
			#ifdef KELBT_LOG_ACTIONS
			cerr << " retry: " << stackTop;
			#endif
		}
		#ifdef KELBT_LOG_ACTIONS
		cerr << endl;
		#endif
	}

	if ( Parser_commitLen[pos] != 0 ) {
		struct Parser_LangEl *commitHead = stackTop, *lel;
		int sp = 0, doExec = 0;
		#ifdef KELBT_LOG_ACTIONS
		cerr << "commit encountered, executing final actions" << endl;
		#endif
		if ( Parser_commitLen[pos] < 0 )
			commitHead = commitHead->next;

		lel = commitHead;

commit_head:
		if ( lel == lastFinal ) {
			doExec = 1;
			goto commit_base;
		}

		if ( lel->next != 0 ) {
			sp += 1;
			lel->next->prev = lel;
			lel = lel->next;
			lel->retry = 0;
			goto commit_head;
		}

commit_reverse:

		if ( lel->child != 0 ) {
			sp += 1;
			lel->child->prev = lel;
			lel = lel->child;
			lel->retry = 1;
			goto commit_head;
		}

commit_upwards:

		if ( doExec ) {
			if ( lel->type < 226 ) {
			}
			else {
				struct Parser_LangEl *redLel = lel;
				if ( redLel->child != 0 ) {
					int r = Parser_prodLengths[redLel->reduction] - 1;
					struct Parser_LangEl *rhsEl = redLel->child;
					while ( rhsEl != 0 ) {
						rhs[r--] = rhsEl;
						rhsEl = rhsEl->next;
					}
				}
switch ( lel->reduction ) {
case 17: {
Token *__ref0 = (Token*)&rhs[1]->user.token;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Token *__ref2 = (Token*)&rhs[1]->user.token;
#line 61 "rlparse.kl"

		LengthDef *lengthDef = new LengthDef( (__ref0)->data );
		pd->lengthDefList.append( lengthDef );

		/* Generic creation of machine for instantiation and assignment. */
		MachineDef *machineDef = new MachineDef( lengthDef );
		tryMachineDef( (__ref1)->loc, (__ref2)->data, machineDef, false );
	

#line 4031 "rlparse.cpp"
} break;
case 18: {
Token *__ref0 = (Token*)&rhs[1]->user.token;
Parser_Lel_inline_list *__ref1 = (Parser_Lel_inline_list*)&rhs[2]->user.inline_list;
#line 72 "rlparse.kl"

		if ( pd->prePushExpr != 0 ) {
			/* Recover by just ignoring the duplicate. */
			error((__ref0)->loc) << "pre_push code already defined" << endl;
		}

		pd->prePushExpr = (__ref1)->inlineList;
	

#line 4046 "rlparse.cpp"
} break;
case 19: {
Token *__ref0 = (Token*)&rhs[1]->user.token;
Parser_Lel_inline_list *__ref1 = (Parser_Lel_inline_list*)&rhs[2]->user.inline_list;
#line 84 "rlparse.kl"

		if ( pd->postPopExpr != 0 ) {
			/* Recover by just ignoring the duplicate. */
			error((__ref0)->loc) << "post_pop code already defined" << endl;
		}

		pd->postPopExpr = (__ref1)->inlineList;
	

#line 4061 "rlparse.cpp"
} break;
case 20: {
#line 95 "rlparse.kl"

		exportContext.append( true );
	

#line 4069 "rlparse.cpp"
} break;
case 21: {
Parser_Lel_opt_export *__ref0 = (Parser_Lel_opt_export*)&redLel->user.opt_export;
#line 104 "rlparse.kl"
 (__ref0)->isSet = true; 

#line 4076 "rlparse.cpp"
} break;
case 22: {
Parser_Lel_opt_export *__ref0 = (Parser_Lel_opt_export*)&redLel->user.opt_export;
#line 105 "rlparse.kl"
 (__ref0)->isSet = false; 

#line 4083 "rlparse.cpp"
} break;
case 23: {
#line 108 "rlparse.kl"

		exportContext.remove( exportContext.length()-1 );
	

#line 4091 "rlparse.cpp"
} break;
case 24: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_join *__ref2 = (Parser_Lel_join*)&rhs[3]->user.join;
Parser_Lel_token_type *__ref3 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_token_type *__ref4 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_opt_export *__ref5 = (Parser_Lel_opt_export*)&rhs[0]->user.opt_export;
Parser_Lel_join *__ref6 = (Parser_Lel_join*)&rhs[3]->user.join;
Token *__ref7 = (Token*)&rhs[2]->user.token;
#line 113 "rlparse.kl"

		/* Main machine must be an instance. */
		bool isInstance = false;
		if ( strcmp((__ref0)->token.data, mainMachine) == 0 ) {
			warning((__ref1)->token.loc) << 
					"main machine will be implicitly instantiated" << endl;
			isInstance = true;
		}

		/* Generic creation of machine for instantiation and assignment. */
		MachineDef *machineDef = new MachineDef( (__ref2)->join );
		tryMachineDef( (__ref3)->token.loc, (__ref4)->token.data, machineDef, isInstance );

		if ( (__ref5)->isSet )
			exportContext.remove( exportContext.length()-1 );

		(__ref6)->join->loc = (__ref7)->loc;
	

#line 4122 "rlparse.cpp"
} break;
case 25: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_join_or_lm *__ref2 = (Parser_Lel_join_or_lm*)&rhs[3]->user.join_or_lm;
Parser_Lel_opt_export *__ref3 = (Parser_Lel_opt_export*)&rhs[0]->user.opt_export;
Parser_Lel_join_or_lm *__ref4 = (Parser_Lel_join_or_lm*)&rhs[3]->user.join_or_lm;
Parser_Lel_join_or_lm *__ref5 = (Parser_Lel_join_or_lm*)&rhs[3]->user.join_or_lm;
Token *__ref6 = (Token*)&rhs[2]->user.token;
#line 133 "rlparse.kl"

		/* Generic creation of machine for instantiation and assignment. */
		tryMachineDef( (__ref0)->token.loc, (__ref1)->token.data, (__ref2)->machineDef, true );

		if ( (__ref3)->isSet )
			exportContext.remove( exportContext.length()-1 );

		/* Pass a location to join_or_lm */
		if ( (__ref4)->machineDef->join != 0 )
			(__ref5)->machineDef->join->loc = (__ref6)->loc;
	

#line 4145 "rlparse.cpp"
} break;
case 26: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_token_type *__ref2 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref3 = (Token*)&rhs[0]->user.token;
#line 153 "rlparse.kl"

		/* Make/get the priority key. The name may have already been referenced
		 * and therefore exist. */
		PriorDictEl *priorDictEl;
		if ( pd->priorDict.insert( (__ref0)->data, pd->nextPriorKey, &priorDictEl ) )
			pd->nextPriorKey += 1;
		pd->curDefPriorKey = priorDictEl->value;

		/* Make/get the local error key. */
		LocalErrDictEl *localErrDictEl;
		if ( pd->localErrDict.insert( (__ref1)->data, pd->nextLocalErrKey, &localErrDictEl ) )
			pd->nextLocalErrKey += 1;
		pd->curDefLocalErrKey = localErrDictEl->value;

		(__ref2)->token = *(__ref3);
	

#line 4170 "rlparse.cpp"
} break;
case 27: {
Token *__ref0 = (Token*)&rhs[1]->user.token;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Token *__ref2 = (Token*)&rhs[1]->user.token;
Token *__ref3 = (Token*)&rhs[2]->user.token;
Token *__ref4 = (Token*)&rhs[1]->user.token;
Parser_Lel_inline_list *__ref5 = (Parser_Lel_inline_list*)&rhs[3]->user.inline_list;
#line 171 "rlparse.kl"

		if ( pd->actionDict.find( (__ref0)->data ) ) {
			/* Recover by just ignoring the duplicate. */
			error((__ref1)->loc) << "action \"" << (__ref2)->data << "\" already defined" << endl;
		}
		else {
			//cerr << "NEW ACTION " << $2->data << " " << $4->inlineList << endl;
			/* Add the action to the list of actions. */
			Action *newAction = new Action( (__ref3)->loc, (__ref4)->data, 
					(__ref5)->inlineList, pd->nextCondId++ );

			/* Insert to list and dict. */
			pd->actionList.append( newAction );
			pd->actionDict.insert( newAction );
		}
	

#line 4197 "rlparse.cpp"
} break;
case 28: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Token *__ref2 = (Token*)&rhs[2]->user.token;
Token *__ref3 = (Token*)&rhs[1]->user.token;
Token *__ref4 = (Token*)&rhs[1]->user.token;
Token *__ref5 = (Token*)&rhs[2]->user.token;
#line 191 "rlparse.kl"

		if ( ! pd->setAlphType( (__ref0)->loc, (__ref1)->data, (__ref2)->data ) ) {
			// Recover by ignoring the alphtype statement.
			error((__ref3)->loc) << "\"" << (__ref4)->data << 
					" " << (__ref5)->data << "\" is not a valid alphabet type" << endl;
		}
	

#line 4215 "rlparse.cpp"
} break;
case 29: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Token *__ref2 = (Token*)&rhs[1]->user.token;
Token *__ref3 = (Token*)&rhs[1]->user.token;
#line 200 "rlparse.kl"

		if ( ! pd->setAlphType( (__ref0)->loc, (__ref1)->data ) ) {
			// Recover by ignoring the alphtype statement.
			error((__ref2)->loc) << "\"" << (__ref3)->data << 
					"\" is not a valid alphabet type" << endl;
		}
	

#line 4231 "rlparse.cpp"
} break;
case 30: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[2]->user.token_type;
Parser_Lel_token_type *__ref2 = (Parser_Lel_token_type*)&rhs[1]->user.token_type;
Parser_Lel_token_type *__ref3 = (Parser_Lel_token_type*)&rhs[2]->user.token_type;
#line 210 "rlparse.kl"

		// Save the upper and lower ends of the range and emit the line number.
		pd->lowerNum = (__ref0)->token.data;
		pd->upperNum = (__ref1)->token.data;
		pd->rangeLowLoc = (__ref2)->token.loc;
		pd->rangeHighLoc = (__ref3)->token.loc;
	

#line 4247 "rlparse.cpp"
} break;
case 31: {
Parser_Lel_inline_list *__ref0 = (Parser_Lel_inline_list*)&rhs[1]->user.inline_list;
#line 219 "rlparse.kl"

		pd->getKeyExpr = (__ref0)->inlineList;
	

#line 4256 "rlparse.cpp"
} break;
case 32: {
Parser_Lel_inline_list *__ref0 = (Parser_Lel_inline_list*)&rhs[1]->user.inline_list;
#line 224 "rlparse.kl"

		pd->accessExpr = (__ref0)->inlineList;
	

#line 4265 "rlparse.cpp"
} break;
case 33: {
Token *__ref0 = (Token*)&rhs[2]->user.token;
Parser_Lel_inline_list *__ref1 = (Parser_Lel_inline_list*)&rhs[3]->user.inline_list;
Token *__ref2 = (Token*)&rhs[2]->user.token;
#line 229 "rlparse.kl"

		/* FIXME: Need to implement the rest of this. */
		bool wasSet = pd->setVariable( (__ref0)->data, (__ref1)->inlineList );
		if ( !wasSet )
			error((__ref2)->loc) << "bad variable name" << endl;
	

#line 4279 "rlparse.cpp"
} break;
case 36: {
Parser_Lel_join_or_lm *__ref0 = (Parser_Lel_join_or_lm*)&redLel->user.join_or_lm;
Parser_Lel_join *__ref1 = (Parser_Lel_join*)&rhs[0]->user.join;
#line 249 "rlparse.kl"

		(__ref0)->machineDef = new MachineDef( (__ref1)->join );
	

#line 4289 "rlparse.cpp"
} break;
case 37: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Parser_Lel_lm_part_list *__ref1 = (Parser_Lel_lm_part_list*)&rhs[1]->user.lm_part_list;
Parser_Lel_lm_part_list *__ref2 = (Parser_Lel_lm_part_list*)&rhs[1]->user.lm_part_list;
Parser_Lel_join_or_lm *__ref3 = (Parser_Lel_join_or_lm*)&redLel->user.join_or_lm;
#line 253 "rlparse.kl"

		/* Create a new factor going to a longest match structure. Record
		 * in the parse data that we have a longest match. */
		LongestMatch *lm = new LongestMatch( (__ref0)->loc, (__ref1)->lmPartList );
		pd->lmList.append( lm );
		for ( LmPartList::Iter lmp = *((__ref2)->lmPartList); lmp.lte(); lmp++ )
			lmp->longestMatch = lm;
		(__ref3)->machineDef = new MachineDef( lm );
	

#line 4307 "rlparse.cpp"
} break;
case 38: {
Parser_Lel_longest_match_part *__ref0 = (Parser_Lel_longest_match_part*)&rhs[1]->user.longest_match_part;
Parser_Lel_lm_part_list *__ref1 = (Parser_Lel_lm_part_list*)&rhs[0]->user.lm_part_list;
Parser_Lel_longest_match_part *__ref2 = (Parser_Lel_longest_match_part*)&rhs[1]->user.longest_match_part;
Parser_Lel_lm_part_list *__ref3 = (Parser_Lel_lm_part_list*)&redLel->user.lm_part_list;
Parser_Lel_lm_part_list *__ref4 = (Parser_Lel_lm_part_list*)&rhs[0]->user.lm_part_list;
#line 270 "rlparse.kl"

		if ( (__ref0)->lmPart != 0 ) 
			(__ref1)->lmPartList->append( (__ref2)->lmPart );
		(__ref3)->lmPartList = (__ref4)->lmPartList;
	

#line 4322 "rlparse.cpp"
} break;
case 39: {
Parser_Lel_lm_part_list *__ref0 = (Parser_Lel_lm_part_list*)&redLel->user.lm_part_list;
Parser_Lel_longest_match_part *__ref1 = (Parser_Lel_longest_match_part*)&rhs[0]->user.longest_match_part;
Parser_Lel_lm_part_list *__ref2 = (Parser_Lel_lm_part_list*)&redLel->user.lm_part_list;
Parser_Lel_longest_match_part *__ref3 = (Parser_Lel_longest_match_part*)&rhs[0]->user.longest_match_part;
#line 277 "rlparse.kl"

		/* Create a new list with the part. */
		(__ref0)->lmPartList = new LmPartList;
		if ( (__ref1)->lmPart != 0 )
			(__ref2)->lmPartList->append( (__ref3)->lmPart );
	

#line 4337 "rlparse.cpp"
} break;
case 40: {
Parser_Lel_longest_match_part *__ref0 = (Parser_Lel_longest_match_part*)&redLel->user.longest_match_part;
#line 290 "rlparse.kl"
 (__ref0)->lmPart = 0; 

#line 4344 "rlparse.cpp"
} break;
case 41: {
Parser_Lel_longest_match_part *__ref0 = (Parser_Lel_longest_match_part*)&redLel->user.longest_match_part;
#line 292 "rlparse.kl"
 (__ref0)->lmPart = 0; 

#line 4351 "rlparse.cpp"
} break;
case 42: {
Parser_Lel_longest_match_part *__ref0 = (Parser_Lel_longest_match_part*)&redLel->user.longest_match_part;
Parser_Lel_opt_lm_part_action *__ref1 = (Parser_Lel_opt_lm_part_action*)&rhs[1]->user.opt_lm_part_action;
Parser_Lel_longest_match_part *__ref2 = (Parser_Lel_longest_match_part*)&redLel->user.longest_match_part;
Parser_Lel_join *__ref3 = (Parser_Lel_join*)&rhs[0]->user.join;
Token *__ref4 = (Token*)&rhs[2]->user.token;
Parser_Lel_join *__ref5 = (Parser_Lel_join*)&rhs[0]->user.join;
Token *__ref6 = (Token*)&rhs[2]->user.token;
#line 294 "rlparse.kl"

		(__ref0)->lmPart = 0;
		Action *action = (__ref1)->action;
		if ( action != 0 )
			action->isLmAction = true;
		(__ref2)->lmPart = new LongestMatchPart( (__ref3)->join, action, 
				(__ref4)->loc, pd->nextLongestMatchId++ );

		/* Provide a location to join. Unfortunately We don't
		 * have the start of the join as in other occurances. Use the end. */
		(__ref5)->join->loc = (__ref6)->loc;
	

#line 4375 "rlparse.cpp"
} break;
case 43: {
Parser_Lel_opt_lm_part_action *__ref0 = (Parser_Lel_opt_lm_part_action*)&redLel->user.opt_lm_part_action;
Parser_Lel_action_ref *__ref1 = (Parser_Lel_action_ref*)&rhs[1]->user.action_ref;
#line 313 "rlparse.kl"
 
		(__ref0)->action = (__ref1)->action;
	

#line 4385 "rlparse.cpp"
} break;
case 44: {
Parser_Lel_opt_lm_part_action *__ref0 = (Parser_Lel_opt_lm_part_action*)&redLel->user.opt_lm_part_action;
Parser_Lel_action_ref *__ref1 = (Parser_Lel_action_ref*)&rhs[0]->user.action_ref;
#line 317 "rlparse.kl"

		(__ref0)->action = (__ref1)->action;
	

#line 4395 "rlparse.cpp"
} break;
case 45: {
Parser_Lel_opt_lm_part_action *__ref0 = (Parser_Lel_opt_lm_part_action*)&redLel->user.opt_lm_part_action;
#line 321 "rlparse.kl"

		(__ref0)->action = 0;
	

#line 4404 "rlparse.cpp"
} break;
case 46: {
Parser_Lel_join *__ref0 = (Parser_Lel_join*)&rhs[0]->user.join;
Parser_Lel_expression *__ref1 = (Parser_Lel_expression*)&rhs[2]->user.expression;
Parser_Lel_join *__ref2 = (Parser_Lel_join*)&redLel->user.join;
Parser_Lel_join *__ref3 = (Parser_Lel_join*)&rhs[0]->user.join;
#line 332 "rlparse.kl"

		/* Append the expression to the list and return it. */
		(__ref0)->join->exprList.append( (__ref1)->expression );
		(__ref2)->join = (__ref3)->join;
	

#line 4418 "rlparse.cpp"
} break;
case 47: {
Parser_Lel_join *__ref0 = (Parser_Lel_join*)&redLel->user.join;
Parser_Lel_expression *__ref1 = (Parser_Lel_expression*)&rhs[0]->user.expression;
#line 338 "rlparse.kl"

		(__ref0)->join = new Join( (__ref1)->expression );
	

#line 4428 "rlparse.cpp"
} break;
case 48: {
Parser_Lel_expression *__ref0 = (Parser_Lel_expression*)&redLel->user.expression;
Parser_Lel_expression *__ref1 = (Parser_Lel_expression*)&rhs[0]->user.expression;
Parser_Lel_term_short *__ref2 = (Parser_Lel_term_short*)&rhs[2]->user.term_short;
#line 348 "rlparse.kl"

		(__ref0)->expression = new Expression( (__ref1)->expression, 
				(__ref2)->term, Expression::OrType );
	

#line 4440 "rlparse.cpp"
} break;
case 49: {
Parser_Lel_expression *__ref0 = (Parser_Lel_expression*)&redLel->user.expression;
Parser_Lel_expression *__ref1 = (Parser_Lel_expression*)&rhs[0]->user.expression;
Parser_Lel_term_short *__ref2 = (Parser_Lel_term_short*)&rhs[2]->user.term_short;
#line 353 "rlparse.kl"

		(__ref0)->expression = new Expression( (__ref1)->expression, 
				(__ref2)->term, Expression::IntersectType );
	

#line 4452 "rlparse.cpp"
} break;
case 50: {
Parser_Lel_expression *__ref0 = (Parser_Lel_expression*)&redLel->user.expression;
Parser_Lel_expression *__ref1 = (Parser_Lel_expression*)&rhs[0]->user.expression;
Parser_Lel_term_short *__ref2 = (Parser_Lel_term_short*)&rhs[2]->user.term_short;
#line 358 "rlparse.kl"

		(__ref0)->expression = new Expression( (__ref1)->expression, 
				(__ref2)->term, Expression::SubtractType );
	

#line 4464 "rlparse.cpp"
} break;
case 51: {
Parser_Lel_expression *__ref0 = (Parser_Lel_expression*)&redLel->user.expression;
Parser_Lel_expression *__ref1 = (Parser_Lel_expression*)&rhs[0]->user.expression;
Parser_Lel_term_short *__ref2 = (Parser_Lel_term_short*)&rhs[2]->user.term_short;
#line 363 "rlparse.kl"

		(__ref0)->expression = new Expression( (__ref1)->expression, 
				(__ref2)->term, Expression::StrongSubtractType );
	

#line 4476 "rlparse.cpp"
} break;
case 52: {
Parser_Lel_expression *__ref0 = (Parser_Lel_expression*)&redLel->user.expression;
Parser_Lel_term_short *__ref1 = (Parser_Lel_term_short*)&rhs[0]->user.term_short;
#line 368 "rlparse.kl"

		(__ref0)->expression = new Expression( (__ref1)->term );
	

#line 4486 "rlparse.cpp"
} break;
case 53: {
Parser_Lel_term_short *__ref0 = (Parser_Lel_term_short*)&redLel->user.term_short;
Parser_Lel_term *__ref1 = (Parser_Lel_term*)&rhs[0]->user.term;
#line 389 "rlparse.kl"

		(__ref0)->term = (__ref1)->term;
	

#line 4496 "rlparse.cpp"
} break;
case 54: {
Parser_Lel_term *__ref0 = (Parser_Lel_term*)&redLel->user.term;
Parser_Lel_term *__ref1 = (Parser_Lel_term*)&rhs[0]->user.term;
Parser_Lel_factor_with_label *__ref2 = (Parser_Lel_factor_with_label*)&rhs[1]->user.factor_with_label;
#line 399 "rlparse.kl"

		(__ref0)->term = new Term( (__ref1)->term, (__ref2)->factorWithAug );
	

#line 4507 "rlparse.cpp"
} break;
case 55: {
Parser_Lel_term *__ref0 = (Parser_Lel_term*)&redLel->user.term;
Parser_Lel_term *__ref1 = (Parser_Lel_term*)&rhs[0]->user.term;
Parser_Lel_factor_with_label *__ref2 = (Parser_Lel_factor_with_label*)&rhs[2]->user.factor_with_label;
#line 403 "rlparse.kl"

		(__ref0)->term = new Term( (__ref1)->term, (__ref2)->factorWithAug );
	

#line 4518 "rlparse.cpp"
} break;
case 56: {
Parser_Lel_term *__ref0 = (Parser_Lel_term*)&redLel->user.term;
Parser_Lel_term *__ref1 = (Parser_Lel_term*)&rhs[0]->user.term;
Parser_Lel_factor_with_label *__ref2 = (Parser_Lel_factor_with_label*)&rhs[2]->user.factor_with_label;
#line 407 "rlparse.kl"

		(__ref0)->term = new Term( (__ref1)->term, (__ref2)->factorWithAug, Term::RightStartType );
	

#line 4529 "rlparse.cpp"
} break;
case 57: {
Parser_Lel_term *__ref0 = (Parser_Lel_term*)&redLel->user.term;
Parser_Lel_term *__ref1 = (Parser_Lel_term*)&rhs[0]->user.term;
Parser_Lel_factor_with_label *__ref2 = (Parser_Lel_factor_with_label*)&rhs[2]->user.factor_with_label;
#line 411 "rlparse.kl"

		(__ref0)->term = new Term( (__ref1)->term, (__ref2)->factorWithAug, Term::RightFinishType );
	

#line 4540 "rlparse.cpp"
} break;
case 58: {
Parser_Lel_term *__ref0 = (Parser_Lel_term*)&redLel->user.term;
Parser_Lel_term *__ref1 = (Parser_Lel_term*)&rhs[0]->user.term;
Parser_Lel_factor_with_label *__ref2 = (Parser_Lel_factor_with_label*)&rhs[2]->user.factor_with_label;
#line 415 "rlparse.kl"

		(__ref0)->term = new Term( (__ref1)->term, 
				(__ref2)->factorWithAug, Term::LeftType );
	

#line 4552 "rlparse.cpp"
} break;
case 59: {
Parser_Lel_term *__ref0 = (Parser_Lel_term*)&redLel->user.term;
Parser_Lel_factor_with_label *__ref1 = (Parser_Lel_factor_with_label*)&rhs[0]->user.factor_with_label;
#line 420 "rlparse.kl"

		(__ref0)->term = new Term( (__ref1)->factorWithAug );
	

#line 4562 "rlparse.cpp"
} break;
case 60: {
Parser_Lel_factor_with_label *__ref0 = (Parser_Lel_factor_with_label*)&rhs[2]->user.factor_with_label;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Parser_Lel_factor_with_label *__ref3 = (Parser_Lel_factor_with_label*)&redLel->user.factor_with_label;
Parser_Lel_factor_with_label *__ref4 = (Parser_Lel_factor_with_label*)&rhs[2]->user.factor_with_label;
#line 430 "rlparse.kl"
 
		/* Add the label to the list and pass the factor up. */
		(__ref0)->factorWithAug->labels.prepend( Label((__ref1)->loc, (__ref2)->data) );
		(__ref3)->factorWithAug = (__ref4)->factorWithAug; 
	

#line 4577 "rlparse.cpp"
} break;
case 61: {
Parser_Lel_factor_with_label *__ref0 = (Parser_Lel_factor_with_label*)&redLel->user.factor_with_label;
Parser_Lel_factor_with_ep *__ref1 = (Parser_Lel_factor_with_ep*)&rhs[0]->user.factor_with_ep;
#line 436 "rlparse.kl"

		(__ref0)->factorWithAug = (__ref1)->factorWithAug;
	

#line 4587 "rlparse.cpp"
} break;
case 62: {
Parser_Lel_factor_with_ep *__ref0 = (Parser_Lel_factor_with_ep*)&rhs[0]->user.factor_with_ep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_ep *__ref2 = (Parser_Lel_factor_with_ep*)&redLel->user.factor_with_ep;
Parser_Lel_factor_with_ep *__ref3 = (Parser_Lel_factor_with_ep*)&rhs[0]->user.factor_with_ep;
#line 446 "rlparse.kl"
 
		/* Add the target to the list and return the factor object. */
		(__ref0)->factorWithAug->epsilonLinks.append( EpsilonLink( (__ref1)->loc, nameRef ) );
		(__ref2)->factorWithAug = (__ref3)->factorWithAug; 
	

#line 4601 "rlparse.cpp"
} break;
case 63: {
Parser_Lel_factor_with_ep *__ref0 = (Parser_Lel_factor_with_ep*)&redLel->user.factor_with_ep;
Parser_Lel_factor_with_aug *__ref1 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 452 "rlparse.kl"

		(__ref0)->factorWithAug = (__ref1)->factorWithAug;
	

#line 4611 "rlparse.cpp"
} break;
case 64: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[2]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 462 "rlparse.kl"

		/* Append the action to the factorWithAug, record the refernce from 
		 * factorWithAug to the action and pass up the factorWithAug. */
		(__ref0)->factorWithAug->actions.append( 
				ParserAction( (__ref1)->loc, (__ref2)->augType, 0, (__ref3)->action ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4629 "rlparse.cpp"
} break;
case 65: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_priority_aug *__ref2 = (Parser_Lel_priority_aug*)&rhs[2]->user.priority_aug;
Parser_Lel_factor_with_aug *__ref3 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 470 "rlparse.kl"

		/* Append the named priority to the factorWithAug and pass it up. */
		(__ref0)->factorWithAug->priorityAugs.append( 
				PriorityAug( (__ref1)->augType, pd->curDefPriorKey, (__ref2)->priorityNum ) );
		(__ref3)->factorWithAug = (__ref4)->factorWithAug;
	

#line 4645 "rlparse.cpp"
} break;
case 66: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_priority_name *__ref2 = (Parser_Lel_priority_name*)&rhs[3]->user.priority_name;
Parser_Lel_priority_aug *__ref3 = (Parser_Lel_priority_aug*)&rhs[5]->user.priority_aug;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 477 "rlparse.kl"

		/* Append the priority using a default name. */
		(__ref0)->factorWithAug->priorityAugs.append( 
				PriorityAug( (__ref1)->augType, (__ref2)->priorityName, (__ref3)->priorityNum ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4662 "rlparse.cpp"
} break;
case 67: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[2]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 484 "rlparse.kl"

		(__ref0)->factorWithAug->conditions.append( ConditionTest( (__ref1)->loc, 
				(__ref2)->augType, (__ref3)->action, true ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4678 "rlparse.cpp"
} break;
case 68: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[3]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 490 "rlparse.kl"

		(__ref0)->factorWithAug->conditions.append( ConditionTest( (__ref1)->loc, 
				(__ref2)->augType, (__ref3)->action, false ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4694 "rlparse.cpp"
} break;
case 69: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[2]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 496 "rlparse.kl"

		/* Append the action, pass it up. */
		(__ref0)->factorWithAug->actions.append( ParserAction( (__ref1)->loc, 
				(__ref2)->augType, 0, (__ref3)->action ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4711 "rlparse.cpp"
} break;
case 70: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[2]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 503 "rlparse.kl"

		/* Append the action, pass it up. */
		(__ref0)->factorWithAug->actions.append( ParserAction( (__ref1)->loc,
				(__ref2)->augType, 0, (__ref3)->action ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4728 "rlparse.cpp"
} break;
case 71: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[2]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 510 "rlparse.kl"

		/* Append the action, pass it up. */
		(__ref0)->factorWithAug->actions.append( ParserAction( (__ref1)->loc,
				(__ref2)->augType, 0, (__ref3)->action ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4745 "rlparse.cpp"
} break;
case 72: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[2]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 517 "rlparse.kl"

		/* Append the action to the factorWithAug, record the refernce from 
		 * factorWithAug to the action and pass up the factorWithAug. */
		(__ref0)->factorWithAug->actions.append( ParserAction( (__ref1)->loc,
				(__ref2)->augType, pd->curDefLocalErrKey, (__ref3)->action ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4763 "rlparse.cpp"
} break;
case 73: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_action_ref *__ref3 = (Parser_Lel_action_ref*)&rhs[2]->user.action_ref;
Parser_Lel_factor_with_aug *__ref4 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 525 "rlparse.kl"

		/* Append the action to the factorWithAug, record the refernce from 
		 * factorWithAug to the action and pass up the factorWithAug. */
		(__ref0)->factorWithAug->actions.append( ParserAction( (__ref1)->loc, 
				(__ref2)->augType, pd->curDefLocalErrKey, (__ref3)->action ) );
		(__ref4)->factorWithAug = (__ref5)->factorWithAug;
	

#line 4781 "rlparse.cpp"
} break;
case 74: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
Parser_Lel_aug_type *__ref1 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&rhs[1]->user.aug_type;
Parser_Lel_local_err_name *__ref3 = (Parser_Lel_local_err_name*)&rhs[3]->user.local_err_name;
Parser_Lel_action_ref *__ref4 = (Parser_Lel_action_ref*)&rhs[5]->user.action_ref;
Parser_Lel_factor_with_aug *__ref5 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_aug *__ref6 = (Parser_Lel_factor_with_aug*)&rhs[0]->user.factor_with_aug;
#line 533 "rlparse.kl"

		/* Append the action to the factorWithAug, record the refernce from
		 * factorWithAug to the action and pass up the factorWithAug. */
		(__ref0)->factorWithAug->actions.append( ParserAction( (__ref1)->loc,
				(__ref2)->augType, (__ref3)->error_name, (__ref4)->action ) );
		(__ref5)->factorWithAug = (__ref6)->factorWithAug;
	

#line 4800 "rlparse.cpp"
} break;
case 75: {
Parser_Lel_factor_with_aug *__ref0 = (Parser_Lel_factor_with_aug*)&redLel->user.factor_with_aug;
Parser_Lel_factor_with_rep *__ref1 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
#line 541 "rlparse.kl"

		(__ref0)->factorWithAug = new FactorWithAug( (__ref1)->factorWithRep );
	

#line 4810 "rlparse.cpp"
} break;
case 76: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 554 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_finish; 

#line 4819 "rlparse.cpp"
} break;
case 77: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 555 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_leave; 

#line 4828 "rlparse.cpp"
} break;
case 78: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 556 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all; 

#line 4837 "rlparse.cpp"
} break;
case 79: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 557 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start; 

#line 4846 "rlparse.cpp"
} break;
case 80: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 562 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start; 

#line 4855 "rlparse.cpp"
} break;
case 81: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 563 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start; 

#line 4864 "rlparse.cpp"
} break;
case 82: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 564 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all; 

#line 4873 "rlparse.cpp"
} break;
case 83: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 565 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all; 

#line 4882 "rlparse.cpp"
} break;
case 84: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 566 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_leave; 

#line 4891 "rlparse.cpp"
} break;
case 85: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 567 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_leave; 

#line 4900 "rlparse.cpp"
} break;
case 86: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 568 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all; 

#line 4909 "rlparse.cpp"
} break;
case 87: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 569 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start; 

#line 4918 "rlparse.cpp"
} break;
case 88: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 570 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_leave; 

#line 4927 "rlparse.cpp"
} break;
case 89: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 579 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_to_state; 

#line 4936 "rlparse.cpp"
} break;
case 90: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 581 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_to_state; 

#line 4945 "rlparse.cpp"
} break;
case 91: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 584 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_to_state; 

#line 4954 "rlparse.cpp"
} break;
case 92: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 586 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_to_state; 

#line 4963 "rlparse.cpp"
} break;
case 93: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 589 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_to_state; 

#line 4972 "rlparse.cpp"
} break;
case 94: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 591 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_to_state; 

#line 4981 "rlparse.cpp"
} break;
case 95: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 594 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_to_state; 

#line 4990 "rlparse.cpp"
} break;
case 96: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 596 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_to_state; 

#line 4999 "rlparse.cpp"
} break;
case 97: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 599 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_to_state; 

#line 5008 "rlparse.cpp"
} break;
case 98: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 601 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_to_state; 

#line 5017 "rlparse.cpp"
} break;
case 99: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 604 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_to_state; 

#line 5026 "rlparse.cpp"
} break;
case 100: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 606 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_to_state; 

#line 5035 "rlparse.cpp"
} break;
case 101: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 615 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_from_state; 

#line 5044 "rlparse.cpp"
} break;
case 102: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 617 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_from_state; 

#line 5053 "rlparse.cpp"
} break;
case 103: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 620 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_from_state; 

#line 5062 "rlparse.cpp"
} break;
case 104: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 622 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_from_state; 

#line 5071 "rlparse.cpp"
} break;
case 105: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 625 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_from_state; 

#line 5080 "rlparse.cpp"
} break;
case 106: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 627 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_from_state; 

#line 5089 "rlparse.cpp"
} break;
case 107: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 630 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_from_state; 

#line 5098 "rlparse.cpp"
} break;
case 108: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 632 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_from_state; 

#line 5107 "rlparse.cpp"
} break;
case 109: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 635 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_from_state; 

#line 5116 "rlparse.cpp"
} break;
case 110: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 637 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_from_state; 

#line 5125 "rlparse.cpp"
} break;
case 111: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 640 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_from_state; 

#line 5134 "rlparse.cpp"
} break;
case 112: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 642 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_from_state; 

#line 5143 "rlparse.cpp"
} break;
case 113: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 651 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_eof; 

#line 5152 "rlparse.cpp"
} break;
case 114: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 653 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_eof; 

#line 5161 "rlparse.cpp"
} break;
case 115: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 656 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_eof; 

#line 5170 "rlparse.cpp"
} break;
case 116: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 658 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_eof; 

#line 5179 "rlparse.cpp"
} break;
case 117: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 661 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_eof; 

#line 5188 "rlparse.cpp"
} break;
case 118: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 663 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_eof; 

#line 5197 "rlparse.cpp"
} break;
case 119: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 666 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_eof; 

#line 5206 "rlparse.cpp"
} break;
case 120: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 668 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_eof; 

#line 5215 "rlparse.cpp"
} break;
case 121: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 671 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_eof; 

#line 5224 "rlparse.cpp"
} break;
case 122: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 673 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_eof; 

#line 5233 "rlparse.cpp"
} break;
case 123: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 676 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_eof; 

#line 5242 "rlparse.cpp"
} break;
case 124: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 678 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_eof; 

#line 5251 "rlparse.cpp"
} break;
case 125: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 687 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_gbl_error; 

#line 5260 "rlparse.cpp"
} break;
case 126: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 689 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_gbl_error; 

#line 5269 "rlparse.cpp"
} break;
case 127: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 692 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_gbl_error; 

#line 5278 "rlparse.cpp"
} break;
case 128: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 694 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_gbl_error; 

#line 5287 "rlparse.cpp"
} break;
case 129: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 697 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_gbl_error; 

#line 5296 "rlparse.cpp"
} break;
case 130: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 699 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_gbl_error; 

#line 5305 "rlparse.cpp"
} break;
case 131: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 702 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_gbl_error; 

#line 5314 "rlparse.cpp"
} break;
case 132: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 704 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_gbl_error; 

#line 5323 "rlparse.cpp"
} break;
case 133: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 707 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_gbl_error; 

#line 5332 "rlparse.cpp"
} break;
case 134: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 709 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_gbl_error; 

#line 5341 "rlparse.cpp"
} break;
case 135: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 712 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_gbl_error; 

#line 5350 "rlparse.cpp"
} break;
case 136: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 714 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_gbl_error; 

#line 5359 "rlparse.cpp"
} break;
case 137: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 724 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_local_error; 

#line 5368 "rlparse.cpp"
} break;
case 138: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 726 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_start_local_error; 

#line 5377 "rlparse.cpp"
} break;
case 139: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 729 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_local_error; 

#line 5386 "rlparse.cpp"
} break;
case 140: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 731 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_start_local_error; 

#line 5395 "rlparse.cpp"
} break;
case 141: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 734 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_local_error; 

#line 5404 "rlparse.cpp"
} break;
case 142: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 736 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_all_local_error; 

#line 5413 "rlparse.cpp"
} break;
case 143: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 739 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_local_error; 

#line 5422 "rlparse.cpp"
} break;
case 144: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 741 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_final_local_error; 

#line 5431 "rlparse.cpp"
} break;
case 145: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 744 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_local_error; 

#line 5440 "rlparse.cpp"
} break;
case 146: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 746 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_not_final_local_error; 

#line 5449 "rlparse.cpp"
} break;
case 147: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 749 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_local_error; 

#line 5458 "rlparse.cpp"
} break;
case 148: {
Parser_Lel_aug_type *__ref0 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_aug_type *__ref2 = (Parser_Lel_aug_type*)&redLel->user.aug_type;
#line 751 "rlparse.kl"
 (__ref0)->loc = (__ref1)->loc; (__ref2)->augType = at_middle_local_error; 

#line 5467 "rlparse.cpp"
} break;
case 149: {
Parser_Lel_action_ref *__ref0 = (Parser_Lel_action_ref*)&redLel->user.action_ref;
Parser_Lel_action_ref *__ref1 = (Parser_Lel_action_ref*)&rhs[0]->user.action_ref;
#line 764 "rlparse.kl"
 (__ref0)->action = (__ref1)->action; 

#line 5475 "rlparse.cpp"
} break;
case 150: {
Parser_Lel_action_ref *__ref0 = (Parser_Lel_action_ref*)&redLel->user.action_ref;
Parser_Lel_action_ref *__ref1 = (Parser_Lel_action_ref*)&rhs[1]->user.action_ref;
#line 765 "rlparse.kl"
 (__ref0)->action = (__ref1)->action; 

#line 5483 "rlparse.cpp"
} break;
case 151: {
Parser_Lel_action_ref *__ref0 = (Parser_Lel_action_ref*)&redLel->user.action_ref;
Parser_Lel_action_ref *__ref1 = (Parser_Lel_action_ref*)&rhs[0]->user.action_ref;
#line 766 "rlparse.kl"
 (__ref0)->action = (__ref1)->action; 

#line 5491 "rlparse.cpp"
} break;
case 152: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Parser_Lel_action_ref *__ref1 = (Parser_Lel_action_ref*)&redLel->user.action_ref;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Token *__ref3 = (Token*)&rhs[0]->user.token;
Parser_Lel_action_ref *__ref4 = (Parser_Lel_action_ref*)&redLel->user.action_ref;
#line 771 "rlparse.kl"

		/* Set the name in the actionDict. */
		Action *action = pd->actionDict.find( (__ref0)->data );
		if ( action != 0 ) {
			/* Pass up the action element */
			(__ref1)->action = action;
		}
		else {
			/* Will recover by returning null as the action. */
			error((__ref2)->loc) << "action lookup of \"" << (__ref3)->data << "\" failed" << endl;
			(__ref4)->action = 0;
		}
	

#line 5514 "rlparse.cpp"
} break;
case 153: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Parser_Lel_inline_list *__ref1 = (Parser_Lel_inline_list*)&rhs[1]->user.inline_list;
Parser_Lel_action_ref *__ref2 = (Parser_Lel_action_ref*)&redLel->user.action_ref;
#line 788 "rlparse.kl"

		/* Create the action, add it to the list and pass up. */
		Action *newAction = new Action( (__ref0)->loc, 0, (__ref1)->inlineList, pd->nextCondId++ );
		pd->actionList.append( newAction );
		(__ref2)->action = newAction;
	

#line 5528 "rlparse.cpp"
} break;
case 154: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Parser_Lel_priority_name *__ref1 = (Parser_Lel_priority_name*)&redLel->user.priority_name;
#line 803 "rlparse.kl"

		// Lookup/create the priority key.
		PriorDictEl *priorDictEl;
		if ( pd->priorDict.insert( (__ref0)->data, pd->nextPriorKey, &priorDictEl ) )
			pd->nextPriorKey += 1;

		// Use the inserted/found priority key.
		(__ref1)->priorityName = priorDictEl->value;
	

#line 5544 "rlparse.cpp"
} break;
case 155: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_token_type *__ref2 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_priority_aug *__ref3 = (Parser_Lel_priority_aug*)&redLel->user.priority_aug;
Parser_Lel_token_type *__ref4 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_token_type *__ref5 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_priority_aug *__ref6 = (Parser_Lel_priority_aug*)&redLel->user.priority_aug;
Parser_Lel_priority_aug *__ref7 = (Parser_Lel_priority_aug*)&redLel->user.priority_aug;
#line 820 "rlparse.kl"

		// Convert the priority number to a long. Check for overflow.
		errno = 0;
		//cerr << "PRIOR AUG: " << $1->token.data << endl;
		long aug = strtol( (__ref0)->token.data, 0, 10 );
		if ( errno == ERANGE && aug == LONG_MAX ) {
			/* Priority number too large. Recover by setting the priority to 0. */
			error((__ref1)->token.loc) << "priority number " << (__ref2)->token.data << 
					" overflows" << endl;
			(__ref3)->priorityNum = 0;
		}
		else if ( errno == ERANGE && aug == LONG_MIN ) {
			/* Priority number too large in the neg. Recover by using 0. */
			error((__ref4)->token.loc) << "priority number " << (__ref5)->token.data << 
					" underflows" << endl;
			(__ref6)->priorityNum = 0;
		}
		else {
			/* No overflow or underflow. */
			(__ref7)->priorityNum = aug;
		}
	

#line 5579 "rlparse.cpp"
} break;
case 156: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 846 "rlparse.kl"

		(__ref0)->token = *(__ref1);
	

#line 5589 "rlparse.cpp"
} break;
case 157: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Parser_Lel_token_type *__ref3 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref4 = (Token*)&rhs[1]->user.token;
#line 850 "rlparse.kl"

		(__ref0)->token.set( "+", 1 );
		(__ref1)->token.loc = (__ref2)->loc;
		(__ref3)->token.append( *(__ref4) );
	

#line 5604 "rlparse.cpp"
} break;
case 158: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Parser_Lel_token_type *__ref3 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref4 = (Token*)&rhs[1]->user.token;
#line 856 "rlparse.kl"

		(__ref0)->token.set( "-", 1 );
		(__ref1)->token.loc = (__ref2)->loc;
		(__ref3)->token.append( *(__ref4) );
	

#line 5619 "rlparse.cpp"
} break;
case 159: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Parser_Lel_local_err_name *__ref1 = (Parser_Lel_local_err_name*)&redLel->user.local_err_name;
#line 868 "rlparse.kl"

		/* Lookup/create the priority key. */
		LocalErrDictEl *localErrDictEl;
		if ( pd->localErrDict.insert( (__ref0)->data, pd->nextLocalErrKey, &localErrDictEl ) )
			pd->nextLocalErrKey += 1;

		/* Use the inserted/found priority key. */
		(__ref1)->error_name = localErrDictEl->value;
	

#line 5635 "rlparse.cpp"
} break;
case 160: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
#line 889 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep, 
				0, 0, FactorWithRep::StarType );
	

#line 5647 "rlparse.cpp"
} break;
case 161: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
#line 894 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep, 
				0, 0, FactorWithRep::StarStarType );
	

#line 5659 "rlparse.cpp"
} break;
case 162: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
#line 899 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep, 
				0, 0, FactorWithRep::OptionalType );
	

#line 5671 "rlparse.cpp"
} break;
case 163: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
#line 904 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep, 
				0, 0, FactorWithRep::PlusType );
	

#line 5683 "rlparse.cpp"
} break;
case 164: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
Parser_Lel_factor_rep_num *__ref3 = (Parser_Lel_factor_rep_num*)&rhs[2]->user.factor_rep_num;
#line 909 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep, 
				(__ref3)->rep, 0, FactorWithRep::ExactType );
	

#line 5696 "rlparse.cpp"
} break;
case 165: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
Parser_Lel_factor_rep_num *__ref3 = (Parser_Lel_factor_rep_num*)&rhs[3]->user.factor_rep_num;
#line 914 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep, 
				0, (__ref3)->rep, FactorWithRep::MaxType );
	

#line 5709 "rlparse.cpp"
} break;
case 166: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
Parser_Lel_factor_rep_num *__ref3 = (Parser_Lel_factor_rep_num*)&rhs[2]->user.factor_rep_num;
#line 919 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep,
				(__ref3)->rep, 0, FactorWithRep::MinType );
	

#line 5722 "rlparse.cpp"
} break;
case 167: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Parser_Lel_factor_with_rep *__ref2 = (Parser_Lel_factor_with_rep*)&rhs[0]->user.factor_with_rep;
Parser_Lel_factor_rep_num *__ref3 = (Parser_Lel_factor_rep_num*)&rhs[2]->user.factor_rep_num;
Parser_Lel_factor_rep_num *__ref4 = (Parser_Lel_factor_rep_num*)&rhs[4]->user.factor_rep_num;
#line 924 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->loc, (__ref2)->factorWithRep, 
				(__ref3)->rep, (__ref4)->rep, FactorWithRep::RangeType );
	

#line 5736 "rlparse.cpp"
} break;
case 168: {
Parser_Lel_factor_with_rep *__ref0 = (Parser_Lel_factor_with_rep*)&redLel->user.factor_with_rep;
Parser_Lel_factor_with_neg *__ref1 = (Parser_Lel_factor_with_neg*)&rhs[0]->user.factor_with_neg;
#line 929 "rlparse.kl"

		(__ref0)->factorWithRep = new FactorWithRep( (__ref1)->factorWithNeg );
	

#line 5746 "rlparse.cpp"
} break;
case 169: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Parser_Lel_factor_rep_num *__ref3 = (Parser_Lel_factor_rep_num*)&redLel->user.factor_rep_num;
Parser_Lel_factor_rep_num *__ref4 = (Parser_Lel_factor_rep_num*)&redLel->user.factor_rep_num;
#line 939 "rlparse.kl"

		// Convert the priority number to a long. Check for overflow.
		errno = 0;
		long rep = strtol( (__ref0)->data, 0, 10 );
		if ( errno == ERANGE && rep == LONG_MAX ) {
			// Repetition too large. Recover by returing repetition 1. */
			error((__ref1)->loc) << "repetition number " << (__ref2)->data << " overflows" << endl;
			(__ref3)->rep = 1;
		}
		else {
			// Cannot be negative, so no overflow.
			(__ref4)->rep = rep;
 		}
	

#line 5770 "rlparse.cpp"
} break;
case 170: {
Parser_Lel_factor_with_neg *__ref0 = (Parser_Lel_factor_with_neg*)&redLel->user.factor_with_neg;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_factor_with_neg *__ref2 = (Parser_Lel_factor_with_neg*)&rhs[1]->user.factor_with_neg;
#line 965 "rlparse.kl"

		(__ref0)->factorWithNeg = new FactorWithNeg( (__ref1)->loc,
				(__ref2)->factorWithNeg, FactorWithNeg::NegateType );
	

#line 5782 "rlparse.cpp"
} break;
case 171: {
Parser_Lel_factor_with_neg *__ref0 = (Parser_Lel_factor_with_neg*)&redLel->user.factor_with_neg;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_factor_with_neg *__ref2 = (Parser_Lel_factor_with_neg*)&rhs[1]->user.factor_with_neg;
#line 970 "rlparse.kl"

		(__ref0)->factorWithNeg = new FactorWithNeg( (__ref1)->loc,
				(__ref2)->factorWithNeg, FactorWithNeg::CharNegateType );
	

#line 5794 "rlparse.cpp"
} break;
case 172: {
Parser_Lel_factor_with_neg *__ref0 = (Parser_Lel_factor_with_neg*)&redLel->user.factor_with_neg;
Parser_Lel_factor *__ref1 = (Parser_Lel_factor*)&rhs[0]->user.factor;
#line 975 "rlparse.kl"

		(__ref0)->factorWithNeg = new FactorWithNeg( (__ref1)->factor );
	

#line 5804 "rlparse.cpp"
} break;
case 173: {
Parser_Lel_factor *__ref0 = (Parser_Lel_factor*)&redLel->user.factor;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 985 "rlparse.kl"

		/* Create a new factor node going to a concat literal. */
		(__ref0)->factor = new Factor( new Literal( *(__ref1), Literal::LitString ) );
	

#line 5815 "rlparse.cpp"
} break;
case 174: {
Parser_Lel_factor *__ref0 = (Parser_Lel_factor*)&redLel->user.factor;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
#line 990 "rlparse.kl"

		/* Create a new factor node going to a literal number. */
		(__ref0)->factor = new Factor( new Literal( (__ref1)->token, Literal::Number ) );
	

#line 5826 "rlparse.cpp"
} break;
case 175: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Parser_Lel_factor *__ref3 = (Parser_Lel_factor*)&redLel->user.factor;
Token *__ref4 = (Token*)&rhs[0]->user.token;
Parser_Lel_factor *__ref5 = (Parser_Lel_factor*)&redLel->user.factor;
Parser_Lel_factor *__ref6 = (Parser_Lel_factor*)&redLel->user.factor;
Token *__ref7 = (Token*)&rhs[0]->user.token;
#line 995 "rlparse.kl"

		/* Find the named graph. */
		GraphDictEl *gdNode = pd->graphDict.find( (__ref0)->data );
		if ( gdNode == 0 ) {
			/* Recover by returning null as the factor node. */
			error((__ref1)->loc) << "graph lookup of \"" << (__ref2)->data << "\" failed" << endl;
			(__ref3)->factor = 0;
		}
		else if ( gdNode->isInstance ) {
			/* Recover by retuning null as the factor node. */
			error((__ref4)->loc) << "references to graph instantiations not allowed "
					"in expressions" << endl;
			(__ref5)->factor = 0;
		}
		else {
			/* Create a factor node that is a lookup of an expression. */
			(__ref6)->factor = new Factor( (__ref7)->loc, gdNode->value );
		}
	

#line 5858 "rlparse.cpp"
} break;
case 176: {
Parser_Lel_factor *__ref0 = (Parser_Lel_factor*)&redLel->user.factor;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_regular_expr_or_data *__ref2 = (Parser_Lel_regular_expr_or_data*)&rhs[1]->user.regular_expr_or_data;
#line 1015 "rlparse.kl"

		/* Create a new factor node going to an OR expression. */
		(__ref0)->factor = new Factor( new ReItem( (__ref1)->loc, (__ref2)->reOrBlock, ReItem::OrBlock ) );
	

#line 5870 "rlparse.cpp"
} break;
case 177: {
Parser_Lel_factor *__ref0 = (Parser_Lel_factor*)&redLel->user.factor;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_regular_expr_or_data *__ref2 = (Parser_Lel_regular_expr_or_data*)&rhs[1]->user.regular_expr_or_data;
#line 1020 "rlparse.kl"

		/* Create a new factor node going to a negated OR expression. */
		(__ref0)->factor = new Factor( new ReItem( (__ref1)->loc, (__ref2)->reOrBlock, ReItem::NegOrBlock ) );
	

#line 5882 "rlparse.cpp"
} break;
case 178: {
Token *__ref0 = (Token*)&rhs[2]->user.token;
Token *__ref1 = (Token*)&rhs[2]->user.token;
Parser_Lel_regular_expr *__ref2 = (Parser_Lel_regular_expr*)&rhs[1]->user.regular_expr;
Parser_Lel_factor *__ref3 = (Parser_Lel_factor*)&redLel->user.factor;
Parser_Lel_regular_expr *__ref4 = (Parser_Lel_regular_expr*)&rhs[1]->user.regular_expr;
#line 1025 "rlparse.kl"

		if ( (__ref0)->length > 1 ) {
			for ( char *p = (__ref1)->data; *p != 0; p++ ) {
				if ( *p == 'i' )
					(__ref2)->regExpr->caseInsensitive = true;
			}
		}

		/* Create a new factor node going to a regular exp. */
		(__ref3)->factor = new Factor( (__ref4)->regExpr );
	

#line 5903 "rlparse.cpp"
} break;
case 179: {
Parser_Lel_factor *__ref0 = (Parser_Lel_factor*)&redLel->user.factor;
Parser_Lel_range_lit *__ref1 = (Parser_Lel_range_lit*)&rhs[0]->user.range_lit;
Parser_Lel_range_lit *__ref2 = (Parser_Lel_range_lit*)&rhs[2]->user.range_lit;
#line 1037 "rlparse.kl"

		/* Create a new factor node going to a range. */
		(__ref0)->factor = new Factor( new Range( (__ref1)->literal, (__ref2)->literal ) );
	

#line 5915 "rlparse.cpp"
} break;
case 180: {
Parser_Lel_factor *__ref0 = (Parser_Lel_factor*)&redLel->user.factor;
Parser_Lel_join *__ref1 = (Parser_Lel_join*)&rhs[1]->user.join;
Parser_Lel_join *__ref2 = (Parser_Lel_join*)&rhs[1]->user.join;
Token *__ref3 = (Token*)&rhs[0]->user.token;
#line 1042 "rlparse.kl"

		/* Create a new factor going to a parenthesized join. */
		(__ref0)->factor = new Factor( (__ref1)->join );
		(__ref2)->join->loc = (__ref3)->loc;
	

#line 5929 "rlparse.cpp"
} break;
case 181: {
Parser_Lel_range_lit *__ref0 = (Parser_Lel_range_lit*)&redLel->user.range_lit;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1055 "rlparse.kl"

		/* Range literas must have only one char. We restrict this in the parse tree. */
		(__ref0)->literal = new Literal( *(__ref1), Literal::LitString );
	

#line 5940 "rlparse.cpp"
} break;
case 182: {
Parser_Lel_range_lit *__ref0 = (Parser_Lel_range_lit*)&redLel->user.range_lit;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
#line 1060 "rlparse.kl"

		/* Create a new literal number. */
		(__ref0)->literal = new Literal( (__ref1)->token, Literal::Number );
	

#line 5951 "rlparse.cpp"
} break;
case 183: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1069 "rlparse.kl"
 
		(__ref0)->token = *(__ref1);
	

#line 5961 "rlparse.cpp"
} break;
case 184: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Parser_Lel_token_type *__ref3 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref4 = (Token*)&rhs[1]->user.token;
#line 1073 "rlparse.kl"
 
		(__ref0)->token.set( "-", 1 );
		(__ref1)->token.loc = (__ref2)->loc;
		(__ref3)->token.append( *(__ref4) );
	

#line 5976 "rlparse.cpp"
} break;
case 185: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1079 "rlparse.kl"
 
		(__ref0)->token = *(__ref1);
	

#line 5986 "rlparse.cpp"
} break;
case 186: {
Parser_Lel_regular_expr_item *__ref0 = (Parser_Lel_regular_expr_item*)&rhs[1]->user.regular_expr_item;
Parser_Lel_regular_expr_item *__ref1 = (Parser_Lel_regular_expr_item*)&rhs[1]->user.regular_expr_item;
Parser_Lel_regular_expr *__ref2 = (Parser_Lel_regular_expr*)&rhs[0]->user.regular_expr;
Parser_Lel_regular_expr *__ref3 = (Parser_Lel_regular_expr*)&rhs[0]->user.regular_expr;
Parser_Lel_regular_expr *__ref4 = (Parser_Lel_regular_expr*)&rhs[0]->user.regular_expr;
Parser_Lel_regular_expr *__ref5 = (Parser_Lel_regular_expr*)&rhs[0]->user.regular_expr;
Parser_Lel_regular_expr_item *__ref6 = (Parser_Lel_regular_expr_item*)&rhs[1]->user.regular_expr_item;
Parser_Lel_regular_expr_item *__ref7 = (Parser_Lel_regular_expr_item*)&rhs[1]->user.regular_expr_item;
Parser_Lel_regular_expr *__ref8 = (Parser_Lel_regular_expr*)&redLel->user.regular_expr;
Parser_Lel_regular_expr *__ref9 = (Parser_Lel_regular_expr*)&rhs[0]->user.regular_expr;
Parser_Lel_regular_expr *__ref10 = (Parser_Lel_regular_expr*)&redLel->user.regular_expr;
Parser_Lel_regular_expr *__ref11 = (Parser_Lel_regular_expr*)&rhs[0]->user.regular_expr;
Parser_Lel_regular_expr_item *__ref12 = (Parser_Lel_regular_expr_item*)&rhs[1]->user.regular_expr_item;
#line 1094 "rlparse.kl"

		/* An optimization to lessen the tree size. If a non-starred char is
		 * directly under the left side on the right and the right side is
		 * another non-starred char then paste them together and return the
		 * left side. Otherwise just put the two under a new reg exp node. */
		if ( (__ref0)->reItem->type == ReItem::Data && !(__ref1)->reItem->star &&
			(__ref2)->regExpr->type == RegExpr::RecurseItem &&
			(__ref3)->regExpr->item->type == ReItem::Data && !(__ref4)->regExpr->item->star )
		{
			/* Append the right side to the right side of the left and toss the
			 * right side. */
			(__ref5)->regExpr->item->token.append( (__ref6)->reItem->token );
			delete (__ref7)->reItem;
			(__ref8)->regExpr = (__ref9)->regExpr;
		}
		else {
			(__ref10)->regExpr = new RegExpr( (__ref11)->regExpr, (__ref12)->reItem );
		}
	

#line 6023 "rlparse.cpp"
} break;
case 187: {
Parser_Lel_regular_expr *__ref0 = (Parser_Lel_regular_expr*)&redLel->user.regular_expr;
#line 1114 "rlparse.kl"

		/* Can't optimize the tree. */
		(__ref0)->regExpr = new RegExpr();
	

#line 6033 "rlparse.cpp"
} break;
case 188: {
Parser_Lel_regular_expr_char *__ref0 = (Parser_Lel_regular_expr_char*)&rhs[0]->user.regular_expr_char;
Parser_Lel_regular_expr_item *__ref1 = (Parser_Lel_regular_expr_item*)&redLel->user.regular_expr_item;
Parser_Lel_regular_expr_char *__ref2 = (Parser_Lel_regular_expr_char*)&rhs[0]->user.regular_expr_char;
#line 1126 "rlparse.kl"

		(__ref0)->reItem->star = true;
		(__ref1)->reItem = (__ref2)->reItem;
	

#line 6045 "rlparse.cpp"
} break;
case 189: {
Parser_Lel_regular_expr_item *__ref0 = (Parser_Lel_regular_expr_item*)&redLel->user.regular_expr_item;
Parser_Lel_regular_expr_char *__ref1 = (Parser_Lel_regular_expr_char*)&rhs[0]->user.regular_expr_char;
#line 1131 "rlparse.kl"

		(__ref0)->reItem = (__ref1)->reItem;
	

#line 6055 "rlparse.cpp"
} break;
case 190: {
Parser_Lel_regular_expr_char *__ref0 = (Parser_Lel_regular_expr_char*)&redLel->user.regular_expr_char;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_regular_expr_or_data *__ref2 = (Parser_Lel_regular_expr_or_data*)&rhs[1]->user.regular_expr_or_data;
#line 1143 "rlparse.kl"

		(__ref0)->reItem = new ReItem( (__ref1)->loc, (__ref2)->reOrBlock, ReItem::OrBlock );
	

#line 6066 "rlparse.cpp"
} break;
case 191: {
Parser_Lel_regular_expr_char *__ref0 = (Parser_Lel_regular_expr_char*)&redLel->user.regular_expr_char;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_regular_expr_or_data *__ref2 = (Parser_Lel_regular_expr_or_data*)&rhs[1]->user.regular_expr_or_data;
#line 1147 "rlparse.kl"

		(__ref0)->reItem = new ReItem( (__ref1)->loc, (__ref2)->reOrBlock, ReItem::NegOrBlock );
	

#line 6077 "rlparse.cpp"
} break;
case 192: {
Parser_Lel_regular_expr_char *__ref0 = (Parser_Lel_regular_expr_char*)&redLel->user.regular_expr_char;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1151 "rlparse.kl"

		(__ref0)->reItem = new ReItem( (__ref1)->loc, ReItem::Dot );
	

#line 6087 "rlparse.cpp"
} break;
case 193: {
Parser_Lel_regular_expr_char *__ref0 = (Parser_Lel_regular_expr_char*)&redLel->user.regular_expr_char;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Token *__ref2 = (Token*)&rhs[0]->user.token;
#line 1155 "rlparse.kl"

		(__ref0)->reItem = new ReItem( (__ref1)->loc, *(__ref2) );
	

#line 6098 "rlparse.cpp"
} break;
case 194: {
Parser_Lel_regular_expr_or_char *__ref0 = (Parser_Lel_regular_expr_or_char*)&rhs[1]->user.regular_expr_or_char;
Parser_Lel_regular_expr_or_data *__ref1 = (Parser_Lel_regular_expr_or_data*)&rhs[0]->user.regular_expr_or_data;
Parser_Lel_regular_expr_or_data *__ref2 = (Parser_Lel_regular_expr_or_data*)&rhs[0]->user.regular_expr_or_data;
Parser_Lel_regular_expr_or_data *__ref3 = (Parser_Lel_regular_expr_or_data*)&rhs[0]->user.regular_expr_or_data;
Parser_Lel_regular_expr_or_char *__ref4 = (Parser_Lel_regular_expr_or_char*)&rhs[1]->user.regular_expr_or_char;
Parser_Lel_regular_expr_or_char *__ref5 = (Parser_Lel_regular_expr_or_char*)&rhs[1]->user.regular_expr_or_char;
Parser_Lel_regular_expr_or_data *__ref6 = (Parser_Lel_regular_expr_or_data*)&redLel->user.regular_expr_or_data;
Parser_Lel_regular_expr_or_data *__ref7 = (Parser_Lel_regular_expr_or_data*)&rhs[0]->user.regular_expr_or_data;
Parser_Lel_regular_expr_or_data *__ref8 = (Parser_Lel_regular_expr_or_data*)&redLel->user.regular_expr_or_data;
Parser_Lel_regular_expr_or_data *__ref9 = (Parser_Lel_regular_expr_or_data*)&rhs[0]->user.regular_expr_or_data;
Parser_Lel_regular_expr_or_char *__ref10 = (Parser_Lel_regular_expr_or_char*)&rhs[1]->user.regular_expr_or_char;
#line 1167 "rlparse.kl"

		/* An optimization to lessen the tree size. If an or char is directly
		 * under the left side on the right and the right side is another or
		 * char then paste them together and return the left side. Otherwise
		 * just put the two under a new or data node. */
		if ( (__ref0)->reOrItem->type == ReOrItem::Data &&
				(__ref1)->reOrBlock->type == ReOrBlock::RecurseItem &&
				(__ref2)->reOrBlock->item->type == ReOrItem::Data )
		{
			/* Append the right side to right side of the left and toss the
			 * right side. */
			(__ref3)->reOrBlock->item->token.append( (__ref4)->reOrItem->token );
			delete (__ref5)->reOrItem;
			(__ref6)->reOrBlock = (__ref7)->reOrBlock;
		}
		else {
			/* Can't optimize, put the left and right under a new node. */
			(__ref8)->reOrBlock = new ReOrBlock( (__ref9)->reOrBlock, (__ref10)->reOrItem );
		}
	

#line 6134 "rlparse.cpp"
} break;
case 195: {
Parser_Lel_regular_expr_or_data *__ref0 = (Parser_Lel_regular_expr_or_data*)&redLel->user.regular_expr_or_data;
#line 1188 "rlparse.kl"

		(__ref0)->reOrBlock = new ReOrBlock();
	

#line 6143 "rlparse.cpp"
} break;
case 196: {
Parser_Lel_regular_expr_or_char *__ref0 = (Parser_Lel_regular_expr_or_char*)&redLel->user.regular_expr_or_char;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Token *__ref2 = (Token*)&rhs[0]->user.token;
#line 1200 "rlparse.kl"

		(__ref0)->reOrItem = new ReOrItem( (__ref1)->loc, *(__ref2) );
	

#line 6154 "rlparse.cpp"
} break;
case 197: {
Parser_Lel_regular_expr_or_char *__ref0 = (Parser_Lel_regular_expr_or_char*)&redLel->user.regular_expr_or_char;
Token *__ref1 = (Token*)&rhs[1]->user.token;
Token *__ref2 = (Token*)&rhs[0]->user.token;
Token *__ref3 = (Token*)&rhs[2]->user.token;
#line 1204 "rlparse.kl"

		(__ref0)->reOrItem = new ReOrItem( (__ref1)->loc, (__ref2)->data[0], (__ref3)->data[0] );
	

#line 6166 "rlparse.cpp"
} break;
case 198: {
Parser_Lel_inline_list *__ref0 = (Parser_Lel_inline_list*)&redLel->user.inline_list;
Parser_Lel_inline_list *__ref1 = (Parser_Lel_inline_list*)&rhs[0]->user.inline_list;
Parser_Lel_inline_list *__ref2 = (Parser_Lel_inline_list*)&redLel->user.inline_list;
Parser_Lel_inline_item *__ref3 = (Parser_Lel_inline_item*)&rhs[1]->user.inline_item;
#line 1221 "rlparse.kl"

		/* Append the item to the list, return the list. */
		(__ref0)->inlineList = (__ref1)->inlineList;
		(__ref2)->inlineList->append( (__ref3)->inlineItem );
	

#line 6180 "rlparse.cpp"
} break;
case 199: {
Parser_Lel_inline_list *__ref0 = (Parser_Lel_inline_list*)&redLel->user.inline_list;
#line 1228 "rlparse.kl"

		/* Start with empty list. */
		(__ref0)->inlineList = new InlineList;
	

#line 6190 "rlparse.cpp"
} break;
case 200: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_token_type *__ref2 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
#line 1243 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->token.loc, (__ref2)->token.data, InlineItem::Text );
	

#line 6201 "rlparse.cpp"
} break;
case 201: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_token_type *__ref2 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
#line 1249 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->token.loc, (__ref2)->token.data, InlineItem::Text );
	

#line 6212 "rlparse.cpp"
} break;
case 202: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_inline_item *__ref1 = (Parser_Lel_inline_item*)&rhs[0]->user.inline_item;
#line 1255 "rlparse.kl"

		/* Pass the inline item up. */
		(__ref0)->inlineItem = (__ref1)->inlineItem;
	

#line 6223 "rlparse.cpp"
} break;
case 203: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1262 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6231 "rlparse.cpp"
} break;
case 204: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1263 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6239 "rlparse.cpp"
} break;
case 205: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1264 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6247 "rlparse.cpp"
} break;
case 206: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1265 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6255 "rlparse.cpp"
} break;
case 207: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1266 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6263 "rlparse.cpp"
} break;
case 208: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1267 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6271 "rlparse.cpp"
} break;
case 209: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_inline_item *__ref1 = (Parser_Lel_inline_item*)&rhs[0]->user.inline_item;
#line 1271 "rlparse.kl"

		/* Pass up interpreted items of inline expressions. */
		(__ref0)->inlineItem = (__ref1)->inlineItem;
	

#line 6282 "rlparse.cpp"
} break;
case 210: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1276 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::Hold );
	

#line 6292 "rlparse.cpp"
} break;
case 211: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_inline_item *__ref2 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_inline_list *__ref3 = (Parser_Lel_inline_list*)&rhs[1]->user.inline_list;
#line 1280 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::Exec );
		(__ref2)->inlineItem->children = (__ref3)->inlineList;
	

#line 6305 "rlparse.cpp"
} break;
case 212: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1285 "rlparse.kl"
 
		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, 
				new NameRef(nameRef), InlineItem::Goto );
	

#line 6316 "rlparse.cpp"
} break;
case 213: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_inline_item *__ref2 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_inline_list *__ref3 = (Parser_Lel_inline_list*)&rhs[2]->user.inline_list;
#line 1290 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::GotoExpr );
		(__ref2)->inlineItem->children = (__ref3)->inlineList;
	

#line 6329 "rlparse.cpp"
} break;
case 214: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1295 "rlparse.kl"
 
		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, new NameRef(nameRef), InlineItem::Next );
	

#line 6339 "rlparse.cpp"
} break;
case 215: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_inline_item *__ref2 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_inline_list *__ref3 = (Parser_Lel_inline_list*)&rhs[2]->user.inline_list;
#line 1299 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::NextExpr );
		(__ref2)->inlineItem->children = (__ref3)->inlineList;
	

#line 6352 "rlparse.cpp"
} break;
case 216: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1304 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, new NameRef(nameRef), InlineItem::Call );
	

#line 6362 "rlparse.cpp"
} break;
case 217: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
Parser_Lel_inline_item *__ref2 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_inline_list *__ref3 = (Parser_Lel_inline_list*)&rhs[2]->user.inline_list;
#line 1308 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::CallExpr );
		(__ref2)->inlineItem->children = (__ref3)->inlineList;
	

#line 6375 "rlparse.cpp"
} break;
case 218: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1313 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::Ret );
	

#line 6385 "rlparse.cpp"
} break;
case 219: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1317 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::Break );
	

#line 6395 "rlparse.cpp"
} break;
case 220: {
Parser_Lel_inline_list *__ref0 = (Parser_Lel_inline_list*)&redLel->user.inline_list;
Parser_Lel_inline_list *__ref1 = (Parser_Lel_inline_list*)&rhs[0]->user.inline_list;
Parser_Lel_inline_list *__ref2 = (Parser_Lel_inline_list*)&redLel->user.inline_list;
Parser_Lel_inline_item *__ref3 = (Parser_Lel_inline_item*)&rhs[1]->user.inline_item;
#line 1325 "rlparse.kl"

		(__ref0)->inlineList = (__ref1)->inlineList;
		(__ref2)->inlineList->append( (__ref3)->inlineItem );
	

#line 6408 "rlparse.cpp"
} break;
case 221: {
Parser_Lel_inline_list *__ref0 = (Parser_Lel_inline_list*)&redLel->user.inline_list;
#line 1330 "rlparse.kl"

		/* Init the list used for this expr. */
		(__ref0)->inlineList = new InlineList;
	

#line 6418 "rlparse.cpp"
} break;
case 222: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_token_type *__ref2 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
#line 1339 "rlparse.kl"

		/* Return a text segment. */
		(__ref0)->inlineItem = new InlineItem( (__ref1)->token.loc, (__ref2)->token.data, InlineItem::Text );
	

#line 6430 "rlparse.cpp"
} break;
case 223: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_token_type *__ref1 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
Parser_Lel_token_type *__ref2 = (Parser_Lel_token_type*)&rhs[0]->user.token_type;
#line 1345 "rlparse.kl"

		/* Return a text segment, must heap alloc the text. */
		(__ref0)->inlineItem = new InlineItem( (__ref1)->token.loc, (__ref2)->token.data, InlineItem::Text );
	

#line 6442 "rlparse.cpp"
} break;
case 224: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Parser_Lel_inline_item *__ref1 = (Parser_Lel_inline_item*)&rhs[0]->user.inline_item;
#line 1351 "rlparse.kl"

		/* Pass the inline item up. */
		(__ref0)->inlineItem = (__ref1)->inlineItem;
	

#line 6453 "rlparse.cpp"
} break;
case 237: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1381 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::PChar );
	

#line 6463 "rlparse.cpp"
} break;
case 238: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1386 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::Char );
	

#line 6473 "rlparse.cpp"
} break;
case 239: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1391 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::Curs );
	

#line 6483 "rlparse.cpp"
} break;
case 240: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1396 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, InlineItem::Targs );
	

#line 6493 "rlparse.cpp"
} break;
case 241: {
Parser_Lel_inline_item *__ref0 = (Parser_Lel_inline_item*)&redLel->user.inline_item;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1401 "rlparse.kl"

		(__ref0)->inlineItem = new InlineItem( (__ref1)->loc, 
			new NameRef(nameRef), InlineItem::Entry );
	

#line 6504 "rlparse.cpp"
} break;
case 243: {
#line 1412 "rlparse.kl"

		nameRef.empty();
	

#line 6512 "rlparse.cpp"
} break;
case 245: {
#line 1422 "rlparse.kl"

		/* Insert an initial null pointer val to indicate the existence of the
		 * initial name seperator. */
		nameRef.setAs( 0 );
	

#line 6522 "rlparse.cpp"
} break;
case 246: {
#line 1428 "rlparse.kl"

		nameRef.empty();
	

#line 6530 "rlparse.cpp"
} break;
case 247: {
Token *__ref0 = (Token*)&rhs[2]->user.token;
#line 1435 "rlparse.kl"

		nameRef.append( (__ref0)->data );
	

#line 6539 "rlparse.cpp"
} break;
case 248: {
Token *__ref0 = (Token*)&rhs[0]->user.token;
#line 1440 "rlparse.kl"

		nameRef.append( (__ref0)->data );
	

#line 6548 "rlparse.cpp"
} break;
}
			}

			if ( lel->child != 0 ) {
				struct Parser_LangEl *first = lel->child;
				struct Parser_LangEl *child = lel->child;
				lel->child = 0;
				while ( 1 ) {
					if ( child->type < 226 ) {
					}
					else {
					}
					numNodes -= 1;
					if ( child->next == 0 )
						break;
					child = child->next;
				}
				child->next = pool;
				pool = first;
			}
		}

commit_base:
		if ( sp > 0 ) {
			sp -= 1;
			if ( lel->retry == 0 ) {
				lel = lel->prev;
				goto commit_reverse;
			}
			else {
				lel->retry = 0;
				lel = lel->prev;
				goto commit_upwards;
			}
		}
		lel->retry = 0;

		lastFinal = lel;
		numRetry = 0;
	}

	if ( *action & 0x2 ) {
		int reduction = *action >> 2;
		struct Parser_LangEl *redLel;

		if ( input != 0 )
			input->causeReduce += 1;

	if ( pool == 0 ) {
		if ( freshPos == 8128 ) {
			struct Parser_Block* newBlock  = (struct Parser_Block*) malloc( sizeof(struct Parser_Block) );
			newBlock->next = block;
			block = newBlock;
			freshEl = newBlock->data;
			#ifdef KELBT_LOG_ACTIONS
			cerr << "allocating 8128 LangEls" << endl;
			#endif
			freshPos = 0;
		}
		redLel = freshEl + freshPos++;
	}
	else {
		redLel = pool;
		pool = pool->next;
	}
	numNodes += 1;

		redLel->type = Parser_prodLhsIds[reduction];
		redLel->reduction = reduction;
		redLel->child = 0;
		redLel->next = 0;
		redLel->retry = (lel->retry << 16);
		redLel->causeReduce = 0;
		lel->retry &= 0xffff0000;

		rhsLen = Parser_prodLengths[reduction];
		if ( rhsLen > 0 ) {
			int r;
			for ( r = rhsLen-1; r > 0; r-- ) {
				rhs[r] = stackTop;
				stackTop = stackTop->next;
			}
			rhs[0] = stackTop;
			stackTop = stackTop->next;
			rhs[0]->next = 0;
		}
switch ( reduction ) {
case 225: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1358 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6643 "rlparse.cpp"
} break;
case 226: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1359 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6651 "rlparse.cpp"
} break;
case 227: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1360 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6659 "rlparse.cpp"
} break;
case 228: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1361 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6667 "rlparse.cpp"
} break;
case 229: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1362 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6675 "rlparse.cpp"
} break;
case 230: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1363 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6683 "rlparse.cpp"
} break;
case 231: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1364 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6691 "rlparse.cpp"
} break;
case 232: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1371 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6699 "rlparse.cpp"
} break;
case 233: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1372 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6707 "rlparse.cpp"
} break;
case 234: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1373 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6715 "rlparse.cpp"
} break;
case 235: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1374 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6723 "rlparse.cpp"
} break;
case 236: {
Parser_Lel_token_type *__ref0 = (Parser_Lel_token_type*)&redLel->user.token_type;
Token *__ref1 = (Token*)&rhs[0]->user.token;
#line 1375 "rlparse.kl"
 (__ref0)->token = *(__ref1); 

#line 6731 "rlparse.cpp"
} break;
}
		#ifdef KELBT_LOG_ACTIONS
		cerr << "reduced: "
				<< Parser_prodNames[reduction]
				<< " rhsLen: " << rhsLen;
		#endif
		if ( action[1] == 0 )
			redLel->retry = 0;
		else {
			redLel->retry += 0x10000;
			numRetry += 1;
			#ifdef KELBT_LOG_ACTIONS
			cerr << " retry: " << redLel;
			#endif
		}

		#ifdef KELBT_LOG_ACTIONS
		cerr << endl;
		#endif

		if ( rhsLen == 0 ) {
			redLel->file = lel->file;
			redLel->line = lel->line;
			targState = curs;
		}
		else {
			redLel->child = rhs[rhsLen-1];
			redLel->file = rhs[0]->file;
			redLel->line = rhs[0]->line;
			targState = rhs[0]->state;
		}

		if ( induceReject ) {
			#ifdef KELBT_LOG_ACTIONS
			cerr << "error induced during reduction of " <<
					Parser_lelNames[redLel->type] << endl;
			#endif
			redLel->state = curs;
			redLel->next = stackTop;
			stackTop = redLel;
			curs = targState;
			goto parseError;
		}
		else {
			redLel->next = input;
			input = redLel;
		}
	}


	curs = targState;
	goto again;

parseError:
	#ifdef KELBT_LOG_BACKTRACK
	cerr << "hit error" << endl;
	#endif
	if ( numRetry > 0 ) {
		struct Parser_LangEl *redLel;

		if ( input != 0 ) {
			redLel = input;
			goto have_undo_element;
		}

		while ( 1 ) {
			redLel = stackTop;
			if ( stackTop->type < 226 ) {
				#ifdef KELBT_LOG_BACKTRACK
				cerr << "backing up over terminal: " <<
						Parser_lelNames[stackTop->type] << endl;
				#endif
				stackTop = stackTop->next;
				redLel->next = input;
				input = redLel;
			}
			else {
				#ifdef KELBT_LOG_BACKTRACK
				cerr << "backing up over non-terminal: " <<
						Parser_lelNames[stackTop->type] << endl;
				#endif
				stackTop = stackTop->next;
				struct Parser_LangEl *first = redLel->child;
				if ( first == 0 )
					rhsLen = 0;
				else {
					rhsLen = 1;
					while ( first->next != 0 ) {
						first = first->next;
						rhsLen += 1;
					}
					first->next = stackTop;
					stackTop = redLel->child;

					struct Parser_LangEl *rhsEl = stackTop;
					int p = rhsLen;
					while ( p > 0 ) {
						rhs[--p] = rhsEl;
						rhsEl = rhsEl->next;
					}
				}
				redLel->next = pool;
				pool = redLel;
				numNodes -= 1;

				if ( input != 0 )
					input->causeReduce -= 1;
			}

have_undo_element:
			if ( redLel->retry == 0 ) {
				if ( input != 0 && input->causeReduce == 0 ) {
					#ifdef KELBT_LOG_BACKTRACK
					cerr << "pushing back: " << Parser_lelNames[input->type] << endl;
					#endif
					input->next = queue;
					queue = input;
					input = 0;
				}
			}
			else {
				#ifdef KELBT_LOG_BACKTRACK
				cerr << "found retry targ: " << redLel << endl;
				#endif
				numRetry -= 1;
				#ifdef KELBT_LOG_BACKTRACK
				cerr << "found retry: " << redLel << endl;
				#endif
				if ( redLel->retry & 0x0000ffff )
					curs = input->state;
				else {
					input->retry = redLel->retry >> 16;
					if ( stackTop->state < 0 )
						curs = Parser_startState;
					else {
						curs = Parser_targs[(int)Parser_indicies[Parser_offsets[stackTop->state] + (stackTop->type - Parser_keys[stackTop->state<<1])]];
					}
				}
				goto again;
			}
		}
	}
	curs = -1;
	errCount += 1;
_out: {}
#line 1459 "rlparse.kl"
	return errCount == 0 ? 0 : -1;
}