home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / palias10.lzh / BNU / PALIAS / y.tab.c < prev    next >
Text File  |  1993-11-06  |  32KB  |  1,268 lines
  1.  
  2. /*  A Bison parser, made from parse.y  */
  3.  
  4. #define    SITE    258
  5. #define    HOST    259
  6. #define    STRING    260
  7. #define    COST    261
  8. #define    NET    262
  9. #define    YEOL    263
  10. #define    PRIVATE    264
  11. #define    DEAD    265
  12. #define    DELETE    266
  13. #define    FILETOK    267
  14. #define    ADJUST    268
  15.  
  16. #line 1 "parse.y"
  17.  
  18. /* pathalias -- by steve bellovin, as told to peter honeyman */
  19. #ifndef lint
  20. static char    *sccsid = "@(#)parse.y    9.11 91/06/01";
  21. #endif /* lint */
  22.  
  23. #include "def.h"
  24.  
  25. /* scanner states (yylex, parse) */
  26. #define OTHER        0
  27. #define COSTING        1
  28. #define NEWLINE        2
  29. #define FILENAME    3
  30.  
  31. /* exports */
  32. long Tcount;
  33. extern void yyerror();
  34.  
  35. /* imports */
  36. extern node *addnode(), *addprivate();
  37. extern void fixprivate(), alias(), deadlink(), deletelink();
  38. extern link *addlink();
  39. extern int strcmp();
  40. extern char *strsave();
  41. extern int optind;
  42. extern char *Cfile, *Netchars, **Argv;
  43. extern int Lineno, Argc;
  44. extern node *Home;
  45.  
  46. /* privates */
  47. STATIC void fixnet(), adjust();
  48. STATIC int yylex(), yywrap(), getword();
  49. static int Scanstate = NEWLINE;    /* scanner (yylex) state */
  50.  
  51. /* flags for ys_flags */
  52. #define TERMINAL 1
  53.  
  54. #line 39 "parse.y"
  55. typedef union {
  56.     node    *y_node;
  57.     Cost    y_cost;
  58.     char    y_net;
  59.     char    *y_name;
  60.     struct {
  61.         node *ys_node;
  62.         Cost ys_cost;
  63.         short ys_flag;
  64.         char ys_net;
  65.         char ys_dir;
  66.     } y_s;
  67. } YYSTYPE;
  68.  
  69. #ifndef YYLTYPE
  70. typedef
  71.   struct yyltype
  72.     {
  73.       int timestamp;
  74.       int first_line;
  75.       int first_column;
  76.       int last_line;
  77.       int last_column;
  78.       char *text;
  79.    }
  80.   yyltype;
  81.  
  82. #define YYLTYPE yyltype
  83. #endif
  84.  
  85. #include <stdio.h>
  86.  
  87. #ifndef __STDC__
  88. #define const
  89. #endif
  90.  
  91.  
  92.  
  93. #define    YYFINAL        122
  94. #define    YYFLAG        -32768
  95. #define    YYNTBASE    26
  96.  
  97. #define YYTRANSLATE(x) ((unsigned)(x) <= 268 ? yytranslate[x] : 54)
  98.  
  99. static const char yytranslate[] = {     0,
  100.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  101.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  102.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  103.      2,     2,     2,     2,     2,     2,     2,     2,     2,    24,
  104.     25,    16,    14,    18,    15,     2,    17,     2,     2,     2,
  105.      2,     2,     2,     2,     2,     2,     2,     2,     2,    19,
  106.     21,    20,     2,     2,     2,     2,     2,     2,     2,     2,
  107.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  108.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  109.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  110.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  111.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  112.      2,     2,    22,     2,    23,     2,     2,     2,     2,     2,
  113.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  114.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  115.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  116.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  117.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  118.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  119.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  120.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  121.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  122.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  123.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  124.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  125.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  126.      6,     7,     8,     9,    10,    11,    12,    13
  127. };
  128.  
  129. static const short yyrline[] = {     0,
  130.     67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
  131.     77,    80,    89,    98,   101,   102,   103,   104,   105,   106,
  132.    109,   114,   119,   126,   130,   137,   138,   139,   142,   143,
  133.    144,   147,   148,   151,   152,   161,   164,   165,   168,   169,
  134.    170,   173,   175,   176,   177,   180,   181,   184,   186,   188,
  135.    189,   190,   193,   203,   206,   206,   206,   211,   213,   214,
  136.    215,   218,   220,   221,   221,   222,   225,   226,   227,   228,
  137.    229,   230,   231
  138. };
  139.  
  140. static const char * const yytname[] = {     0,
  141. "error","$illegal.","SITE","HOST","STRING","COST","NET","YEOL","PRIVATE","DEAD",
  142. "DELETE","FILETOK","ADJUST","'+'","'-'","'*'","'/'","','","'<'","'>'",
  143. "'='","'{'","'}'","'('","')'","map"
  144. };
  145.  
  146. static const short yyr1[] = {     0,
  147.     26,    26,    26,    26,    26,    26,    26,    26,    26,    26,
  148.     26,    27,    27,    27,    28,    28,    28,    28,    28,    28,
  149.     29,    29,    29,    30,    30,    31,    31,    31,    32,    32,
  150.     32,    33,    33,    34,    34,    34,    35,    35,    36,    36,
  151.     36,    37,    38,    38,    38,    39,    39,    40,    41,    42,
  152.     42,    42,    43,    43,    45,    46,    44,    47,    48,    48,
  153.     48,    49,    50,    51,    52,    50,    53,    53,    53,    53,
  154.     53,    53,    53
  155. };
  156.  
  157. static const short yyr2[] = {     0,
  158.      0,     2,     3,     3,     3,     3,     3,     3,     3,     3,
  159.      2,     3,     4,     2,     1,     1,     1,     1,     1,     1,
  160.      1,     2,     2,     1,     3,     3,     3,     2,     5,     6,
  161.      6,     1,     2,     1,     3,     2,     4,     3,     1,     3,
  162.      2,     4,     1,     3,     2,     1,     3,     1,     4,     1,
  163.      3,     2,     1,     3,     0,     0,     6,     4,     1,     3,
  164.      2,     2,     0,     0,     0,     5,     1,     2,     3,     3,
  165.      3,     3,     3
  166. };
  167.  
  168. static const short yydefact[] = {     0,
  169.      0,     0,    11,    15,     2,    16,    17,    18,    19,    20,
  170.     32,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  171.      0,     0,     0,     0,    55,     0,     3,    14,    24,     0,
  172.      0,    33,    63,    21,     4,    28,     5,     0,     0,     6,
  173.      7,     8,     9,    10,    39,    38,     0,    46,     0,    43,
  174.      0,    53,     0,     0,    50,     0,    48,    63,     0,    59,
  175.     63,    22,     0,    26,    64,    12,    23,    27,     0,    34,
  176.      0,    41,    37,    45,    42,     0,     0,    52,    49,    56,
  177.     62,    61,    58,    13,    25,     0,     0,    36,    63,    40,
  178.     44,    47,    54,    51,     0,    60,    67,     0,     0,    65,
  179.     63,    35,    63,    29,    57,    68,     0,     0,     0,     0,
  180.      0,     0,    30,    31,    69,    70,    71,    72,    73,    66,
  181.      0,     0
  182. };
  183.  
  184. static const short yydefgoto[] = {     2,
  185.     12,    13,    33,    34,    14,    15,    16,    71,    17,    47,
  186.     18,    49,    50,    51,    19,    54,    55,    20,    56,    95,
  187.     21,    59,    60,    66,    86,   112,   100
  188. };
  189.  
  190. static const short yypact[] = {     5,
  191.     12,    27,-32768,-32768,-32768,   -14,     2,    11,    29,    40,
  192. -32768,     3,    22,    56,    14,    35,    65,    83,    84,    85,
  193.     86,     0,    92,    93,-32768,    94,-32768,    42,-32768,    31,
  194.     95,    96,    39,    68,-32768,    97,-32768,    79,    99,-32768,
  195. -32768,-32768,-32768,-32768,-32768,-32768,   -11,    98,    58,-32768,
  196.    100,    98,   101,    59,-32768,   104,-32768,    39,    60,-32768,
  197.     39,-32768,    90,-32768,-32768,-32768,-32768,-32768,    99,-32768,
  198.     61,   103,-32768,    92,-32768,    94,    94,    93,-32768,-32768,
  199. -32768,    94,-32768,-32768,-32768,     4,    67,   108,    23,-32768,
  200. -32768,-32768,-32768,-32768,    80,-32768,-32768,     4,     4,    72,
  201.     39,-32768,    39,-32768,-32768,    43,    55,     4,     4,     4,
  202.      4,    87,-32768,-32768,-32768,    43,    43,-32768,-32768,-32768,
  203.    113,-32768
  204. };
  205.  
  206. static const short yypgoto[] = {-32768,
  207. -32768,-32768,    76,    88,-32768,-32768,-32768,    45,-32768,-32768,
  208. -32768,-32768,    41,   -24,-32768,-32768,    38,-32768,-32768,-32768,
  209. -32768,-32768,    37,   -57,-32768,-32768,   -43
  210. };
  211.  
  212.  
  213. #define    YYLAST        119
  214.  
  215.  
  216. static const short yytable[] = {    53,
  217.     81,    58,    45,    84,    -1,     1,    72,    22,    -1,    97,
  218.     27,    73,    -1,    -1,    -1,    -1,    -1,    -1,    98,     3,
  219.     28,    37,    46,    23,    29,    -1,   121,    99,    30,   103,
  220.      4,   104,    24,    29,     5,     6,     7,     8,     9,    10,
  221.     31,    38,    32,   113,    29,   114,    65,    11,    30,    31,
  222.     25,    92,    93,    53,   106,   107,    39,    58,   110,   111,
  223.     31,    26,    65,    35,   116,   117,   118,   119,   108,   109,
  224.    110,   111,    40,    36,    67,    74,    78,    82,    88,   115,
  225.     75,    79,    83,    89,    88,   108,   109,   110,   111,   101,
  226.     41,    42,    43,    44,    48,    52,    57,    63,    64,    68,
  227.     69,    70,   105,    61,   -48,    90,    76,    77,    80,    85,
  228.    102,   120,   122,    87,    91,    94,     0,    62,    96
  229. };
  230.  
  231. static const short yycheck[] = {    24,
  232.     58,    26,     3,    61,     0,     1,    18,    22,     4,     6,
  233.      8,    23,     8,     9,    10,    11,    12,    13,    15,     8,
  234.     18,     8,    23,    22,     3,    21,     0,    24,     7,     7,
  235.      4,    89,    22,     3,     8,     9,    10,    11,    12,    13,
  236.     19,     7,    21,   101,     3,   103,    24,    21,     7,    19,
  237.     22,    76,    77,    78,    98,    99,    22,    82,    16,    17,
  238.     19,    22,    24,     8,   108,   109,   110,   111,    14,    15,
  239.     16,    17,     8,    18,     7,    18,    18,    18,    18,    25,
  240.     23,    23,    23,    23,    18,    14,    15,    16,    17,    23,
  241.      8,     8,     8,     8,     3,     3,     3,     3,     3,     3,
  242.     22,     3,    23,    28,     7,     3,     7,     7,     5,    20,
  243.      3,    25,     0,    69,    74,    78,    -1,    30,    82
  244. };
  245. #define YYPURE 1
  246.  
  247. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  248. #line 3 "bison.simple"
  249.  
  250. /* Skeleton output parser for bison,
  251.    Copyright (C) 1984 Bob Corbett and Richard Stallman
  252.  
  253.    This program is free software; you can redistribute it and/or modify
  254.    it under the terms of the GNU General Public License as published by
  255.    the Free Software Foundation; either version 1, or (at your option)
  256.    any later version.
  257.  
  258.    This program is distributed in the hope that it will be useful,
  259.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  260.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  261.    GNU General Public License for more details.
  262.  
  263.    You should have received a copy of the GNU General Public License
  264.    along with this program; if not, write to the Free Software
  265.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  266.  
  267.  
  268. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  269. #include <alloca.h>
  270. #endif
  271.  
  272. /* This is the parser code that is written into each bison parser
  273.   when the %semantic_parser declaration is not specified in the grammar.
  274.   It was written by Richard Stallman by simplifying the hairy parser
  275.   used when %semantic_parser is specified.  */
  276.  
  277. /* Note: there must be only one dollar sign in this file.
  278.    It is replaced by the list of actions, each action
  279.    as one case of the switch.  */
  280.  
  281. #define yyerrok        (yyerrstatus = 0)
  282. #define yyclearin    (yychar = YYEMPTY)
  283. #define YYEMPTY        -2
  284. #define YYEOF        0
  285. #define YYFAIL        goto yyerrlab;
  286. #define YYACCEPT    return(0)
  287. #define YYABORT     return(1)
  288. #define YYERROR        goto yyerrlab
  289.  
  290. #define YYTERROR    1
  291.  
  292. #ifndef YYIMPURE
  293. #define YYLEX        yylex()
  294. #endif
  295.  
  296. #ifndef YYPURE
  297. #define YYLEX        yylex(&yylval, &yylloc)
  298. #endif
  299.  
  300. /* If nonreentrant, generate the variables here */
  301.  
  302. #ifndef YYIMPURE
  303.  
  304. int    yychar;            /*  the lookahead symbol        */
  305. YYSTYPE    yylval;            /*  the semantic value of the        */
  306.                 /*  lookahead symbol            */
  307.  
  308. YYLTYPE yylloc;            /*  location data for the lookahead    */
  309.                 /*  symbol                */
  310.  
  311. int yynerrs;            /*  number of parse errors so far       */
  312. #endif  /* YYIMPURE */
  313.  
  314. #if YYDEBUG != 0
  315. int yydebug;            /*  nonzero means print parse trace    */
  316. /* Since this is uninitialized, it does not stop multiple parsers
  317.    from coexisting.  */
  318. #endif
  319.  
  320. /*  YYMAXDEPTH indicates the initial size of the parser's stacks    */
  321.  
  322. #ifndef    YYMAXDEPTH
  323. #define YYMAXDEPTH 200
  324. #endif
  325.  
  326. /*  YYMAXLIMIT is the maximum size the stacks can grow to
  327.     (effective only if the built-in stack extension method is used).  */
  328.  
  329. #ifndef YYMAXLIMIT
  330. #define YYMAXLIMIT 10000
  331. #endif
  332.  
  333.  
  334. #line 175 "bison.simple"
  335. int
  336. yyparse()
  337. {
  338.   register int yystate;
  339.   register int yyn;
  340.   register short *yyssp;
  341.   register YYSTYPE *yyvsp;
  342.   YYLTYPE *yylsp;
  343.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  344.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  345.  
  346.   short    yyssa[YYMAXDEPTH];    /*  the state stack            */
  347.   YYSTYPE yyvsa[YYMAXDEPTH];    /*  the semantic value stack        */
  348.   YYLTYPE yylsa[YYMAXDEPTH];    /*  the location stack            */
  349.  
  350.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  351.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  352.   YYLTYPE *yyls = yylsa;
  353.  
  354.   int yymaxdepth = YYMAXDEPTH;
  355.  
  356. #ifndef YYPURE
  357.   int yychar;
  358.   YYSTYPE yylval;
  359.   YYLTYPE yylloc;
  360.   int yynerrs;
  361. #endif
  362.  
  363.   YYSTYPE yyval;        /*  the variable used to return        */
  364.                 /*  semantic values from the action    */
  365.                 /*  routines                */
  366.  
  367.   int yylen;
  368.  
  369. #if YYDEBUG != 0
  370.   if (yydebug)
  371.     fprintf(stderr, "Starting parse\n");
  372. #endif
  373.  
  374.   yystate = 0;
  375.   yyerrstatus = 0;
  376.   yynerrs = 0;
  377.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  378.  
  379.   /* Initialize stack pointers.
  380.      Waste one element of value and location stack
  381.      so that they stay on the same level as the state stack.  */
  382.  
  383.   yyssp = yyss - 1;
  384.   yyvsp = yyvs;
  385.   yylsp = yyls;
  386.  
  387. /* Push a new state, which is found in  yystate  .  */
  388. /* In all cases, when you get here, the value and location stacks
  389.    have just been pushed. so pushing a state here evens the stacks.  */
  390. yynewstate:
  391.  
  392.   *++yyssp = yystate;
  393.  
  394.   if (yyssp >= yyss + yymaxdepth - 1)
  395.     {
  396.       /* Give user a chance to reallocate the stack */
  397.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  398.       YYSTYPE *yyvs1 = yyvs;
  399.       YYLTYPE *yyls1 = yyls;
  400.       short *yyss1 = yyss;
  401.  
  402.       /* Get the current used size of the three stacks, in elements.  */
  403.       int size = yyssp - yyss + 1;
  404.  
  405. #ifdef yyoverflow
  406.       /* Each stack pointer address is followed by the size of
  407.      the data in use in that stack, in bytes.  */
  408.       yyoverflow("parser stack overflow",
  409.          &yyss1, size * sizeof (*yyssp),
  410.          &yyvs1, size * sizeof (*yyvsp),
  411.          &yyls1, size * sizeof (*yylsp),
  412.          &yymaxdepth);
  413.  
  414.       yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
  415. #else /* no yyoverflow */
  416.       /* Extend the stack our own way.  */
  417.       if (yymaxdepth >= YYMAXLIMIT)
  418.     yyerror("parser stack overflow");
  419.       yymaxdepth *= 2;
  420.       if (yymaxdepth > YYMAXLIMIT)
  421.     yymaxdepth = YYMAXLIMIT;
  422.       yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
  423.       bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  424.       yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
  425.       bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  426. #ifdef YYLSP_NEEDED
  427.       yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
  428.       bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  429. #endif
  430. #endif /* no yyoverflow */
  431.  
  432.       yyssp = yyss + size - 1;
  433.       yyvsp = yyvs + size - 1;
  434. #ifdef YYLSP_NEEDED
  435.       yylsp = yyls + size - 1;
  436. #endif
  437.  
  438. #if YYDEBUG != 0
  439.       if (yydebug)
  440.     fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
  441. #endif
  442.  
  443.       if (yyssp >= yyss + yymaxdepth - 1)
  444.     YYABORT;
  445.     }
  446.  
  447. #if YYDEBUG != 0
  448.   if (yydebug)
  449.     fprintf(stderr, "Entering state %d\n", yystate);
  450. #endif
  451.  
  452. /* Do appropriate processing given the current state.  */
  453. /* Read a lookahead token if we need one and don't already have one.  */
  454. yyresume:
  455.  
  456.   /* First try to decide what to do without reference to lookahead token.  */
  457.  
  458.   yyn = yypact[yystate];
  459.   if (yyn == YYFLAG)
  460.     goto yydefault;
  461.  
  462.   /* Not known => get a lookahead token if don't already have one.  */
  463.  
  464.   /* yychar is either YYEMPTY or YYEOF
  465.      or a valid token in external form.  */
  466.  
  467.   if (yychar == YYEMPTY)
  468.     {
  469. #if YYDEBUG != 0
  470.       if (yydebug)
  471.     fprintf(stderr, "Reading a token: ");
  472. #endif
  473.       yychar = YYLEX;
  474.     }
  475.  
  476.   /* Convert token to internal form (in yychar1) for indexing tables with */
  477.  
  478.   if (yychar <= 0)        /* This means end of input. */
  479.     {
  480.       yychar1 = 0;
  481.       yychar = YYEOF;        /* Don't call YYLEX any more */
  482.  
  483. #if YYDEBUG != 0
  484.       if (yydebug)
  485.     fprintf(stderr, "Now at end of input.\n");
  486. #endif
  487.     }
  488.   else
  489.     {
  490.       yychar1 = YYTRANSLATE(yychar);
  491.  
  492. #if YYDEBUG != 0
  493.       if (yydebug)
  494.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  495. #endif
  496.     }
  497.  
  498.   yyn += yychar1;
  499.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  500.     goto yydefault;
  501.  
  502.   yyn = yytable[yyn];
  503.  
  504.   /* yyn is what to do for this token type in this state.
  505.      Negative => reduce, -yyn is rule number.
  506.      Positive => shift, yyn is new state.
  507.        New state is final state => don't bother to shift,
  508.        just return success.
  509.      0, or most negative number => error.  */
  510.  
  511.   if (yyn < 0)
  512.     {
  513.       if (yyn == YYFLAG)
  514.     goto yyerrlab;
  515.       yyn = -yyn;
  516.       goto yyreduce;
  517.     }
  518.   else if (yyn == 0)
  519.     goto yyerrlab;
  520.  
  521.   if (yyn == YYFINAL)
  522.     YYACCEPT;
  523.  
  524.   /* Shift the lookahead token.  */
  525.  
  526. #if YYDEBUG != 0
  527.   if (yydebug)
  528.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  529. #endif
  530.  
  531.   /* Discard the token being shifted unless it is eof.  */
  532.   if (yychar != YYEOF)
  533.     yychar = YYEMPTY;
  534.  
  535.   *++yyvsp = yylval;
  536. #ifdef YYLSP_NEEDED
  537.   *++yylsp = yylloc;
  538. #endif
  539.  
  540.   /* count tokens shifted since error; after three, turn off error status.  */
  541.   if (yyerrstatus) yyerrstatus--;
  542.  
  543.   yystate = yyn;
  544.   goto yynewstate;
  545.  
  546. /* Do the default action for the current state.  */
  547. yydefault:
  548.  
  549.   yyn = yydefact[yystate];
  550.   if (yyn == 0)
  551.     goto yyerrlab;
  552.  
  553. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  554. yyreduce:
  555.   yylen = yyr2[yyn];
  556.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  557.  
  558. #if YYDEBUG != 0
  559.   if (yydebug)
  560.     {
  561.       if (yylen == 1)
  562.     fprintf (stderr, "Reducing 1 value via line %d, ",
  563.          yyrline[yyn]);
  564.       else
  565.     fprintf (stderr, "Reducing %d values via line %d, ",
  566.          yylen, yyrline[yyn]);
  567.     }
  568. #endif
  569.  
  570.  
  571.   switch (yyn) {
  572.  
  573. case 12:
  574. #line 80 "parse.y"
  575. {
  576.         struct link *l;
  577.  
  578.         l = addlink(yyvsp[-2].y_node, yyvsp[-1].y_s.ys_node, yyvsp[0].y_cost, yyvsp[-1].y_s.ys_net, yyvsp[-1].y_s.ys_dir);
  579.         if (GATEWAYED(yyvsp[-1].y_s.ys_node))
  580.             l->l_flag |= LGATEWAY;
  581.         if (yyvsp[-1].y_s.ys_flag & TERMINAL)
  582.             l->l_flag |= LTERMINAL;
  583.       ;
  584.     break;}
  585. case 13:
  586. #line 89 "parse.y"
  587. {
  588.         struct link *l;
  589.  
  590.         l = addlink(yyvsp[-3].y_node, yyvsp[-1].y_s.ys_node, yyvsp[0].y_cost, yyvsp[-1].y_s.ys_net, yyvsp[-1].y_s.ys_dir);
  591.         if (GATEWAYED(yyvsp[-1].y_s.ys_node))
  592.             l->l_flag |= LGATEWAY;
  593.         if (yyvsp[-1].y_s.ys_flag & TERMINAL)
  594.             l->l_flag |= LTERMINAL;
  595.       ;
  596.     break;}
  597. case 15:
  598. #line 101 "parse.y"
  599. {yyval.y_node = addnode(yyvsp[0].y_name);;
  600.     break;}
  601. case 16:
  602. #line 102 "parse.y"
  603. {yyval.y_node = addnode("private");;
  604.     break;}
  605. case 17:
  606. #line 103 "parse.y"
  607. {yyval.y_node = addnode("dead");;
  608.     break;}
  609. case 18:
  610. #line 104 "parse.y"
  611. {yyval.y_node = addnode("delete");;
  612.     break;}
  613. case 19:
  614. #line 105 "parse.y"
  615. {yyval.y_node = addnode("file");;
  616.     break;}
  617. case 20:
  618. #line 106 "parse.y"
  619. {yyval.y_node = addnode("adjust");;
  620.     break;}
  621. case 21:
  622. #line 109 "parse.y"
  623. {
  624.         yyval.y_s = yyvsp[0].y_s;
  625.         yyval.y_s.ys_net = DEFNET;
  626.         yyval.y_s.ys_dir = DEFDIR;
  627.       ;
  628.     break;}
  629. case 22:
  630. #line 114 "parse.y"
  631. {
  632.         yyval.y_s = yyvsp[0].y_s;
  633.         yyval.y_s.ys_net = yyvsp[-1].y_net;
  634.         yyval.y_s.ys_dir = LRIGHT;
  635.       ;
  636.     break;}
  637. case 23:
  638. #line 119 "parse.y"
  639. {
  640.         yyval.y_s = yyvsp[-1].y_s;
  641.         yyval.y_s.ys_net = yyvsp[0].y_net;
  642.         yyval.y_s.ys_dir = LLEFT;
  643.       ;
  644.     break;}
  645. case 24:
  646. #line 126 "parse.y"
  647. {
  648.         yyval.y_s.ys_node = addnode(yyvsp[0].y_name);
  649.         yyval.y_s.ys_flag = 0;
  650.       ;
  651.     break;}
  652. case 25:
  653. #line 130 "parse.y"
  654. {
  655.         Tcount++;
  656.         yyval.y_s.ys_node = addnode(yyvsp[-1].y_name);
  657.         yyval.y_s.ys_flag = TERMINAL;
  658.       ;
  659.     break;}
  660. case 26:
  661. #line 137 "parse.y"
  662. {alias(yyvsp[-2].y_node, addnode(yyvsp[0].y_name));;
  663.     break;}
  664. case 27:
  665. #line 138 "parse.y"
  666. {alias(yyvsp[-2].y_node, addnode(yyvsp[0].y_name));;
  667.     break;}
  668. case 29:
  669. #line 142 "parse.y"
  670. {fixnet(yyvsp[-4].y_node, yyvsp[-2].y_node, yyvsp[0].y_cost, DEFNET, DEFDIR);;
  671.     break;}
  672. case 30:
  673. #line 143 "parse.y"
  674. {fixnet(yyvsp[-5].y_node, yyvsp[-2].y_node, yyvsp[0].y_cost, yyvsp[-4].y_net, LRIGHT);;
  675.     break;}
  676. case 31:
  677. #line 144 "parse.y"
  678. {fixnet(yyvsp[-5].y_node, yyvsp[-3].y_node, yyvsp[0].y_cost, yyvsp[-1].y_net, LLEFT);;
  679.     break;}
  680. case 32:
  681. #line 147 "parse.y"
  682. {yyval.y_node = 0;    /* anonymous net */;
  683.     break;}
  684. case 33:
  685. #line 148 "parse.y"
  686. {yyval.y_node = yyvsp[-1].y_node;    /* named net */;
  687.     break;}
  688. case 34:
  689. #line 151 "parse.y"
  690. {yyval.y_node = addnode(yyvsp[0].y_name);;
  691.     break;}
  692. case 35:
  693. #line 152 "parse.y"
  694. {
  695.         node *n;
  696.  
  697.         n = addnode(yyvsp[0].y_name);
  698.         if (n->n_net == 0) {
  699.             n->n_net = yyvsp[-2].y_node;
  700.             yyval.y_node = n;
  701.         }
  702.       ;
  703.     break;}
  704. case 38:
  705. #line 165 "parse.y"
  706. {fixprivate();;
  707.     break;}
  708. case 39:
  709. #line 168 "parse.y"
  710. {addprivate(yyvsp[0].y_name)->n_flag |= ISPRIVATE;;
  711.     break;}
  712. case 40:
  713. #line 169 "parse.y"
  714. {addprivate(yyvsp[0].y_name)->n_flag |= ISPRIVATE;;
  715.     break;}
  716. case 46:
  717. #line 180 "parse.y"
  718. {deadlink(addnode(yyvsp[0].y_name), (node *) 0);;
  719.     break;}
  720. case 47:
  721. #line 181 "parse.y"
  722. {deadlink(yyvsp[-2].y_node, yyvsp[0].y_node);;
  723.     break;}
  724. case 48:
  725. #line 184 "parse.y"
  726. {yyval.y_node = addnode(yyvsp[0].y_name);;
  727.     break;}
  728. case 53:
  729. #line 193 "parse.y"
  730. {
  731.         node *n;
  732.  
  733.         n = addnode(yyvsp[0].y_name);
  734.         deletelink(n, (node *) 0);
  735.         n->n_flag |= ISPRIVATE;
  736.         /* reset Home if it's deleted */
  737.         if (n == Home)
  738.             Home = addnode(Home->n_name);
  739.       ;
  740.     break;}
  741. case 54:
  742. #line 203 "parse.y"
  743. {deletelink(yyvsp[-2].y_node, yyvsp[0].y_node);;
  744.     break;}
  745. case 55:
  746. #line 206 "parse.y"
  747. {Scanstate = FILENAME;;
  748.     break;}
  749. case 56:
  750. #line 206 "parse.y"
  751. {Scanstate = OTHER;;
  752.     break;}
  753. case 57:
  754. #line 206 "parse.y"
  755. {
  756.         Lineno = 0;
  757.         Cfile = strsave(yyvsp[-2].y_name);
  758.     ;
  759.     break;}
  760. case 62:
  761. #line 218 "parse.y"
  762. {adjust(yyvsp[-1].y_node, yyvsp[0].y_cost);;
  763.     break;}
  764. case 63:
  765. #line 220 "parse.y"
  766. {yyval.y_cost = DEFCOST;    /* empty -- cost is always optional */;
  767.     break;}
  768. case 64:
  769. #line 221 "parse.y"
  770. {Scanstate = COSTING;;
  771.     break;}
  772. case 65:
  773. #line 221 "parse.y"
  774. {Scanstate = OTHER;;
  775.     break;}
  776. case 66:
  777. #line 222 "parse.y"
  778. {yyval.y_cost = yyvsp[-2].y_cost;;
  779.     break;}
  780. case 68:
  781. #line 226 "parse.y"
  782. {yyval.y_cost = -yyvsp[0].y_cost;;
  783.     break;}
  784. case 69:
  785. #line 227 "parse.y"
  786. {yyval.y_cost = yyvsp[-1].y_cost;;
  787.     break;}
  788. case 70:
  789. #line 228 "parse.y"
  790. {yyval.y_cost = yyvsp[-2].y_cost + yyvsp[0].y_cost;;
  791.     break;}
  792. case 71:
  793. #line 229 "parse.y"
  794. {yyval.y_cost = yyvsp[-2].y_cost - yyvsp[0].y_cost;;
  795.     break;}
  796. case 72:
  797. #line 230 "parse.y"
  798. {yyval.y_cost = yyvsp[-2].y_cost * yyvsp[0].y_cost;;
  799.     break;}
  800. case 73:
  801. #line 231 "parse.y"
  802. {
  803.         if (yyvsp[0].y_cost == 0)
  804.             yyerror("zero divisor\n");
  805.         else
  806.             yyval.y_cost = yyvsp[-2].y_cost / yyvsp[0].y_cost;
  807.       ;
  808.     break;}
  809. }
  810.    /* the action file gets copied in in place of this dollarsign */
  811. #line 412 "bison.simple"
  812.  
  813.   yyvsp -= yylen;
  814.   yyssp -= yylen;
  815. #ifdef YYLSP_NEEDED
  816.   yylsp -= yylen;
  817. #endif
  818.  
  819. #if YYDEBUG != 0
  820.   if (yydebug)
  821.     {
  822.       short *ssp1 = yyss - 1;
  823.       fprintf (stderr, "state stack now");
  824.       while (ssp1 != yyssp)
  825.     fprintf (stderr, " %d", *++ssp1);
  826.       fprintf (stderr, "\n");
  827.     }
  828. #endif
  829.  
  830.   *++yyvsp = yyval;
  831.  
  832. #ifdef YYLSP_NEEDED
  833.   yylsp++;
  834.   if (yylen == 0)
  835.     {
  836.       yylsp->first_line = yylloc.first_line;
  837.       yylsp->first_column = yylloc.first_column;
  838.       yylsp->last_line = (yylsp-1)->last_line;
  839.       yylsp->last_column = (yylsp-1)->last_column;
  840.       yylsp->text = 0;
  841.     }
  842.   else
  843.     {
  844.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  845.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  846.     }
  847. #endif
  848.  
  849.   /* Now "shift" the result of the reduction.
  850.      Determine what state that goes to,
  851.      based on the state we popped back to
  852.      and the rule number reduced by.  */
  853.  
  854.   yyn = yyr1[yyn];
  855.  
  856.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  857.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  858.     yystate = yytable[yystate];
  859.   else
  860.     yystate = yydefgoto[yyn - YYNTBASE];
  861.  
  862.   goto yynewstate;
  863.  
  864. yyerrlab:   /* here on detecting error */
  865.  
  866.   if (! yyerrstatus)
  867.     /* If not already recovering from an error, report this error.  */
  868.     {
  869.       ++yynerrs;
  870.       yyerror("parse error");
  871.     }
  872.  
  873.   if (yyerrstatus == 3)
  874.     {
  875.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  876.  
  877.       /* return failure if at end of input */
  878.       if (yychar == YYEOF)
  879.     YYABORT;
  880.  
  881. #if YYDEBUG != 0
  882.       if (yydebug)
  883.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  884. #endif
  885.  
  886.       yychar = YYEMPTY;
  887.     }
  888.  
  889.   /* Else will try to reuse lookahead token
  890.      after shifting the error token.  */
  891.  
  892.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  893.  
  894.   goto yyerrhandle;
  895.  
  896. yyerrdefault:  /* current state does not do anything special for the error token. */
  897.  
  898. #if 0
  899.   /* This is wrong; only states that explicitly want error tokens
  900.      should shift them.  */
  901.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  902.   if (yyn) goto yydefault;
  903. #endif
  904.  
  905. yyerrpop:   /* pop the current state because it cannot handle the error token */
  906.  
  907.   if (yyssp == yyss) YYABORT;
  908.   yyvsp--;
  909.   yystate = *--yyssp;
  910. #ifdef YYLSP_NEEDED
  911.   yylsp--;
  912. #endif
  913.  
  914. #if YYDEBUG != 0
  915.   if (yydebug)
  916.     {
  917.       short *ssp1 = yyss - 1;
  918.       fprintf (stderr, "Error: state stack now");
  919.       while (ssp1 != yyssp)
  920.     fprintf (stderr, " %d", *++ssp1);
  921.       fprintf (stderr, "\n");
  922.     }
  923. #endif
  924.  
  925. yyerrhandle:
  926.  
  927.   yyn = yypact[yystate];
  928.   if (yyn == YYFLAG)
  929.     goto yyerrdefault;
  930.  
  931.   yyn += YYTERROR;
  932.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  933.     goto yyerrdefault;
  934.  
  935.   yyn = yytable[yyn];
  936.   if (yyn < 0)
  937.     {
  938.       if (yyn == YYFLAG)
  939.     goto yyerrpop;
  940.       yyn = -yyn;
  941.       goto yyreduce;
  942.     }
  943.   else if (yyn == 0)
  944.     goto yyerrpop;
  945.  
  946.   if (yyn == YYFINAL)
  947.     YYACCEPT;
  948.  
  949. #if YYDEBUG != 0
  950.   if (yydebug)
  951.     fprintf(stderr, "Shifting error token, ");
  952. #endif
  953.  
  954.   *++yyvsp = yylval;
  955. #ifdef YYLSP_NEEDED
  956.   *++yylsp = yylloc;
  957. #endif
  958.  
  959.   yystate = yyn;
  960.   goto yynewstate;
  961. }
  962. #line 238 "parse.y"
  963.  
  964.  
  965. void
  966. #ifdef YYDEBUG
  967. /*VARARGS1*/
  968. yyerror(fmt, arg)
  969.     char *fmt, *arg;
  970. #else
  971. yyerror(s)
  972.     char *s;
  973. #endif
  974. {
  975.     /* a concession to bsd error(1) */
  976.     fprintf(stderr, "\"%s\", ", Cfile);
  977. #ifdef YYDEBUG
  978.     fprintf(stderr, "line %d: ", Lineno);
  979.     fprintf(stderr, fmt, arg);
  980.     putc('\n', stderr);
  981. #else
  982.     fprintf(stderr, "line %d: %s\n", Lineno, s);
  983. #endif
  984. }
  985.  
  986. /*
  987.  * patch in the costs of getting on/off the network.
  988.  *
  989.  * for each network member on netlist, add links:
  990.  *    network -> member    cost = 0;
  991.  *    member -> network    cost = parameter.
  992.  *
  993.  * if network and member both require gateways, assume network
  994.  * is a gateway to member (but not v.v., to avoid such travesties
  995.  * as topaz!seismo.css.gov.edu.rutgers).
  996.  *
  997.  * note that members can have varying costs to a network, by suitable
  998.  * multiple declarations.  this is a feechur, albeit a useless one.
  999.  */
  1000. STATIC void
  1001. fixnet(network, nlist, cost, netchar, netdir)
  1002.     register node *network;
  1003.     node *nlist;
  1004.     Cost cost;
  1005.     char netchar, netdir;
  1006. {    register node *member, *nextnet;
  1007.     link *l;
  1008.     static int netanon = 0;
  1009.     char anon[25];
  1010.  
  1011.     if (network == 0) {
  1012.         sprintf(anon, "[unnamed net %d]", netanon++);
  1013.         network = addnode(anon);
  1014.     }
  1015.     network->n_flag |= NNET;
  1016.  
  1017.     /* insert the links */
  1018.     for (member = nlist ; member; member = nextnet) {
  1019.  
  1020.         /* network -> member, cost is 0 */
  1021.         l = addlink(network, member, (Cost) 0, netchar, netdir);
  1022.         if (GATEWAYED(network) && GATEWAYED(member))
  1023.             l->l_flag |= LGATEWAY;
  1024.  
  1025.         /* member -> network, cost is parameter */
  1026.         /* never ever ever crawl up from a domain*/
  1027.         if (!ISADOMAIN(network))
  1028.             (void) addlink(member, network, cost, netchar, netdir);
  1029.  
  1030.         nextnet = member->n_net;
  1031.         member->n_net = 0;    /* clear for later use */
  1032.     }
  1033. }
  1034.  
  1035. /* scanner */
  1036.  
  1037. #define QUOTE '"'
  1038. #define STR_EQ(s1, s2) (s1[2] == s2[2] && strcmp(s1, s2) == 0)
  1039. #define NLRETURN() {Scanstate = NEWLINE; return YEOL;}
  1040.  
  1041. static struct ctable {
  1042.     char *cname;
  1043.     Cost cval;
  1044. } ctable[] = {
  1045.     /* ordered by frequency of appearance in a "typical" dataset */
  1046.     {"DIRECT", 200},
  1047.     {"DEMAND", 300},
  1048.     {"DAILY", 5000},
  1049.     {"HOURLY", 500},
  1050.     {"DEDICATED", 100},
  1051.     {"EVENING", 2000},
  1052.     {"LOCAL", 25},
  1053.     {"LOW", 5},    /* baud rate, quality penalty */
  1054.     {"DEAD", MILLION},
  1055.     {"POLLED", 5000},
  1056.     {"WEEKLY", 30000},
  1057.     {"HIGH", -5},    /* baud rate, quality bonus */
  1058.     {"FAST", -80},    /* high speed (>= 9.6 kbps) modem */
  1059.     /* deprecated */
  1060.     {"ARPA", 100},
  1061.     {"DIALED", 300},
  1062.     {0, 0}
  1063. };
  1064.  
  1065. STATIC int
  1066. yylex()
  1067. {    static char retbuf[128];    /* for return to yacc part */
  1068.     register int c;
  1069.     register char *buf = retbuf;
  1070.     register struct ctable *ct;
  1071.     register Cost cost;
  1072.     char errbuf[128];
  1073.  
  1074.     if (feof(stdin) && yywrap())
  1075.         return EOF;
  1076.  
  1077.     /* count lines, skip over space and comments */
  1078.     if ((c = getchar()) == EOF)
  1079.         NLRETURN();
  1080.     
  1081. continuation:
  1082.     while (c == ' ' || c == '\t')
  1083.         if ((c = getchar()) == EOF)
  1084.             NLRETURN();
  1085.  
  1086.     if (c == '#')
  1087.         while ((c = getchar()) != '\n')
  1088.             if (c == EOF)
  1089.                 NLRETURN();
  1090.  
  1091.     /* scan token */
  1092.     if (c == '\n') {
  1093.         Lineno++;
  1094.         if ((c = getchar()) != EOF) {
  1095.             if (c == ' ' || c == '\t')
  1096.                 goto continuation;
  1097.             ungetc(c, stdin);
  1098.         }
  1099.         NLRETURN();
  1100.     }
  1101.  
  1102.     switch(Scanstate) {
  1103.     case COSTING:
  1104.         if (isdigit(c)) {
  1105.             cost = c - '0';
  1106.             for (c = getchar(); isdigit(c); c = getchar())
  1107.                 cost = (cost * 10) + c - '0';
  1108.             ungetc(c, stdin);
  1109.             yylval.y_cost = cost;
  1110.             return COST;
  1111.         }
  1112.  
  1113.         if (getword(buf, c) == 0) {
  1114.             for (ct = ctable; ct->cname; ct++)
  1115.                 if (STR_EQ(buf, ct->cname)) {
  1116.                     yylval.y_cost = ct->cval;
  1117.                     return COST;
  1118.                 }
  1119.             sprintf(errbuf, "unknown cost (%s), using default", buf);
  1120.             yyerror(errbuf);
  1121.             yylval.y_cost = DEFCOST;
  1122.             return COST;
  1123.         }
  1124.  
  1125.         return c;    /* pass the buck */
  1126.  
  1127.     case NEWLINE:
  1128.         Scanstate = OTHER;
  1129.         if (getword(buf, c) != 0)
  1130.             return c;
  1131.         /*
  1132.          * special purpose tokens.
  1133.          *
  1134.          * the "switch" serves the dual-purpose of recognizing
  1135.          * unquoted tokens only.
  1136.          */
  1137.         switch(c) {
  1138.         case 'p':
  1139.             if (STR_EQ(buf, "private"))
  1140.                 return PRIVATE;
  1141.             break;
  1142.         case 'd':
  1143.             if (STR_EQ(buf, "dead"))
  1144.                 return DEAD;
  1145.             if (STR_EQ(buf, "delete"))
  1146.                 return DELETE;
  1147.             break;
  1148.         case 'f':
  1149.             if (STR_EQ(buf, "file"))
  1150.                 return FILETOK;
  1151.             break;
  1152.         case 'a':
  1153.             if (STR_EQ(buf, "adjust"))
  1154.                 return ADJUST;
  1155.             break;
  1156.         }
  1157.  
  1158.         yylval.y_name = buf;
  1159.         return HOST;
  1160.  
  1161.     case FILENAME:
  1162.         while (c != EOF && isprint(c)) {
  1163.             if (c == ' ' || c == '\t' || c == '\n' || c == '}')
  1164.                 break;
  1165.             *buf++ = c;
  1166.             c = getchar();
  1167.         }
  1168.         if (c != EOF)
  1169.             ungetc(c, stdin);
  1170.         *buf = 0;
  1171.         yylval.y_name = retbuf;
  1172.         return STRING;
  1173.     }
  1174.  
  1175.     if (getword(buf, c) == 0) {
  1176.         yylval.y_name = buf;
  1177.         return SITE;
  1178.     }
  1179.  
  1180.     if (index(Netchars, c)) {
  1181.         yylval.y_net = c;
  1182.         return NET;
  1183.     }
  1184.  
  1185.     return c;
  1186. }
  1187.  
  1188. /*
  1189.  * fill str with the next word in [0-9A-Za-z][-._0-9A-Za-z]+ or a quoted
  1190.  * string that contains no newline.  return -1 on failure or EOF, 0 o.w.
  1191.  */ 
  1192. STATIC int
  1193. getword(str, c)
  1194.     register char *str;
  1195.     register int c;
  1196. {
  1197.     if (c == QUOTE) {
  1198.         while ((c = getchar()) != QUOTE) {
  1199.             if (c == '\n') {
  1200.                 yyerror("newline in quoted string\n");
  1201.                 ungetc(c, stdin);
  1202.                 return -1;
  1203.             }
  1204.             if (c == EOF) {
  1205.                 yyerror("EOF in quoted string\n");
  1206.                 return -1;
  1207.             }
  1208.             *str++ = c;
  1209.         }
  1210.         *str = 0;
  1211.         return 0;
  1212.     }
  1213.  
  1214.     /* host name must start with alphanumeric or `.' */
  1215.     if (!isalnum(c) && c != '.')
  1216.         return -1;
  1217.  
  1218. yymore:
  1219.     do {
  1220.         *str++ = c;
  1221.         c = getchar();
  1222.     } while (isalnum(c) || c == '.' || c == '_');
  1223.  
  1224.     if (c == '-' && Scanstate != COSTING)
  1225.         goto yymore;
  1226.  
  1227.     ungetc(c, stdin);
  1228.     *str = 0;
  1229.     return 0;
  1230. }
  1231.  
  1232. STATIC int
  1233. yywrap()
  1234. {    char errbuf[100];
  1235.  
  1236.     fixprivate();    /* munge private host definitions */
  1237.     Lineno = 1;
  1238.     while (optind < Argc) {
  1239.         if (freopen((Cfile = Argv[optind++]), "r", stdin) != 0)
  1240.             return 0;
  1241.         sprintf(errbuf, "%s: %s", Argv[0], Cfile);
  1242.         perror(errbuf);
  1243.     }
  1244.     freopen(DEVNULL, "r", stdin);
  1245.     return -1;
  1246. }
  1247.  
  1248. STATIC void
  1249. adjust(n, cost)
  1250.     node *n;
  1251.     Cost cost;
  1252. {    link *l;
  1253.  
  1254.     n->n_cost += cost;    /* cumulative */
  1255.  
  1256.     /* hit existing links */
  1257.     for (l = n->n_link; l; l = l->l_next) {
  1258.         if ((l->l_cost += cost) < 0) {
  1259.             char buf[100];
  1260.  
  1261.             l->l_flag |= LDEAD;
  1262.             sprintf(buf, "link to %s deleted with negative cost",
  1263.                             l->l_to->n_name);
  1264.             yyerror(buf);
  1265.         }
  1266.     }
  1267. }
  1268.