| 
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -785,7 +785,7 @@ ttynew(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																		close(s); | 
																 | 
																 | 
																		close(s); | 
															
														
														
													
														
															
																 | 
																 | 
																		cmdfd = m; | 
																 | 
																 | 
																		cmdfd = m; | 
															
														
														
													
														
															
																 | 
																 | 
																		signal(SIGCHLD, sigchld); | 
																 | 
																 | 
																		signal(SIGCHLD, sigchld); | 
															
														
														
													
														
															
																 | 
																 | 
																		if (opt_io && !(fileio = fopen(opt_io, "w"))) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(opt_io && !(fileio = fopen(opt_io, "w"))) { | 
															
														
														
													
														
															
																 | 
																 | 
																			fprintf(stderr, "Error opening %s:%s\n", | 
																 | 
																 | 
																			fprintf(stderr, "Error opening %s:%s\n", | 
															
														
														
													
														
															
																 | 
																 | 
																				opt_io, strerror(errno)); | 
																 | 
																 | 
																				opt_io, strerror(errno)); | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -884,7 +884,7 @@ treset(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT}; | 
																 | 
																 | 
																	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT}; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	memset(term.tabs, 0, term.col * sizeof(*term.tabs)); | 
																 | 
																 | 
																	memset(term.tabs, 0, term.col * sizeof(*term.tabs)); | 
															
														
														
													
														
															
																 | 
																 | 
																	for (i = TAB; i < term.col; i += TAB) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	for(i = TAB; i < term.col; i += TAB) | 
															
														
														
													
														
															
																 | 
																 | 
																		term.tabs[i] = 1; | 
																 | 
																 | 
																		term.tabs[i] = 1; | 
															
														
														
													
														
															
																 | 
																 | 
																	term.top = 0, term.bot = term.row - 1; | 
																 | 
																 | 
																	term.top = 0, term.bot = term.row - 1; | 
															
														
														
													
														
															
																 | 
																 | 
																	term.mode = MODE_WRAP; | 
																 | 
																 | 
																	term.mode = MODE_WRAP; | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1203,7 +1203,7 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																tsetmode(bool priv, bool set, int *args, int narg) { | 
																 | 
																 | 
																tsetmode(bool priv, bool set, int *args, int narg) { | 
															
														
														
													
														
															
																 | 
																 | 
																	int *lim, mode; | 
																 | 
																 | 
																	int *lim, mode; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	for (lim = args + narg; args < lim; ++args) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	for(lim = args + narg; args < lim; ++args) { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(priv) { | 
																 | 
																 | 
																		if(priv) { | 
															
														
														
													
														
															
																 | 
																 | 
																			switch(*args) { | 
																 | 
																 | 
																			switch(*args) { | 
															
														
														
													
														
															
																 | 
																 | 
																			case 1: | 
																 | 
																 | 
																			case 1: | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1212,7 +1212,7 @@ tsetmode(bool priv, bool set, int *args, int narg) { | 
															
														
														
													
														
															
																 | 
																 | 
																			case 5: /* DECSCNM -- Reverve video */ | 
																 | 
																 | 
																			case 5: /* DECSCNM -- Reverve video */ | 
															
														
														
													
														
															
																 | 
																 | 
																				mode = term.mode; | 
																 | 
																 | 
																				mode = term.mode; | 
															
														
														
													
														
															
																 | 
																 | 
																				MODBIT(term.mode,set, MODE_REVERSE); | 
																 | 
																 | 
																				MODBIT(term.mode,set, MODE_REVERSE); | 
															
														
														
													
														
															
																 | 
																 | 
																				if (mode != term.mode) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				if(mode != term.mode) | 
															
														
														
													
														
															
																 | 
																 | 
																					redraw(); | 
																 | 
																 | 
																					redraw(); | 
															
														
														
													
														
															
																 | 
																 | 
																				break; | 
																 | 
																 | 
																				break; | 
															
														
														
													
														
															
																 | 
																 | 
																			case 7: | 
																 | 
																 | 
																			case 7: | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1237,11 +1237,11 @@ tsetmode(bool priv, bool set, int *args, int narg) { | 
															
														
														
													
														
															
																 | 
																 | 
																			case 1047: | 
																 | 
																 | 
																			case 1047: | 
															
														
														
													
														
															
																 | 
																 | 
																				if(IS_SET(MODE_ALTSCREEN)) | 
																 | 
																 | 
																				if(IS_SET(MODE_ALTSCREEN)) | 
															
														
														
													
														
															
																 | 
																 | 
																					tclearregion(0, 0, term.col-1, term.row-1); | 
																 | 
																 | 
																					tclearregion(0, 0, term.col-1, term.row-1); | 
															
														
														
													
														
															
																 | 
																 | 
																				if ((set && !IS_SET(MODE_ALTSCREEN)) || | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				if((set && !IS_SET(MODE_ALTSCREEN)) || | 
															
														
														
													
														
															
																 | 
																 | 
																				    (!set && IS_SET(MODE_ALTSCREEN))) { | 
																 | 
																 | 
																				    (!set && IS_SET(MODE_ALTSCREEN))) { | 
															
														
														
													
														
															
																 | 
																 | 
																					    tswapscreen(); | 
																 | 
																 | 
																					    tswapscreen(); | 
															
														
														
													
														
															
																 | 
																 | 
																				} | 
																 | 
																 | 
																				} | 
															
														
														
													
														
															
																 | 
																 | 
																				if (*args != 1049) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				if(*args != 1049) | 
															
														
														
													
														
															
																 | 
																 | 
																					break; | 
																 | 
																 | 
																					break; | 
															
														
														
													
														
															
																 | 
																 | 
																				/* pass through */ | 
																 | 
																 | 
																				/* pass through */ | 
															
														
														
													
														
															
																 | 
																 | 
																			case 1048: | 
																 | 
																 | 
																			case 1048: | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1334,7 +1334,7 @@ csihandle(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																		break; | 
															
														
														
													
														
															
																 | 
																 | 
																	case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */ | 
																 | 
																 | 
																	case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */ | 
															
														
														
													
														
															
																 | 
																 | 
																		DEFAULT(csiescseq.arg[0], 1); | 
																 | 
																 | 
																		DEFAULT(csiescseq.arg[0], 1); | 
															
														
														
													
														
															
																 | 
																 | 
																		while (csiescseq.arg[0]--) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		while(csiescseq.arg[0]--) | 
															
														
														
													
														
															
																 | 
																 | 
																			tputtab(1); | 
																 | 
																 | 
																			tputtab(1); | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																		break; | 
															
														
														
													
														
															
																 | 
																 | 
																	case 'J': /* ED -- Clear screen */ | 
																 | 
																 | 
																	case 'J': /* ED -- Clear screen */ | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1399,7 +1399,7 @@ csihandle(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																		break; | 
															
														
														
													
														
															
																 | 
																 | 
																	case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */ | 
																 | 
																 | 
																	case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */ | 
															
														
														
													
														
															
																 | 
																 | 
																		DEFAULT(csiescseq.arg[0], 1); | 
																 | 
																 | 
																		DEFAULT(csiescseq.arg[0], 1); | 
															
														
														
													
														
															
																 | 
																 | 
																		while (csiescseq.arg[0]--) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		while(csiescseq.arg[0]--) | 
															
														
														
													
														
															
																 | 
																 | 
																			tputtab(0); | 
																 | 
																 | 
																			tputtab(0); | 
															
														
														
													
														
															
																 | 
																 | 
																		break; | 
																 | 
																 | 
																		break; | 
															
														
														
													
														
															
																 | 
																 | 
																	case 'd': /* VPA -- Move to <row> */ | 
																 | 
																 | 
																	case 'd': /* VPA -- Move to <row> */ | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1530,15 +1530,15 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																tputtab(bool forward) { | 
																 | 
																 | 
																tputtab(bool forward) { | 
															
														
														
													
														
															
																 | 
																 | 
																	unsigned x = term.c.x; | 
																 | 
																 | 
																	unsigned x = term.c.x; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if (forward) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		if (x == term.col) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(forward) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(x == term.col) | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																			return; | 
															
														
														
													
														
															
																 | 
																 | 
																		for (++x; x < term.col && !term.tabs[x]; ++x) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		for(++x; x < term.col && !term.tabs[x]; ++x) | 
															
														
														
													
														
															
																 | 
																 | 
																			/* nothing */ ; | 
																 | 
																 | 
																			/* nothing */ ; | 
															
														
														
													
														
															
																 | 
																 | 
																	} else { | 
																 | 
																 | 
																	} else { | 
															
														
														
													
														
															
																 | 
																 | 
																		if (x == 0) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(x == 0) | 
															
														
														
													
														
															
																 | 
																 | 
																			return; | 
																 | 
																 | 
																			return; | 
															
														
														
													
														
															
																 | 
																 | 
																		for (--x; x > 0 && !term.tabs[x]; --x) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		for(--x; x > 0 && !term.tabs[x]; --x) | 
															
														
														
													
														
															
																 | 
																 | 
																			/* nothing */ ; | 
																 | 
																 | 
																			/* nothing */ ; | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	tmoveto(x, term.c.y); | 
																 | 
																 | 
																	tmoveto(x, term.c.y); | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1548,8 +1548,9 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																tputc(char *c) { | 
																 | 
																 | 
																tputc(char *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																	char ascii = *c; | 
																 | 
																 | 
																	char ascii = *c; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if (fileio) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(fileio) | 
															
														
														
													
														
															
																 | 
																 | 
																		putc(ascii, fileio); | 
																 | 
																 | 
																		putc(ascii, fileio); | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	if(term.esc & ESC_START) { | 
																 | 
																 | 
																	if(term.esc & ESC_START) { | 
															
														
														
													
														
															
																 | 
																 | 
																		if(term.esc & ESC_CSI) { | 
																 | 
																 | 
																		if(term.esc & ESC_CSI) { | 
															
														
														
													
														
															
																 | 
																 | 
																			csiescseq.buf[csiescseq.len++] = ascii; | 
																 | 
																 | 
																			csiescseq.buf[csiescseq.len++] = ascii; | 
															
														
														
													
												
													
														
															
																| 
																	
																	
																	
																		
																			
																		
																	
																 | 
																@ -1568,7 +1569,7 @@ tputc(char *c) { | 
															
														
														
													
														
															
																 | 
																 | 
																				break; | 
																 | 
																 | 
																				break; | 
															
														
														
													
														
															
																 | 
																 | 
																			default: | 
																 | 
																 | 
																			default: | 
															
														
														
													
														
															
																 | 
																 | 
																				strescseq.buf[strescseq.len++] = ascii; | 
																 | 
																 | 
																				strescseq.buf[strescseq.len++] = ascii; | 
															
														
														
													
														
															
																 | 
																 | 
																				if (strescseq.len+1 >= STR_BUF_SIZ) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																				if(strescseq.len+1 >= STR_BUF_SIZ) { | 
															
														
														
													
														
															
																 | 
																 | 
																					term.esc = 0; | 
																 | 
																 | 
																					term.esc = 0; | 
															
														
														
													
														
															
																 | 
																 | 
																					strhandle(); | 
																 | 
																 | 
																					strhandle(); | 
															
														
														
													
														
															
																 | 
																 | 
																				} | 
																 | 
																 | 
																				} | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1746,13 +1747,13 @@ tresize(int col, int row) { | 
															
														
														
													
														
															
																 | 
																 | 
																		term.line[i] = calloc(col, sizeof(Glyph)); | 
																 | 
																 | 
																		term.line[i] = calloc(col, sizeof(Glyph)); | 
															
														
														
													
														
															
																 | 
																 | 
																		term.alt [i] = calloc(col, sizeof(Glyph)); | 
																 | 
																 | 
																		term.alt [i] = calloc(col, sizeof(Glyph)); | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	if (col > term.col) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(col > term.col) { | 
															
														
														
													
														
															
																 | 
																 | 
																		bool *bp = term.tabs + term.col; | 
																 | 
																 | 
																		bool *bp = term.tabs + term.col; | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																		memset(bp, 0, sizeof(*term.tabs) * (col - term.col)); | 
																 | 
																 | 
																		memset(bp, 0, sizeof(*term.tabs) * (col - term.col)); | 
															
														
														
													
														
															
																 | 
																 | 
																		while (--bp > term.tabs && !*bp) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		while(--bp > term.tabs && !*bp) | 
															
														
														
													
														
															
																 | 
																 | 
																			/* nothing */ ; | 
																 | 
																 | 
																			/* nothing */ ; | 
															
														
														
													
														
															
																 | 
																 | 
																		for (bp += TAB; bp < term.tabs + col; bp += TAB) | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		for(bp += TAB; bp < term.tabs + col; bp += TAB) | 
															
														
														
													
														
															
																 | 
																 | 
																			*bp = 1; | 
																 | 
																 | 
																			*bp = 1; | 
															
														
														
													
														
															
																 | 
																 | 
																	} | 
																 | 
																 | 
																	} | 
															
														
														
													
														
															
																 | 
																 | 
																	/* update terminal size */ | 
																 | 
																 | 
																	/* update terminal size */ | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -1805,7 +1806,7 @@ xloadcols(void) { | 
															
														
														
													
														
															
																 | 
																 | 
																
 | 
																 | 
																 | 
																
 | 
															
														
														
													
														
															
																 | 
																 | 
																	for(r = 0; r < 24; r++, i++) { | 
																 | 
																 | 
																	for(r = 0; r < 24; r++, i++) { | 
															
														
														
													
														
															
																 | 
																 | 
																		color.red = color.green = color.blue = 0x0808 + 0x0a0a * r; | 
																 | 
																 | 
																		color.red = color.green = color.blue = 0x0808 + 0x0a0a * r; | 
															
														
														
													
														
															
																 | 
																 | 
																		if (!XAllocColor(xw.dpy, xw.cmap, &color)) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(!XAllocColor(xw.dpy, xw.cmap, &color)) { | 
															
														
														
													
														
															
																 | 
																 | 
																			dc.col[i] = white; | 
																 | 
																 | 
																			dc.col[i] = white; | 
															
														
														
													
														
															
																 | 
																 | 
																			fprintf(stderr, "Could not allocate color %d\n", i); | 
																 | 
																 | 
																			fprintf(stderr, "Could not allocate color %d\n", i); | 
															
														
														
													
														
															
																 | 
																 | 
																		} else | 
																 | 
																 | 
																		} else | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -2227,11 +2228,11 @@ void | 
															
														
														
													
														
															
																 | 
																 | 
																cmessage(XEvent *e) { | 
																 | 
																 | 
																cmessage(XEvent *e) { | 
															
														
														
													
														
															
																 | 
																 | 
																	/* See xembed specs | 
																 | 
																 | 
																	/* See xembed specs | 
															
														
														
													
														
															
																 | 
																 | 
																	   http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html */ | 
																 | 
																 | 
																	   http://standards.freedesktop.org/xembed-spec/xembed-spec-latest.html */ | 
															
														
														
													
														
															
																 | 
																 | 
																	if (e->xclient.message_type == xw.xembed && e->xclient.format == 32) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																		if (e->xclient.data.l[1] == XEMBED_FOCUS_IN) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																	if(e->xclient.message_type == xw.xembed && e->xclient.format == 32) { | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		if(e->xclient.data.l[1] == XEMBED_FOCUS_IN) { | 
															
														
														
													
														
															
																 | 
																 | 
																			xw.state |= WIN_FOCUSED; | 
																 | 
																 | 
																			xw.state |= WIN_FOCUSED; | 
															
														
														
													
														
															
																 | 
																 | 
																			xseturgency(0); | 
																 | 
																 | 
																			xseturgency(0); | 
															
														
														
													
														
															
																 | 
																 | 
																		} else if (e->xclient.data.l[1] == XEMBED_FOCUS_OUT) { | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																		} else if(e->xclient.data.l[1] == XEMBED_FOCUS_OUT) { | 
															
														
														
													
														
															
																 | 
																 | 
																			xw.state &= ~WIN_FOCUSED; | 
																 | 
																 | 
																			xw.state &= ~WIN_FOCUSED; | 
															
														
														
													
														
															
																 | 
																 | 
																		} | 
																 | 
																 | 
																		} | 
															
														
														
													
														
															
																 | 
																 | 
																		draw(); | 
																 | 
																 | 
																		draw(); | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																		
																			
																		
																	
																	
																 | 
																@ -2322,7 +2323,7 @@ main(int argc, char *argv[]) { | 
															
														
														
													
														
															
																 | 
																 | 
																			if(++i < argc) opt_embed = argv[i]; | 
																 | 
																 | 
																			if(++i < argc) opt_embed = argv[i]; | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case 'f': | 
																 | 
																 | 
																		case 'f': | 
															
														
														
													
														
															
																 | 
																 | 
																			if (++i < argc) opt_io = argv[i]; | 
																 | 
																 | 
																 | 
															
														
														
													
														
															
																 | 
																 | 
																 | 
																 | 
																 | 
																			if(++i < argc) opt_io = argv[i]; | 
															
														
														
													
														
															
																 | 
																 | 
																			break; | 
																 | 
																 | 
																			break; | 
															
														
														
													
														
															
																 | 
																 | 
																		case 'e': | 
																 | 
																 | 
																		case 'e': | 
															
														
														
													
														
															
																 | 
																 | 
																			/* eat every remaining arguments */ | 
																 | 
																 | 
																			/* eat every remaining arguments */ | 
															
														
														
													
												
													
														
															
																| 
																	
																		
																			
																		
																	
																	
																	
																 | 
																
  |