# line 2 "newsrc.y" #if !defined(lint) && !defined(SABER) && !defined(GCC_WALL) static char XRNrcsid[] = "$Id: newsrc.y,v 1.14 1995/09/22 06:47:47 jik Exp $"; #endif /* * xrn - an X-based NNTP news reader * * Copyright (c) 1988-1993, Ellen M. Sentovich and Rick L. Spickelmier. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, provided * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of the University of California not * be used in advertising or publicity pertaining to distribution of * the software without specific, written prior permission. The University * of California makes no representations about the suitability of this * software for any purpose. It is provided "as is" without express or * implied warranty. * * THE UNIVERSITY OF CALIFORNIA DISCLAIMS ALL WARRANTIES WITH REGARD TO * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS, IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE FOR * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * newsrc.y - yacc parser for the newsrc file */ #include "copyright.h" #include "config.h" #include "utils.h" #include #include #include "avl.h" #include "mesg.h" #include "news.h" #include "newsrcfile.h" #include "mesg_strings.h" #include "internals.h" extern int yylineno; int newsrc_mesg_name; # line 53 "newsrc.y" typedef union #ifdef __cplusplus YYSTYPE #endif { int integer; char *string; char character; struct list *item; } YYSTYPE; # define NAME 257 # define SEPARATOR 258 # define NUMBER 259 # define EOL 260 # define DASH 261 # define COMMA 262 #include #include #include #include #ifdef __cplusplus #ifndef yyerror void yyerror(const char *); #endif #ifndef yylex extern "C" int yylex(void); #endif int yyparse(void); #endif #define yyclearin yychar = -1 #define yyerrok yyerrflag = 0 extern int yychar; extern int yyerrflag; YYSTYPE yylval; YYSTYPE yyval; typedef int yytabelem; #ifndef YYMAXDEPTH #define YYMAXDEPTH 150 #endif #if YYMAXDEPTH > 0 int yy_yys[YYMAXDEPTH], *yys = yy_yys; YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; #else /* user does initial allocation */ int *yys; YYSTYPE *yyv; #endif static int yymaxdepth = YYMAXDEPTH; # define YYERRCODE 256 # line 178 "newsrc.y" #include "lex.yy.c" yytabelem yyexca[] ={ -1, 1, 0, -1, -2, 0, -1, 2, 0, 1, -2, 0, }; # define YYNPROD 11 # define YYLAST 27 yytabelem yyact[]={ 13, 8, 14, 15, 12, 10, 17, 12, 7, 5, 4, 11, 3, 2, 1, 6, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16 }; yytabelem yypact[]={ -247,-10000000, -247,-10000000, -250, -259,-10000000, -255,-10000000, -260, -10000000,-10000000, -258,-10000000, -252, -253,-10000000,-10000000 }; yytabelem yypgo[]={ 0, 16, 11, 14, 13, 12 }; yytabelem yyr1[]={ 0, 3, 4, 4, 5, 5, 5, 1, 1, 2, 2 }; yytabelem yyr2[]={ 0, 2, 2, 4, 9, 7, 5, 3, 7, 3, 7 }; yytabelem yychk[]={ -10000000, -3, -4, -5, 257, 256, -5, 258, 260, -1, 260, -2, 259, 260, 262, 261, -2, 259 }; yytabelem yydef[]={ 0, -2, -2, 2, 0, 0, 3, 0, 6, 0, 5, 7, 9, 4, 0, 0, 8, 10 }; typedef struct #ifdef __cplusplus yytoktype #endif { char *t_name; int t_val; } yytoktype; #ifndef YYDEBUG # define YYDEBUG 0 /* don't allow debugging */ #endif #if YYDEBUG yytoktype yytoks[] = { "NAME", 257, "SEPARATOR", 258, "NUMBER", 259, "EOL", 260, "DASH", 261, "COMMA", 262, "-unknown-", -1 /* ends search */ }; char * yyreds[] = { "-no such reduction-", "goal : newsrc_file", "newsrc_file : newsrc_line", "newsrc_file : newsrc_file newsrc_line", "newsrc_line : NAME SEPARATOR artlist EOL", "newsrc_line : NAME SEPARATOR EOL", "newsrc_line : error EOL", "artlist : articles", "artlist : artlist COMMA articles", "articles : NUMBER", "articles : NUMBER DASH NUMBER", }; #endif /* YYDEBUG */ /* * Copyright 1987 Silicon Graphics, Inc. - All Rights Reserved */ /* #ident "@(#)yacc:yaccpar 1.10" */ #ident "$Revision: 1.9 $" /* ** Skeleton parser driver for yacc output */ /* ** yacc user known macros and defines */ #define YYERROR goto yyerrlab #define YYACCEPT return(0) #define YYABORT return(1) #ifdef __cplusplus #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ yyerror( gettxt("uxlibc:78", "syntax error - cannot backup") );\ goto yyerrlab;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #else #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ yyerror( gettxt("uxlibc:78", "Syntax error - cannot backup") );\ goto yyerrlab;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #endif #define YYRECOVERING() (!!yyerrflag) #define YYNEW(type) malloc(sizeof(type) * yynewmax) #define YYCOPY(to, from, type) \ (type *) memcpy(to, (char *) from, yynewmax * sizeof(type)) #define YYENLARGE( from, type) \ (type *) realloc((char *) from, yynewmax * sizeof(type)) #ifndef YYDEBUG # define YYDEBUG 1 /* make debugging available */ #endif /* ** user known globals */ int yydebug; /* set to 1 to get debugging */ /* ** driver internal defines */ #define YYFLAG (-10000000) /* ** global variables used by the parser */ YYSTYPE *yypv; /* top of value stack */ int *yyps; /* top of state stack */ int yystate; /* current state */ int yytmp; /* extra var (lasts between blocks) */ int yynerrs; /* number of errors */ int yyerrflag; /* error recovery flag */ int yychar; /* current input token number */ /* ** yyparse - return 0 if worked, 1 if syntax error not recovered from */ #if defined(__STDC__) || defined(__cplusplus) int yyparse(void) #else int yyparse() #endif { register YYSTYPE *yypvt; /* top of value stack for $vars */ /* ** Initialize externals - yyparse may be called more than once */ yypv = &yyv[-1]; yyps = &yys[-1]; yystate = 0; yytmp = 0; yynerrs = 0; yyerrflag = 0; yychar = -1; #if YYMAXDEPTH <= 0 if (yymaxdepth <= 0) { if ((yymaxdepth = YYEXPAND(0)) <= 0) { #ifdef __cplusplus yyerror(gettxt("uxlibc:79", "yacc initialization error")); #else yyerror(gettxt("uxlibc:79", "Yacc initialization error")); #endif YYABORT; } } #endif goto yystack; { register YYSTYPE *yy_pv; /* top of value stack */ register int *yy_ps; /* top of state stack */ register int yy_state; /* current state */ register int yy_n; /* internal state number info */ /* ** get globals into registers. ** branch to here only if YYBACKUP was called. */ yynewstate: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; goto yy_newstate; /* ** get globals into registers. ** either we just started, or we just finished a reduction */ yystack: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; /* ** top of for (;;) loop while no reductions done */ yy_stack: /* ** put a state and value onto the stacks */ #if YYDEBUG /* ** if debugging, look up token value in list of value vs. ** name pairs. 0 and negative (-1) are special values. ** Note: linear search is used since time is not a real ** consideration while debugging. */ if ( yydebug ) { register int yy_i; printf( "State %d, token ", yy_state ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ { int yynewmax, yys_off; /* The following pointer-differences are safe, since * yypvt, yy_pv, and yypv all are a multiple of * sizeof(YYSTYPE) bytes from yyv. */ int yypvt_off = yypvt - yyv; int yy_pv_off = yy_pv - yyv; int yypv_off = yypv - yyv; int *yys_base = yys; #ifdef YYEXPAND yynewmax = YYEXPAND(yymaxdepth); #else yynewmax = 2 * yymaxdepth; /* double table size */ if (yymaxdepth == YYMAXDEPTH) /* first time growth */ { void *newyys = YYNEW(int); void *newyyv = YYNEW(YYSTYPE); if (newyys != 0 && newyyv != 0) { yys = YYCOPY(newyys, yys, int); yyv = YYCOPY(newyyv, yyv, YYSTYPE); } else yynewmax = 0; /* failed */ } else /* not first time */ { yys = YYENLARGE(yys, int); yyv = YYENLARGE(yyv, YYSTYPE); if (yys == 0 || yyv == 0) yynewmax = 0; /* failed */ } #endif if (yynewmax <= yymaxdepth) /* tables not expanded */ { #ifdef __cplusplus yyerror( gettxt("uxlibc:80", "yacc stack overflow") ); #else yyerror( gettxt("uxlibc:80", "Yacc stack overflow") ); #endif YYABORT; } yymaxdepth = yynewmax; /* reset pointers into yys */ yys_off = yys - yys_base; yy_ps = yy_ps + yys_off; yyps = yyps + yys_off; /* reset pointers into yyv */ yypvt = yyv + yypvt_off; yy_pv = yyv + yy_pv_off; yypv = yyv + yypv_off; } *yy_ps = yy_state; *++yy_pv = yyval; /* ** we have a new state - find out what to do */ yy_newstate: if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) goto yydefault; /* simple state */ #if YYDEBUG /* ** if debugging, need to mark whether new token grabbed */ yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) goto yydefault; if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ { yychar = -1; yyval = yylval; yy_state = yy_n; if ( yyerrflag > 0 ) yyerrflag--; goto yy_stack; } yydefault: if ( ( yy_n = yydef[ yy_state ] ) == -2 ) { #if YYDEBUG yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ /* ** look through exception table */ { register int *yyxi = yyexca; while ( ( *yyxi != -1 ) || ( yyxi[1] != yy_state ) ) { yyxi += 2; } while ( ( *(yyxi += 2) >= 0 ) && ( *yyxi != yychar ) ) ; if ( ( yy_n = yyxi[1] ) < 0 ) YYACCEPT; } } /* ** check for syntax error */ if ( yy_n == 0 ) /* have an error */ { /* no worry about speed here! */ switch ( yyerrflag ) { case 0: /* new error */ #ifdef __cplusplus yyerror( gettxt("uxlibc:81", "syntax error") ); #else yyerror( gettxt("uxlibc:81", "Syntax error") ); #endif goto skip_init; yyerrlab: /* ** get globals into registers. ** we have a user generated syntax type error */ yy_pv = yypv; yy_ps = yyps; yy_state = yystate; yynerrs++; /* FALLTHRU */ skip_init: case 1: case 2: /* incompletely recovered error */ /* try again... */ yyerrflag = 3; /* ** find state where "error" is a legal ** shift action */ while ( yy_ps >= yys ) { yy_n = yypact[ *yy_ps ] + YYERRCODE; if ( yy_n >= 0 && yy_n < YYLAST && yychk[yyact[yy_n]] == YYERRCODE) { /* ** simulate shift of "error" */ yy_state = yyact[ yy_n ]; goto yy_stack; } /* ** current state has no shift on ** "error", pop stack */ #if YYDEBUG # define _POP_ "Error recovery pops state %d, uncovers state %d\n" if ( yydebug ) printf( _POP_, *yy_ps, yy_ps[-1] ); # undef _POP_ #endif yy_ps--; yy_pv--; } /* ** there is no state on stack with "error" as ** a valid shift. give up. */ YYABORT; case 3: /* no shift yet; eat a token */ #if YYDEBUG /* ** if debugging, look up token in list of ** pairs. 0 and negative shouldn't occur, ** but since timing doesn't matter when ** debugging, it doesn't hurt to leave the ** tests here. */ if ( yydebug ) { register int yy_i; printf( "Error recovery discards " ); if ( yychar == 0 ) printf( "token end-of-file\n" ); else if ( yychar < 0 ) printf( "token -none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "token %s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( yychar == 0 ) /* reached EOF. quit */ YYABORT; yychar = -1; goto yy_newstate; } }/* end if ( yy_n == 0 ) */ /* ** reduction by production yy_n ** put stack tops, etc. so things right after switch */ #if YYDEBUG /* ** if debugging, print the string that is the user's ** specification of the reduction which is just about ** to be done. */ if ( yydebug ) printf( "Reduce by (%d) \"%s\"\n", yy_n, yyreds[ yy_n ] ); #endif yytmp = yy_n; /* value to switch over */ yypvt = yy_pv; /* $vars top of value stack */ /* ** Look in goto table for next state ** Sorry about using yy_state here as temporary ** register variable, but why not, if it works... ** If yyr2[ yy_n ] doesn't have the low order bit ** set, then there is no action to be done for ** this reduction. So, no saving & unsaving of ** registers done. The only difference between the ** code just after the if and the body of the if is ** the goto yy_stack in the body. This way the test ** can be made before the choice of what to do is needed. */ { /* length of production doubled with extra bit */ register int yy_len = yyr2[ yy_n ]; if ( !( yy_len & 01 ) ) { yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } goto yy_stack; } yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } } /* save until reenter driver code */ yystate = yy_state; yyps = yy_ps; yypv = yy_pv; } /* ** code supplied by user is placed in this switch */ switch( yytmp ) { case 4: # line 80 "newsrc.y" { struct newsgroup *newsgroup; if (! verifyGroup(yypvt[-3].string, &newsgroup)) { struct list *current, *next; mesgPane(XRN_SERIOUS, newsrc_mesg_name, BOGUS_NG_REMOVING_MSG, yypvt[-3].string); for (current = yypvt[-1].item; current; current = next) { next = current->next; XtFree((char *) current); } } else { if (IS_NOENTRY(newsgroup) || IS_NEW(newsgroup)) { CLEAR_NOENTRY(newsgroup); CLEAR_NEW(newsgroup); if (yypvt[-2].character == ':') SET_SUB(newsgroup); newsgroup->nglist = yypvt[-1].item; updateArticleArray(newsgroup); newsgroup->newsrc = MaxGroupNumber; Newsrc[MaxGroupNumber++] = newsgroup; } else { mesgPane(XRN_SERIOUS, newsrc_mesg_name, DUP_NEWSRC_ENTRY_MSG, yypvt[-3].string); } } XtFree(yypvt[-3].string); } break; case 5: # line 111 "newsrc.y" { struct newsgroup *newsgroup; if (! verifyGroup(yypvt[-2].string, &newsgroup)) mesgPane(XRN_SERIOUS, newsrc_mesg_name, BOGUS_NG_REMOVING_MSG, yypvt[-2].string); else { if (IS_NOENTRY(newsgroup) || IS_NEW(newsgroup)) { CLEAR_NOENTRY(newsgroup); CLEAR_NEW(newsgroup); if (yypvt[-1].character == ':') SET_SUB(newsgroup); newsgroup->nglist = NIL(struct list); updateArticleArray(newsgroup); newsgroup->newsrc = MaxGroupNumber; Newsrc[MaxGroupNumber++] = newsgroup; } else { mesgPane(XRN_SERIOUS, newsrc_mesg_name, DUP_NEWSRC_ENTRY_MSG, yypvt[-2].string); } } XtFree(yypvt[-2].string); } break; case 6: # line 134 "newsrc.y" { mesgPane(XRN_SERIOUS, newsrc_mesg_name, BAD_NEWSRC_LINE_MSG, yylineno - 1); /* yylineno stepped at EOL */ yyerrok; yyclearin; } break; case 7: # line 143 "newsrc.y" { yyval.item = yypvt[-0].item; } break; case 8: # line 147 "newsrc.y" { struct list *temp; yyval.item = yypvt[-2].item; for (temp = yyval.item; temp != NIL(struct list); temp = temp->next) { if (temp->next == NIL(struct list)) { temp->next = yypvt[-0].item; break; } } } break; case 9: # line 161 "newsrc.y" { yyval.item = ALLOC(struct list); yyval.item->type = SINGLE; yyval.item->contents.single = (art_num) yypvt[-0].integer; yyval.item->next = NIL(struct list); } break; case 10: # line 168 "newsrc.y" { yyval.item = ALLOC(struct list); yyval.item->type = RANGE; yyval.item->contents.range.start = (art_num) yypvt[-2].integer; yyval.item->contents.range.end = (art_num) yypvt[-0].integer; yyval.item->next = NIL(struct list); } break; } goto yystack; /* reset registers in driver code */ }