home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 5 / DATAFILE_PDCD5.iso / utilities / o / orbits / !orbits / c / orbpar < prev    next >
Encoding:
Text File  |  1991-11-16  |  16.3 KB  |  676 lines
  1. /*  A Bison parser, made from y.orbpar  */
  2.  
  3. #define    NUM    258
  4. #define    RETURN    259
  5.  
  6. #line 27 "y.orbpar"
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <stddef.h>
  11. extern int    yyline;
  12. extern int    number;
  13. extern char   *yytext;
  14. extern int    yylex(void);
  15. extern double *x,*y,*dx,*dy,*mass;
  16. static void   yyerror(char *);
  17. static void   add_body(double,double,double,double,double);
  18.  
  19. #line 40 "y.orbpar"
  20. typedef union
  21. {
  22.   int    ival;
  23.   double dval;
  24. } YYSTYPE;
  25.  
  26. #ifndef YYLTYPE
  27. typedef
  28.   struct yyltype
  29.     {
  30.       int timestamp;
  31.       int first_line;
  32.       int first_column;
  33.       int last_line;
  34.       int last_column;
  35.       char *text;
  36.    }
  37.   yyltype;
  38.  
  39. #define YYLTYPE yyltype
  40. #endif
  41.  
  42.  
  43. #ifndef YYDEBUG
  44. #define YYDEBUG 0
  45. #endif
  46.  
  47. #include <stdio.h>
  48. #ifdef __STDC__
  49. #include <stdlib.h>
  50. #endif
  51.  
  52. #ifndef __STDC__
  53. #define const
  54. #endif
  55.  
  56. #define    YYFINAL        16
  57. #define    YYFLAG        -32768
  58. #define    YYNTBASE    7
  59.  
  60. #define YYTRANSLATE(x) ((unsigned)(x) <= 259 ? yytranslate[x] : 10)
  61.  
  62. static const char yytranslate[] = {     0,
  63.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  64.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  65.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  66.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  67.      2,     2,     2,     6,     2,     2,     5,     2,     2,     2,
  68.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  69.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  70.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  71.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  72.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  73.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  74.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  75.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  76.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  77.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  78.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  79.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  80.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  81.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  82.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  83.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  84.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  85.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  86.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  87.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  88.      2,     2,     2,     2,     2,     1,     2,     3,     4
  89. };
  90.  
  91. #if YYDEBUG != 0
  92. static const short yyrline[] = {     0,
  93.     51,    52,    55,    59,    62
  94. };
  95.  
  96. static const char * const yytname[] = {     0,
  97. "error","$illegal.","NUM","RETURN","'/'","','","list"
  98. };
  99. #endif
  100.  
  101. static const short yyr1[] = {     0,
  102.      7,     7,     8,     8,     9
  103. };
  104.  
  105. static const short yyr2[] = {     0,
  106.      1,     3,     9,     0,     1
  107. };
  108.  
  109. static const short yydefact[] = {     4,
  110.      5,     0,     1,     0,     4,     0,     2,     0,     0,     0,
  111.      0,     0,     0,     3,     0,     0
  112. };
  113.  
  114. static const short yydefgoto[] = {     2,
  115.      3,     4
  116. };
  117.  
  118. static const short yypact[] = {    -2,
  119. -32768,     2,-32768,    -1,    -2,    -2,-32768,     3,    -2,     5,
  120.     -2,     6,    -2,-32768,     8,-32768
  121. };
  122.  
  123. static const short yypgoto[] = {-32768,
  124.      9,    -6
  125. };
  126.  
  127.  
  128. #define    YYLAST        14
  129.  
  130.  
  131. static const short yytable[] = {     8,
  132.      1,    15,    10,     6,    12,     5,    14,    16,     9,    11,
  133.      0,    13,     0,     7
  134. };
  135.  
  136. static const short yycheck[] = {     6,
  137.      3,     0,     9,     5,    11,     4,    13,     0,     6,     5,
  138.     -1,     6,    -1,     5
  139. };
  140. #define YYPURE 1
  141.  
  142. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  143. #line 3 "bison.simple"
  144.  
  145. /* Skeleton output parser for bison,
  146.    Copyright (C) 1984 Bob Corbett and Richard Stallman
  147.  
  148.    This program is free software; you can redistribute it and/or modify
  149.    it under the terms of the GNU General Public License as published by
  150.    the Free Software Foundation; either version 1, or (at your option)
  151.    any later version.
  152.  
  153.    This program is distributed in the hope that it will be useful,
  154.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  155.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  156.    GNU General Public License for more details.
  157.  
  158.    You should have received a copy of the GNU General Public License
  159.    along with this program; if not, write to the Free Software
  160.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  161.  
  162.  
  163. /* This is the parser code that is written into each bison parser
  164.   when the %semantic_parser declaration is not specified in the grammar.
  165.   It was written by Richard Stallman by simplifying the hairy parser
  166.   used when %semantic_parser is specified.  */
  167.  
  168. /* Note: there must be only one dollar sign in this file.
  169.    It is replaced by the list of actions, each action
  170.    as one case of the switch.  */
  171.  
  172. #define yyerrok        (yyerrstatus = 0)
  173. #define yyclearin    (yychar = YYEMPTY)
  174. #define YYEMPTY        -2
  175. #define YYEOF        0
  176. #define YYFAIL        goto yyerrlab;
  177. #define YYACCEPT    return(0)
  178. #define YYABORT     return(1)
  179. #define YYERROR        goto yyerrlab
  180.  
  181. #define YYTERROR    1
  182. #define YYERRCODE    256
  183.  
  184. #ifndef YYIMPURE
  185. #define YYLEX        yylex()
  186. #endif
  187.  
  188. #ifndef YYPURE
  189. #define YYLEX        yylex(&yylval, &yylloc)
  190. #endif
  191.  
  192. /* If nonreentrant, generate the variables here */
  193.  
  194. #ifndef YYIMPURE
  195.  
  196. int    yychar;            /*  the lookahead symbol        */
  197. YYSTYPE    yylval;            /*  the semantic value of the        */
  198.                 /*  lookahead symbol            */
  199.  
  200. YYLTYPE yylloc;            /*  location data for the lookahead    */
  201.                 /*  symbol                */
  202.  
  203. int yynerrs;            /*  number of parse errors so far       */
  204. #endif  /* YYIMPURE */
  205.  
  206. #if YYDEBUG != 0
  207. int yydebug;            /*  nonzero means print parse trace    */
  208. /* Since this is uninitialized, it does not stop multiple parsers
  209.    from coexisting.  */
  210. #endif
  211.  
  212. /*  YYMAXDEPTH indicates the initial size of the parser's stacks    */
  213.  
  214. #ifndef    YYMAXDEPTH
  215. #define YYMAXDEPTH 200
  216. #endif
  217.  
  218. /*  YYMAXLIMIT is the maximum size the stacks can grow to
  219.     (effective only if the built-in stack extension method is used).  */
  220.  
  221. #ifndef YYMAXLIMIT
  222. #define YYMAXLIMIT 10000
  223. #endif
  224.  
  225.  
  226. #line 86 "bison.simple"
  227. int
  228. yyparse()
  229. {
  230.   register int yystate;
  231.   register int yyn;
  232.   register short *yyssp;
  233.   register YYSTYPE *yyvsp;
  234.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  235.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  236.  
  237.   /*  yyss: the state stack            */
  238.   /*  yyvs: the semantic value stack        */
  239.   /*  yyls: the location stack            */
  240.  
  241.   short   *yyss = (short *)   malloc(YYMAXDEPTH * sizeof(short));
  242.   YYSTYPE *yyvs = (YYSTYPE *) malloc(YYMAXDEPTH * sizeof(YYSTYPE));
  243.  
  244. #ifdef YYLSP_NEEDED
  245.   YYLTYPE *yyls = (YYLTYPE *) malloc(YYMAXDEPTH * sizeof(YYLTYPE));
  246.   YYLTYPE *yylsp;
  247. #endif
  248.  
  249.   int yymaxdepth = YYMAXDEPTH;
  250.  
  251. #ifndef YYPURE
  252.   int yychar;
  253.   YYSTYPE yylval;
  254.   YYLTYPE yylloc;
  255.   int yynerrs;
  256. #endif
  257.  
  258.   YYSTYPE yyval;        /*  the variable used to return        */
  259.                 /*  semantic values from the action    */
  260.                 /*  routines                */
  261.  
  262.   int yylen;
  263.  
  264. #if YYDEBUG != 0
  265.   if (yydebug)
  266.     fprintf(stderr, "Starting parse\n");
  267. #endif
  268.  
  269.   yystate = 0;
  270.   yyerrstatus = 0;
  271.   yynerrs = 0;
  272.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  273.  
  274.   /* Initialize stack pointers.
  275.      Waste one element of value and location stack
  276.      so that they stay on the same level as the state stack.  */
  277.  
  278.   yyssp = yyss - 1;
  279.   yyvsp = yyvs;
  280.  
  281. #ifdef YYLSP_NEEDED
  282.   yylsp = yyls;
  283. #endif
  284.  
  285. /* Push a new state, which is found in  yystate.  */
  286. /* In all cases, when you get here, the value and location stacks
  287.    have just been pushed. so pushing a state here evens the stacks.  */
  288. yynewstate:
  289.  
  290.   *++yyssp = yystate;
  291.  
  292.   if (yyssp >= yyss + yymaxdepth - 1)
  293.     {
  294.       /* Get the current used size of the three stacks, in elements.  */
  295.       int size = yyssp - yyss + 1;
  296.  
  297. #ifdef yyoverflow
  298.       /* Give user a chance to reallocate the stack */
  299.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  300.       YYSTYPE *yyvs1 = yyvs;
  301.       short *yyss1 = yyss;
  302.  
  303. #ifdef YYLSP_NEEDED
  304.       YYLTYPE *yyls1 = yyls;
  305.       int yylssz = size * sizeof (*yylsp);
  306. #else
  307.       void *yyls1 = NULL;
  308.       int yylssz = 0;
  309. #endif
  310.  
  311.       /* Each stack pointer address is followed by the size of
  312.      the data in use in that stack, in bytes.  */
  313.       yyoverflow("parser stack overflow",
  314.          &yyss1, size * sizeof (*yyssp),
  315.          &yyvs1, size * sizeof (*yyvsp),
  316.          &yyls1, yylssz,
  317.          &yymaxdepth);
  318.  
  319.       yyss = yyss1; yyvs = yyvs1;
  320.  
  321. #ifdef YYLSP_NEEDED
  322.       yyls = yyls1;
  323. #endif
  324.  
  325. #else /* no yyoverflow */
  326.       /* Extend the stack our own way.  */
  327.       if (yymaxdepth >= YYMAXLIMIT)
  328.     yyerror("parser stack overflow");
  329.       yymaxdepth *= 2;
  330.       if (yymaxdepth > YYMAXLIMIT)
  331.     yymaxdepth = YYMAXLIMIT;
  332.       yyss = (short *)   realloc (yyss, yymaxdepth * sizeof (*yyssp));
  333.       if (yyss == 0)
  334.     yyerror("parser stack overflow");
  335.       yyvs = (YYSTYPE *) realloc (yyvs, yymaxdepth * sizeof (*yyvsp));
  336.       if (yyvs == 0)
  337.     yyerror("parser stack overflow");
  338.  
  339. #ifdef YYLSP_NEEDED
  340.       yyls = (YYLTYPE *) realloc (yyls, yymaxdepth * sizeof (*yylsp));
  341.       if (yyls == 0)
  342.     yyerror("parser stack overflow");
  343. #endif
  344.  
  345. #endif /* no yyoverflow */
  346.  
  347.       yyssp = yyss + size - 1;
  348.       yyvsp = yyvs + size - 1;
  349. #ifdef YYLSP_NEEDED
  350.       yylsp = yyls + size - 1;
  351. #endif
  352.  
  353. #if YYDEBUG != 0
  354.       if (yydebug)
  355.     fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
  356. #endif
  357.  
  358.       if (yyssp >= yyss + yymaxdepth - 1)
  359.     YYABORT;
  360.     }
  361.  
  362. #if YYDEBUG != 0
  363.   if (yydebug)
  364.     fprintf(stderr, "Entering state %d\n", yystate);
  365. #endif
  366.  
  367. /* Do appropriate processing given the current state.  */
  368. /* Read a lookahead token if we need one and don't already have one.  */
  369.  
  370.   /* First try to decide what to do without reference to lookahead token.  */
  371.  
  372.   yyn = yypact[yystate];
  373.   if (yyn == YYFLAG)
  374.     goto yydefault;
  375.  
  376.   /* Not known => get a lookahead token if don't already have one.  */
  377.  
  378.   /* yychar is either YYEMPTY or YYEOF
  379.      or a valid token in external form.  */
  380.  
  381.   if (yychar == YYEMPTY)
  382.     {
  383. #if YYDEBUG != 0
  384.       if (yydebug)
  385.     fprintf(stderr, "Reading a token: ");
  386. #endif
  387.       yychar = YYLEX;
  388.     }
  389.  
  390.   /* Convert token to internal form (in yychar1) for indexing tables with */
  391.  
  392.   if (yychar <= 0)        /* This means end of input. */
  393.     {
  394.       yychar1 = 0;
  395.       yychar = YYEOF;        /* Don't call YYLEX any more */
  396.  
  397. #if YYDEBUG != 0
  398.       if (yydebug)
  399.     fprintf(stderr, "Now at end of input.\n");
  400. #endif
  401.     }
  402.   else
  403.     {
  404.       yychar1 = YYTRANSLATE(yychar);
  405.  
  406. #if YYDEBUG != 0
  407.       if (yydebug)
  408.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  409. #endif
  410.     }
  411.  
  412.   yyn += yychar1;
  413.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  414.     goto yydefault;
  415.  
  416.   yyn = yytable[yyn];
  417.  
  418.   /* yyn is what to do for this token type in this state.
  419.      Negative => reduce, -yyn is rule number.
  420.      Positive => shift, yyn is new state.
  421.        New state is final state => don't bother to shift,
  422.        just return success.
  423.      0, or most negative number => error.  */
  424.  
  425.   if (yyn < 0)
  426.     {
  427.       if (yyn == YYFLAG)
  428.     goto yyerrlab;
  429.       yyn = -yyn;
  430.       goto yyreduce;
  431.     }
  432.   else if (yyn == 0)
  433.     goto yyerrlab;
  434.  
  435.   if (yyn == YYFINAL)
  436.     YYACCEPT;
  437.  
  438.   /* Shift the lookahead token.  */
  439.  
  440. #if YYDEBUG != 0
  441.   if (yydebug)
  442.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  443. #endif
  444.  
  445.   /* Discard the token being shifted unless it is eof.  */
  446.   if (yychar != YYEOF)
  447.     yychar = YYEMPTY;
  448.  
  449.   *++yyvsp = yylval;
  450. #ifdef YYLSP_NEEDED
  451.   *++yylsp = yylloc;
  452. #endif
  453.  
  454.   /* count tokens shifted since error; after three, turn off error status.  */
  455.   if (yyerrstatus) yyerrstatus--;
  456.  
  457.   yystate = yyn;
  458.   goto yynewstate;
  459.  
  460. /* Do the default action for the current state.  */
  461. yydefault:
  462.  
  463.   yyn = yydefact[yystate];
  464.   if (yyn == 0)
  465.     goto yyerrlab;
  466.  
  467. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  468. yyreduce:
  469.   yylen = yyr2[yyn];
  470.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  471.  
  472. #if YYDEBUG != 0
  473.   if (yydebug)
  474.     {
  475.       if (yylen == 1)
  476.     fprintf (stderr, "Reducing 1 value via line %d, ",
  477.          yyrline[yyn]);
  478.       else
  479.     fprintf (stderr, "Reducing %d values via line %d, ",
  480.          yylen, yyrline[yyn]);
  481.     }
  482. #endif
  483.  
  484.  
  485.   switch (yyn) {
  486.  
  487. case 3:
  488. #line 56 "y.orbpar"
  489. {
  490.          add_body(yyvsp[-8].dval,yyvsp[-6].dval,yyvsp[-4].dval,yyvsp[-2].dval,yyvsp[0].dval);
  491.        ;
  492.     break;}
  493. case 5:
  494. #line 63 "y.orbpar"
  495. {
  496.            yyval.dval=atof(yytext);
  497.          ;
  498.     break;}
  499. }
  500.    /* the action file gets copied in in place of this dollarsign */
  501. #line 322 "bison.simple"
  502.  
  503.   yyvsp -= yylen;
  504.   yyssp -= yylen;
  505. #ifdef YYLSP_NEEDED
  506.   yylsp -= yylen;
  507. #endif
  508.  
  509. #if YYDEBUG != 0
  510.   if (yydebug)
  511.     {
  512.       short *ssp1 = yyss - 1;
  513.       fprintf (stderr, "state stack now");
  514.       while (ssp1 != yyssp)
  515.     fprintf (stderr, " %d", *++ssp1);
  516.       fprintf (stderr, "\n");
  517.     }
  518. #endif
  519.  
  520.   *++yyvsp = yyval;
  521.  
  522. #ifdef YYLSP_NEEDED
  523.   yylsp++;
  524.   if (yylen == 0)
  525.     {
  526.       yylsp->first_line = yylloc.first_line;
  527.       yylsp->first_column = yylloc.first_column;
  528.       yylsp->last_line = (yylsp-1)->last_line;
  529.       yylsp->last_column = (yylsp-1)->last_column;
  530.       yylsp->text = 0;
  531.     }
  532.   else
  533.     {
  534.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  535.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  536.     }
  537. #endif
  538.  
  539.   /* Now "shift" the result of the reduction.
  540.      Determine what state that goes to,
  541.      based on the state we popped back to
  542.      and the rule number reduced by.  */
  543.  
  544.   yyn = yyr1[yyn];
  545.  
  546.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  547.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  548.     yystate = yytable[yystate];
  549.   else
  550.     yystate = yydefgoto[yyn - YYNTBASE];
  551.  
  552.   goto yynewstate;
  553.  
  554. yyerrlab:   /* here on detecting error */
  555.  
  556.   if (! yyerrstatus)
  557.     /* If not already recovering from an error, report this error.  */
  558.     {
  559.       ++yynerrs;
  560.       yyerror("parse error");
  561.     }
  562.  
  563.   if (yyerrstatus == 3)
  564.     {
  565.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  566.  
  567.       /* return failure if at end of input */
  568.       if (yychar == YYEOF)
  569.     YYABORT;
  570.  
  571. #if YYDEBUG != 0
  572.       if (yydebug)
  573.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  574. #endif
  575.  
  576.       yychar = YYEMPTY;
  577.     }
  578.  
  579.   /* Else will try to reuse lookahead token
  580.      after shifting the error token.  */
  581.  
  582.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  583.  
  584.   goto yyerrhandle;
  585.  
  586. yyerrdefault:  /* current state does not do anything special for the error token. */
  587.  
  588. #if 0
  589.   /* This is wrong; only states that explicitly want error tokens
  590.      should shift them.  */
  591.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  592.   if (yyn) goto yydefault;
  593. #endif
  594.  
  595. yyerrpop:   /* pop the current state because it cannot handle the error token */
  596.  
  597.   if (yyssp == yyss) YYABORT;
  598.   yyvsp--;
  599.   yystate = *--yyssp;
  600. #ifdef YYLSP_NEEDED
  601.   yylsp--;
  602. #endif
  603.  
  604. #if YYDEBUG != 0
  605.   if (yydebug)
  606.     {
  607.       short *ssp1 = yyss - 1;
  608.       fprintf (stderr, "Error: state stack now");
  609.       while (ssp1 != yyssp)
  610.     fprintf (stderr, " %d", *++ssp1);
  611.       fprintf (stderr, "\n");
  612.     }
  613. #endif
  614.  
  615. yyerrhandle:
  616.  
  617.   yyn = yypact[yystate];
  618.   if (yyn == YYFLAG)
  619.     goto yyerrdefault;
  620.  
  621.   yyn += YYTERROR;
  622.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  623.     goto yyerrdefault;
  624.  
  625.   yyn = yytable[yyn];
  626.   if (yyn < 0)
  627.     {
  628.       if (yyn == YYFLAG)
  629.     goto yyerrpop;
  630.       yyn = -yyn;
  631.       goto yyreduce;
  632.     }
  633.   else if (yyn == 0)
  634.     goto yyerrpop;
  635.  
  636.   if (yyn == YYFINAL)
  637.     YYACCEPT;
  638.  
  639. #if YYDEBUG != 0
  640.   if (yydebug)
  641.     fprintf(stderr, "Shifting error token, ");
  642. #endif
  643.  
  644.   *++yyvsp = yylval;
  645. #ifdef YYLSP_NEEDED
  646.   *++yylsp = yylloc;
  647. #endif
  648.  
  649.   yystate = yyn;
  650.   goto yynewstate;
  651. }
  652. #line 68 "y.orbpar"
  653.  
  654.  
  655. static void yyerror(char *s)
  656. {
  657.   (void)fprintf(stderr,"Orbits: %s at line %d\n",s,yyline);
  658.   exit(3);
  659. }
  660.  
  661. static void add_body(double im,double ix,double iy,double idx,double idy)
  662. {
  663.   number++;
  664.   x=   (double *)realloc(x,   sizeof(double)*number);
  665.   y=   (double *)realloc(y,   sizeof(double)*number);
  666.   dx=  (double *)realloc(dx,  sizeof(double)*number);
  667.   dy=  (double *)realloc(dy,  sizeof(double)*number);
  668.   mass=(double *)realloc(mass,sizeof(double)*number);
  669.   x[number-1]=ix;
  670.   y[number-1]=iy;
  671.   dx[number-1]=idx;
  672.   dy[number-1]=idy;
  673.   mass[number-1]=im;
  674.   return;
  675. }
  676.