src/rrd_graph.c

   1 /****************************************************************************
   2  * RRDtool 1.2.12  Copyright by Tobi Oetiker, 1997-2005
   3  ****************************************************************************
   4  * rrd__graph.c  produce graphs from data in rrdfiles
   5  ****************************************************************************/
   6
   7
   8 #include <sys/stat.h>
   9
  10 #include "rrd_tool.h"
  11
  12 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
  13 #include <io.h>
  14 #include <fcntl.h>
  15 #endif
  16
  17 #ifdef HAVE_TIME_H
  18 #include <time.h>
  19 #endif
  20
  21 #ifdef HAVE_LOCALE_H
  22 #include <locale.h>
  23 #endif
  24
  25 #include "rrd_graph.h"
  26
  27 /* some constant definitions */
  28
  29
  30
  31 #ifndef RRD_DEFAULT_FONT
  32 /* there is special code later to pick Cour.ttf when running on windows */
  33 #define RRD_DEFAULT_FONT "DejaVuSansMono-Roman.ttf"
  34 #endif
  35
  36 text_prop_t text_prop[] = {
  37      { 8.0, RRD_DEFAULT_FONT }, /* default */
  38      { 9.0, RRD_DEFAULT_FONT }, /* title */
  39      { 7.0,  RRD_DEFAULT_FONT }, /* axis */
  40      { 8.0, RRD_DEFAULT_FONT }, /* unit */
  41      { 8.0, RRD_DEFAULT_FONT }  /* legend */
  42 };
  43
  44 xlab_t xlab[] = {
  45     {0,                 0,   TMT_SECOND,30, TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
  46     {2,                 0,   TMT_MINUTE,1,  TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
  47     {5,                 0,   TMT_MINUTE,2,  TMT_MINUTE,10, TMT_MINUTE,10,        0,"%H:%M"},
  48     {10,                0,   TMT_MINUTE,5,  TMT_MINUTE,20, TMT_MINUTE,20,        0,"%H:%M"},
  49     {30,                0,   TMT_MINUTE,10, TMT_HOUR,1,    TMT_HOUR,1,           0,"%H:%M"},
  50     {60,                0,   TMT_MINUTE,30, TMT_HOUR,2,    TMT_HOUR,2,           0,"%H:%M"},
  51     {180,               0,   TMT_HOUR,1,    TMT_HOUR,6,    TMT_HOUR,6,           0,"%H:%M"},
  52     {180,       1*24*3600,   TMT_HOUR,1,    TMT_HOUR,6,    TMT_HOUR,6,           0,"%a %H:%M"},
  53     /*{300,             0,   TMT_HOUR,3,    TMT_HOUR,12,   TMT_HOUR,12,    12*3600,"%a %p"},  this looks silly*/
  54     {600,               0,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%a"},
  55     {600,       1*24*3600,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%a %d"},
  56     {1800,              0,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a"},
  57     {1800,      1*24*3600,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a %d"},
  58     {3600,              0,   TMT_DAY,1,     TMT_WEEK,1,    TMT_WEEK,1,    7*24*3600,"Week %V"},
  59     {3*3600,            0,   TMT_WEEK,1,    TMT_MONTH,1,   TMT_WEEK,2,    7*24*3600,"Week %V"},
  60     {6*3600,            0,   TMT_MONTH,1,   TMT_MONTH,1,   TMT_MONTH,1, 30*24*3600,"%b"},
  61     {48*3600,           0,   TMT_MONTH,1,   TMT_MONTH,3,   TMT_MONTH,3, 30*24*3600,"%b"},
  62     {10*24*3600,        0,   TMT_YEAR,1,  TMT_YEAR,1,    TMT_YEAR,1, 365*24*3600,"%y"},
  63     {-1,0,TMT_MONTH,0,TMT_MONTH,0,TMT_MONTH,0,0,""}
  64 };
  65
  66 /* sensible logarithmic y label intervals ...
  67    the first element of each row defines the possible starting points on the
  68    y axis ... the other specify the */
  69
  70 double yloglab[][12]= {{ 1e9, 1,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0 },
  71                        {  1e3, 1,  0,  0,  0,   0,  0,  0,  0,  0,  0,  0 },
  72                        {  1e1, 1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 },
  73                        /* {  1e1, 1,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0 }, */
  74                        {  1e1, 1,  2.5,  5,  7.5,  0,  0,  0,  0,  0,  0,  0 },
  75                        {  1e1, 1,  2,  4,  6,  8,  0,  0,  0,  0,  0,  0 },
  76                        {  1e1, 1,  2,  3,  4,  5,  6,  7,  8,  9,  0,  0 },
  77                        {  0,   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0 }};
  78
  79 /* sensible y label intervals ...*/
  80
  81 ylab_t ylab[]= {
  82     {0.1, {1,2, 5,10}},
  83     {0.2, {1,5,10,20}},
  84     {0.5, {1,2, 4,10}},
  85     {1.0,   {1,2, 5,10}},
  86     {2.0,   {1,5,10,20}},
  87     {5.0,   {1,2, 4,10}},
  88     {10.0,  {1,2, 5,10}},
  89     {20.0,  {1,5,10,20}},
  90     {50.0,  {1,2, 4,10}},
  91     {100.0, {1,2, 5,10}},
  92     {200.0, {1,5,10,20}},
  93     {500.0, {1,2, 4,10}},
  94     {0.0,   {0,0,0,0}}};
  95
  96
  97 gfx_color_t graph_col[] =   /* default colors */
  98 {    0xFFFFFFFF,   /* canvas     */
  99      0xF0F0F0FF,   /* background */
 100      0xD0D0D0FF,   /* shade A    */
 101      0xA0A0A0FF,   /* shade B    */
 102      0x90909080,   /* grid       */
 103      0xE0505080,   /* major grid */
 104      0x000000FF,   /* font       */
 105      0x802020FF,   /* arrow      */
 106      0x202020FF,   /* axis       */
 107      0x000000FF    /* frame      */
 108 };
 109
 110
 111 /* #define DEBUG */
 112
 113 #ifdef DEBUG
 114 # define DPRINT(x)    (void)(printf x, printf("\n"))
 115 #else
 116 # define DPRINT(x)
 117 #endif
 118
 119
 120 /* initialize with xtr(im,0); */
 121 int
 122 xtr(image_desc_t *im,time_t mytime){
 123     static double pixie;
 124     if (mytime==0){
 125         pixie = (double) im->xsize / (double)(im->end - im->start);
 126         return im->xorigin;
 127     }
 128     return (int)((double)im->xorigin
 129                  + pixie * ( mytime - im->start ) );
 130 }
 131
 132 /* translate data values into y coordinates */
 133 double
 134 ytr(image_desc_t *im, double value){
 135     static double pixie;
 136     double yval;
 137     if (isnan(value)){
 138       if(!im->logarithmic)
 139         pixie = (double) im->ysize / (im->maxval - im->minval);
 140       else
 141         pixie = (double) im->ysize / (log10(im->maxval) - log10(im->minval));
 142       yval = im->yorigin;
 143     } else if(!im->logarithmic) {
 144       yval = im->yorigin - pixie * (value - im->minval);
 145     } else {
 146       if (value < im->minval) {
 147         yval = im->yorigin;
 148       } else {
 149         yval = im->yorigin - pixie * (log10(value) - log10(im->minval));
 150       }
 151     }
 152     /* make sure we don't return anything too unreasonable. GD lib can
 153        get terribly slow when drawing lines outside its scope. This is
 154        especially problematic in connection with the rigid option */
 155     if (! im->rigid) {
 156       /* keep yval as-is */
 157     } else if (yval > im->yorigin) {
 158       yval = im->yorigin +0.00001;
 159     } else if (yval < im->yorigin - im->ysize){
 160       yval = im->yorigin - im->ysize - 0.00001;
 161     }
 162     return yval;
 163 }
 164
 165
 166
 167 /* conversion function for symbolic entry names */
 168
 169
 170 #define conv_if(VV,VVV) \
 171    if (strcmp(#VV, string) == 0) return VVV ;
 172
 173 enum gf_en gf_conv(char *string){
 174
 175     conv_if(PRINT,GF_PRINT)
 176     conv_if(GPRINT,GF_GPRINT)
 177     conv_if(COMMENT,GF_COMMENT)
 178     conv_if(HRULE,GF_HRULE)
 179     conv_if(VRULE,GF_VRULE)
 180     conv_if(LINE,GF_LINE)
 181     conv_if(AREA,GF_AREA)
 182     conv_if(STACK,GF_STACK)
 183     conv_if(TICK,GF_TICK)
 184     conv_if(DEF,GF_DEF)
 185     conv_if(CDEF,GF_CDEF)
 186     conv_if(VDEF,GF_VDEF)
 187 #ifdef WITH_PIECHART
 188     conv_if(PART,GF_PART)
 189 #endif
 190     conv_if(XPORT,GF_XPORT)
 191     conv_if(SHIFT,GF_SHIFT)
 192
 193     return (-1);
 194 }
 195
 196 enum gfx_if_en if_conv(char *string){
 197
 198     conv_if(PNG,IF_PNG)
 199     conv_if(SVG,IF_SVG)
 200     conv_if(EPS,IF_EPS)
 201     conv_if(PDF,IF_PDF)
 202
 203     return (-1);
 204 }
 205
 206 enum tmt_en tmt_conv(char *string){
 207
 208     conv_if(SECOND,TMT_SECOND)
 209     conv_if(MINUTE,TMT_MINUTE)
 210     conv_if(HOUR,TMT_HOUR)
 211     conv_if(DAY,TMT_DAY)
 212     conv_if(WEEK,TMT_WEEK)
 213     conv_if(MONTH,TMT_MONTH)
 214     conv_if(YEAR,TMT_YEAR)
 215     return (-1);
 216 }
 217
 218 enum grc_en grc_conv(char *string){
 219
 220     conv_if(BACK,GRC_BACK)
 221     conv_if(CANVAS,GRC_CANVAS)
 222     conv_if(SHADEA,GRC_SHADEA)
 223     conv_if(SHADEB,GRC_SHADEB)
 224     conv_if(GRID,GRC_GRID)
 225     conv_if(MGRID,GRC_MGRID)
 226     conv_if(FONT,GRC_FONT)
 227     conv_if(ARROW,GRC_ARROW)
 228     conv_if(AXIS,GRC_AXIS)
 229     conv_if(FRAME,GRC_FRAME)
 230
 231     return -1;
 232 }
 233
 234 enum text_prop_en text_prop_conv(char *string){
 235
 236     conv_if(DEFAULT,TEXT_PROP_DEFAULT)
 237     conv_if(TITLE,TEXT_PROP_TITLE)
 238     conv_if(AXIS,TEXT_PROP_AXIS)
 239     conv_if(UNIT,TEXT_PROP_UNIT)
 240     conv_if(LEGEND,TEXT_PROP_LEGEND)
 241     return -1;
 242 }
 243
 244
 245 #undef conv_if
 246
 247 int
 248 im_free(image_desc_t *im)
 249 {
 250     unsigned long       i,ii;
 251
 252     if (im == NULL) return 0;
 253     for(i=0;i<(unsigned)im->gdes_c;i++){
 254       if (im->gdes[i].data_first){
 255         /* careful here, because a single pointer can occur several times */
 256           free (im->gdes[i].data);
 257           if (im->gdes[i].ds_namv){
 258               for (ii=0;ii<im->gdes[i].ds_cnt;ii++)
 259                   free(im->gdes[i].ds_namv[ii]);
 260               free(im->gdes[i].ds_namv);
 261           }
 262       }
 263       free (im->gdes[i].p_data);
 264       free (im->gdes[i].rpnp);
 265     }
 266     free(im->gdes);
 267     gfx_destroy(im->canvas);
 268     return 0;
 269 }
 270
 271 /* find SI magnitude symbol for the given number*/
 272 void
 273 auto_scale(
 274            image_desc_t *im,   /* image description */
 275            double *value,
 276            char **symb_ptr,
 277            double *magfact
 278            )
 279 {
 280
 281     char *symbol[] = {"a", /* 10e-18 Atto */
 282                       "f", /* 10e-15 Femto */
 283                       "p", /* 10e-12 Pico */
 284                       "n", /* 10e-9  Nano */
 285                       "u", /* 10e-6  Micro */
 286                       "m", /* 10e-3  Milli */
 287                       " ", /* Base */
 288                       "k", /* 10e3   Kilo */
 289                       "M", /* 10e6   Mega */
 290                       "G", /* 10e9   Giga */
 291                       "T", /* 10e12  Tera */
 292                       "P", /* 10e15  Peta */
 293                       "E"};/* 10e18  Exa */
 294
 295     int symbcenter = 6;
 296     int sindex;
 297
 298     if (*value == 0.0 || isnan(*value) ) {
 299         sindex = 0;
 300         *magfact = 1.0;
 301     } else {
 302         sindex = floor(log(fabs(*value))/log((double)im->base));
 303         *magfact = pow((double)im->base, (double)sindex);
 304         (*value) /= (*magfact);
 305     }
 306     if ( sindex <= symbcenter && sindex >= -symbcenter) {
 307         (*symb_ptr) = symbol[sindex+symbcenter];
 308     }
 309     else {
 310         (*symb_ptr) = "?";
 311     }
 312 }
 313
 314
 315 /* find SI magnitude symbol for the numbers on the y-axis*/
 316 void
 317 si_unit(
 318     image_desc_t *im   /* image description */
 319 )
 320 {
 321
 322     char symbol[] = {'a', /* 10e-18 Atto */
 323                      'f', /* 10e-15 Femto */
 324                      'p', /* 10e-12 Pico */
 325                      'n', /* 10e-9  Nano */
 326                      'u', /* 10e-6  Micro */
 327                      'm', /* 10e-3  Milli */
 328                      ' ', /* Base */
 329                      'k', /* 10e3   Kilo */
 330                      'M', /* 10e6   Mega */
 331                      'G', /* 10e9   Giga */
 332                      'T', /* 10e12  Tera */
 333                      'P', /* 10e15  Peta */
 334                      'E'};/* 10e18  Exa */
 335
 336     int   symbcenter = 6;
 337     double digits,viewdigits=0;
 338
 339     digits = floor( log( max( fabs(im->minval),fabs(im->maxval)))/log((double)im->base));
 340
 341     if (im->unitsexponent != 9999) {
 342         /* unitsexponent = 9, 6, 3, 0, -3, -6, -9, etc */
 343         viewdigits = floor(im->unitsexponent / 3);
 344     } else {
 345         viewdigits = digits;
 346     }
 347
 348     im->magfact = pow((double)im->base , digits);
 349
 350 #ifdef DEBUG
 351     printf("digits %6.3f  im->magfact %6.3f\n",digits,im->magfact);
 352 #endif
 353
 354     im->viewfactor = im->magfact / pow((double)im->base , viewdigits);
 355
 356     if ( ((viewdigits+symbcenter) < sizeof(symbol)) &&
 357                     ((viewdigits+symbcenter) >= 0) )
 358         im->symbol = symbol[(int)viewdigits+symbcenter];
 359     else
 360         im->symbol = '?';
 361  }
 362
 363 /*  move min and max values around to become sensible */
 364
 365 void
 366 expand_range(image_desc_t *im)
 367 {
 368     double sensiblevalues[] ={1000.0,900.0,800.0,750.0,700.0,
 369                               600.0,500.0,400.0,300.0,250.0,
 370                               200.0,125.0,100.0,90.0,80.0,
 371                               75.0,70.0,60.0,50.0,40.0,30.0,
 372                               25.0,20.0,10.0,9.0,8.0,
 373                               7.0,6.0,5.0,4.0,3.5,3.0,
 374                               2.5,2.0,1.8,1.5,1.2,1.0,
 375                               0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1,0.0,-1};
 376
 377     double scaled_min,scaled_max;
 378     double adj;
 379     int i;
 380
 381
 382
 383 #ifdef DEBUG
 384     printf("Min: %6.2f Max: %6.2f MagFactor: %6.2f\n",
 385            im->minval,im->maxval,im->magfact);
 386 #endif
 387
 388     if (isnan(im->ygridstep)){
 389         if(im->extra_flags & ALTAUTOSCALE) {
 390             /* measure the amplitude of the function. Make sure that
 391                graph boundaries are slightly higher then max/min vals
 392                so we can see amplitude on the graph */
 393               double delt, fact;
 394
 395               delt = im->maxval - im->minval;
 396               adj = delt * 0.1;
 397               fact = 2.0 * pow(10.0,
 398                     floor(log10(max(fabs(im->minval), fabs(im->maxval))/im->magfact)) - 2);
 399               if (delt < fact) {
 400                 adj = (fact - delt) * 0.55;
 401 #ifdef DEBUG
 402               printf("Min: %6.2f Max: %6.2f delt: %6.2f fact: %6.2f adj: %6.2f\n", im->minval, im->maxval, delt, fact, adj);
 403 #endif
 404               }
 405               im->minval -= adj;
 406               im->maxval += adj;
 407         }
 408         else if(im->extra_flags & ALTAUTOSCALE_MAX) {
 409             /* measure the amplitude of the function. Make sure that
 410                graph boundaries are slightly higher than max vals
 411                so we can see amplitude on the graph */
 412               adj = (im->maxval - im->minval) * 0.1;
 413               im->maxval += adj;
 414         }
 415         else {
 416             scaled_min = im->minval / im->magfact;
 417             scaled_max = im->maxval / im->magfact;
 418
 419             for (i=1; sensiblevalues[i] > 0; i++){
 420                 if (sensiblevalues[i-1]>=scaled_min &&
 421                     sensiblevalues[i]<=scaled_min)
 422                     im->minval = sensiblevalues[i]*(im->magfact);
 423
 424                 if (-sensiblevalues[i-1]<=scaled_min &&
 425                 -sensiblevalues[i]>=scaled_min)
 426                     im->minval = -sensiblevalues[i-1]*(im->magfact);
 427
 428                 if (sensiblevalues[i-1] >= scaled_max &&
 429                     sensiblevalues[i] <= scaled_max)
 430                     im->maxval = sensiblevalues[i-1]*(im->magfact);
 431
 432                 if (-sensiblevalues[i-1]<=scaled_max &&
 433                     -sensiblevalues[i] >=scaled_max)
 434                     im->maxval = -sensiblevalues[i]*(im->magfact);
 435             }
 436         }
 437     } else {
 438         /* adjust min and max to the grid definition if there is one */
 439         im->minval = (double)im->ylabfact * im->ygridstep *
 440             floor(im->minval / ((double)im->ylabfact * im->ygridstep));
 441         im->maxval = (double)im->ylabfact * im->ygridstep *
 442             ceil(im->maxval /( (double)im->ylabfact * im->ygridstep));
 443     }
 444
 445 #ifdef DEBUG
 446     fprintf(stderr,"SCALED Min: %6.2f Max: %6.2f Factor: %6.2f\n",
 447            im->minval,im->maxval,im->magfact);
 448 #endif
 449 }
 450
 451 void
 452 apply_gridfit(image_desc_t *im)
 453 {
 454   if (isnan(im->minval) || isnan(im->maxval))
 455     return;
 456   ytr(im,DNAN);
 457   if (im->logarithmic) {
 458     double ya, yb, ypix, ypixfrac;
 459     double log10_range = log10(im->maxval) - log10(im->minval);
 460     ya = pow((double)10, floor(log10(im->minval)));
 461     while (ya < im->minval)
 462       ya *= 10;
 463     if (ya > im->maxval)
 464       return; /* don't have y=10^x gridline */
 465     yb = ya * 10;
 466     if (yb <= im->maxval) {
 467       /* we have at least 2 y=10^x gridlines.
 468          Make sure distance between them in pixels
 469          are an integer by expanding im->maxval */
 470       double y_pixel_delta = ytr(im, ya) - ytr(im, yb);
 471       double factor = y_pixel_delta / floor(y_pixel_delta);
 472       double new_log10_range = factor * log10_range;
 473       double new_ymax_log10 = log10(im->minval) + new_log10_range;
 474       im->maxval = pow(10, new_ymax_log10);
 475       ytr(im,DNAN); /* reset precalc */
 476       log10_range = log10(im->maxval) - log10(im->minval);
 477     }
 478     /* make sure first y=10^x gridline is located on
 479        integer pixel position by moving scale slightly
 480        downwards (sub-pixel movement) */
 481     ypix = ytr(im, ya) + im->ysize; /* add im->ysize so it always is positive */
 482     ypixfrac = ypix - floor(ypix);
 483     if (ypixfrac > 0 && ypixfrac < 1) {
 484       double yfrac = ypixfrac / im->ysize;
 485       im->minval = pow(10, log10(im->minval) - yfrac * log10_range);
 486       im->maxval = pow(10, log10(im->maxval) - yfrac * log10_range);
 487       ytr(im,DNAN); /* reset precalc */
 488     }
 489   } else {
 490     /* Make sure we have an integer pixel distance between
 491        each minor gridline */
 492     double ypos1 = ytr(im, im->minval);
 493     double ypos2 = ytr(im, im->minval + im->ygrid_scale.gridstep);
 494     double y_pixel_delta = ypos1 - ypos2;
 495     double factor = y_pixel_delta / floor(y_pixel_delta);
 496     double new_range = factor * (im->maxval - im->minval);
 497     double gridstep = im->ygrid_scale.gridstep;
 498     double minor_y, minor_y_px, minor_y_px_frac;
 499     im->maxval = im->minval + new_range;
 500     ytr(im,DNAN); /* reset precalc */
 501     /* make sure first minor gridline is on integer pixel y coord */
 502     minor_y = gridstep * floor(im->minval / gridstep);
 503     while (minor_y < im->minval)
 504       minor_y += gridstep;
 505     minor_y_px = ytr(im, minor_y) + im->ysize; /* ensure > 0 by adding ysize */
 506     minor_y_px_frac = minor_y_px - floor(minor_y_px);
 507     if (minor_y_px_frac > 0 && minor_y_px_frac < 1) {
 508       double yfrac = minor_y_px_frac / im->ysize;
 509       double range = im->maxval - im->minval;
 510       im->minval = im->minval - yfrac * range;
 511       im->maxval = im->maxval - yfrac * range;
 512       ytr(im,DNAN); /* reset precalc */
 513     }
 514     calc_horizontal_grid(im); /* recalc with changed im->maxval */
 515   }
 516 }
 517
 518 /* reduce data reimplementation by Alex */
 519
 520 void
 521 reduce_data(
 522     enum cf_en     cf,         /* which consolidation function ?*/
 523     unsigned long  cur_step,   /* step the data currently is in */
 524     time_t         *start,     /* start, end and step as requested ... */
 525     time_t         *end,       /* ... by the application will be   ... */
 526     unsigned long  *step,      /* ... adjusted to represent reality    */
 527     unsigned long  *ds_cnt,    /* number of data sources in file */
 528     rrd_value_t    **data)     /* two dimensional array containing the data */
 529 {
 530     int i,reduce_factor = ceil((double)(*step) / (double)cur_step);
 531     unsigned long col,dst_row,row_cnt,start_offset,end_offset,skiprows=0;
 532     rrd_value_t    *srcptr,*dstptr;
 533
 534     (*step) = cur_step*reduce_factor; /* set new step size for reduced data */
 535     dstptr = *data;
 536     srcptr = *data;
 537     row_cnt = ((*end)-(*start))/cur_step;
 538
 539 #ifdef DEBUG
 540 #define DEBUG_REDUCE
 541 #endif
 542 #ifdef DEBUG_REDUCE
 543 printf("Reducing %lu rows with factor %i time %lu to %lu, step %lu\n",
 544                         row_cnt,reduce_factor,*start,*end,cur_step);
 545 for (col=0;col<row_cnt;col++) {
 546     printf("time %10lu: ",*start+(col+1)*cur_step);
 547     for (i=0;i<*ds_cnt;i++)
 548         printf(" %8.2e",srcptr[*ds_cnt*col+i]);
 549     printf("\n");
 550 }
 551 #endif
 552
 553     /* We have to combine [reduce_factor] rows of the source
 554     ** into one row for the destination.  Doing this we also
 555     ** need to take care to combine the correct rows.  First
 556     ** alter the start and end time so that they are multiples
 557     ** of the new step time.  We cannot reduce the amount of
 558     ** time so we have to move the end towards the future and
 559     ** the start towards the past.
 560     */
 561     end_offset = (*end) % (*step);
 562     start_offset = (*start) % (*step);
 563
 564     /* If there is a start offset (which cannot be more than
 565     ** one destination row), skip the appropriate number of
 566     ** source rows and one destination row.  The appropriate
 567     ** number is what we do know (start_offset/cur_step) of
 568     ** the new interval (*step/cur_step aka reduce_factor).
 569     */
 570 #ifdef DEBUG_REDUCE
 571 printf("start_offset: %lu  end_offset: %lu\n",start_offset,end_offset);
 572 printf("row_cnt before:  %lu\n",row_cnt);
 573 #endif
 574     if (start_offset) {
 575         (*start) = (*start)-start_offset;
 576         skiprows=reduce_factor-start_offset/cur_step;
 577         srcptr+=skiprows* *ds_cnt;
 578         for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
 579         row_cnt-=skiprows;
 580     }
 581 #ifdef DEBUG_REDUCE
 582 printf("row_cnt between: %lu\n",row_cnt);
 583 #endif
 584
 585     /* At the end we have some rows that are not going to be
 586     ** used, the amount is end_offset/cur_step
 587     */
 588     if (end_offset) {
 589         (*end) = (*end)-end_offset+(*step);
 590         skiprows = end_offset/cur_step;
 591         row_cnt-=skiprows;
 592     }
 593 #ifdef DEBUG_REDUCE
 594 printf("row_cnt after:   %lu\n",row_cnt);
 595 #endif
 596
 597 /* Sanity check: row_cnt should be multiple of reduce_factor */
 598 /* if this gets triggered, something is REALLY WRONG ... we die immediately */
 599
 600     if (row_cnt%reduce_factor) {
 601         printf("SANITY CHECK: %lu rows cannot be reduced by %i \n",
 602                                 row_cnt,reduce_factor);
 603         printf("BUG in reduce_data()\n");
 604         exit(1);
 605     }
 606
 607     /* Now combine reduce_factor intervals at a time
 608     ** into one interval for the destination.
 609     */
 610
 611     for (dst_row=0;(long int)row_cnt>=reduce_factor;dst_row++) {
 612         for (col=0;col<(*ds_cnt);col++) {
 613             rrd_value_t newval=DNAN;
 614             unsigned long validval=0;
 615
 616             for (i=0;i<reduce_factor;i++) {
 617                 if (isnan(srcptr[i*(*ds_cnt)+col])) {
 618                     continue;
 619                 }
 620                 validval++;
 621                 if (isnan(newval)) newval = srcptr[i*(*ds_cnt)+col];
 622                 else {
 623                     switch (cf) {
 624                         case CF_HWPREDICT:
 625                         case CF_DEVSEASONAL:
 626                         case CF_DEVPREDICT:
 627                         case CF_SEASONAL:
 628                         case CF_AVERAGE:
 629                             newval += srcptr[i*(*ds_cnt)+col];
 630                             break;
 631                         case CF_MINIMUM:
 632                             newval = min (newval,srcptr[i*(*ds_cnt)+col]);
 633                             break;
 634                         case CF_FAILURES:
 635                         /* an interval contains a failure if any subintervals contained a failure */
 636                         case CF_MAXIMUM:
 637                             newval = max (newval,srcptr[i*(*ds_cnt)+col]);
 638                             break;
 639                         case CF_LAST:
 640                             newval = srcptr[i*(*ds_cnt)+col];
 641                             break;
 642                     }
 643                 }
 644             }
 645             if (validval == 0){newval = DNAN;} else{
 646                 switch (cf) {
 647                     case CF_HWPREDICT:
 648             case CF_DEVSEASONAL:
 649                     case CF_DEVPREDICT:
 650                     case CF_SEASONAL:
 651                     case CF_AVERAGE:
 652                        newval /= validval;
 653                         break;
 654                     case CF_MINIMUM:
 655                     case CF_FAILURES:
 656                     case CF_MAXIMUM:
 657                     case CF_LAST:
 658                         break;
 659                 }
 660             }
 661             *dstptr++=newval;
 662         }
 663         srcptr+=(*ds_cnt)*reduce_factor;
 664         row_cnt-=reduce_factor;
 665     }
 666     /* If we had to alter the endtime, we didn't have enough
 667     ** source rows to fill the last row. Fill it with NaN.
 668     */
 669     if (end_offset) for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
 670 #ifdef DEBUG_REDUCE
 671     row_cnt = ((*end)-(*start))/ *step;
 672     srcptr = *data;
 673     printf("Done reducing. Currently %lu rows, time %lu to %lu, step %lu\n",
 674                                 row_cnt,*start,*end,*step);
 675 for (col=0;col<row_cnt;col++) {
 676     printf("time %10lu: ",*start+(col+1)*(*step));
 677     for (i=0;i<*ds_cnt;i++)
 678         printf(" %8.2e",srcptr[*ds_cnt*col+i]);
 679     printf("\n");
 680 }
 681 #endif
 682 }
 683
 684
 685 /* get the data required for the graphs from the
 686    relevant rrds ... */
 687
 688 int
 689 data_fetch(image_desc_t *im )
 690 {
 691     int i,ii;
 692     int         skip;
 693
 694     /* pull the data from the rrd files ... */
 695     for (i=0;i< (int)im->gdes_c;i++){
 696         /* only GF_DEF elements fetch data */
 697         if (im->gdes[i].gf != GF_DEF)
 698             continue;
 699
 700         skip=0;
 701         /* do we have it already ?*/
 702         for (ii=0;ii<i;ii++) {
 703             if (im->gdes[ii].gf != GF_DEF)
 704                 continue;
 705             if ((strcmp(im->gdes[i].rrd, im->gdes[ii].rrd) == 0)
 706                         && (im->gdes[i].cf    == im->gdes[ii].cf)
 707                         && (im->gdes[i].cf_reduce == im->gdes[ii].cf_reduce)
 708                         && (im->gdes[i].start_orig == im->gdes[ii].start_orig)
 709                         && (im->gdes[i].end_orig   == im->gdes[ii].end_orig)
 710                         && (im->gdes[i].step_orig  == im->gdes[ii].step_orig)) {
 711                 /* OK, the data is already there.
 712                 ** Just copy the header portion
 713                 */
 714                 im->gdes[i].start = im->gdes[ii].start;
 715                 im->gdes[i].end = im->gdes[ii].end;
 716                 im->gdes[i].step = im->gdes[ii].step;
 717                 im->gdes[i].ds_cnt = im->gdes[ii].ds_cnt;
 718                 im->gdes[i].ds_namv = im->gdes[ii].ds_namv;
 719                 im->gdes[i].data = im->gdes[ii].data;
 720                 im->gdes[i].data_first = 0;
 721                 skip=1;
 722             }
 723             if (skip)
 724                 break;
 725         }
 726         if (! skip) {
 727             unsigned long  ft_step = im->gdes[i].step ;
 728
 729             if((rrd_fetch_fn(im->gdes[i].rrd,
 730                              im->gdes[i].cf,
 731                              &im->gdes[i].start,
 732                              &im->gdes[i].end,
 733                              &ft_step,
 734                              &im->gdes[i].ds_cnt,
 735                              &im->gdes[i].ds_namv,
 736                              &im->gdes[i].data)) == -1){
 737                 return -1;
 738             }
 739             im->gdes[i].data_first = 1;
 740             im->gdes[i].step = im->step;
 741
 742             if (ft_step < im->gdes[i].step) {
 743                 reduce_data(im->gdes[i].cf_reduce,
 744                             ft_step,
 745                             &im->gdes[i].start,
 746                             &im->gdes[i].end,
 747                             &im->gdes[i].step,
 748                             &im->gdes[i].ds_cnt,
 749                             &im->gdes[i].data);
 750             } else {
 751                 im->gdes[i].step = ft_step;
 752             }
 753         }
 754
 755         /* lets see if the required data source is really there */
 756         for(ii=0;ii<(int)im->gdes[i].ds_cnt;ii++){
 757             if(strcmp(im->gdes[i].ds_namv[ii],im->gdes[i].ds_nam) == 0){
 758                 im->gdes[i].ds=ii; }
 759         }
 760         if (im->gdes[i].ds== -1){
 761             rrd_set_error("No DS called '%s' in '%s'",
 762                           im->gdes[i].ds_nam,im->gdes[i].rrd);
 763             return -1;
 764         }
 765
 766     }
 767     return 0;
 768 }
 769
 770 /* evaluate the expressions in the CDEF functions */
 771
 772 /*************************************************************
 773  * CDEF stuff
 774  *************************************************************/
 775
 776 long
 777 find_var_wrapper(void *arg1, char *key)
 778 {
 779    return find_var((image_desc_t *) arg1, key);
 780 }
 781
 782 /* find gdes containing var*/
 783 long
 784 find_var(image_desc_t *im, char *key){
 785     long ii;
 786     for(ii=0;ii<im->gdes_c-1;ii++){
 787         if((im->gdes[ii].gf == GF_DEF
 788             || im->gdes[ii].gf == GF_VDEF
 789             || im->gdes[ii].gf == GF_CDEF)
 790            && (strcmp(im->gdes[ii].vname,key) == 0)){
 791             return ii;
 792         }
 793     }
 794     return -1;
 795 }
 796
 797 /* find the largest common denominator for all the numbers
 798    in the 0 terminated num array */
 799 long
 800 lcd(long *num){
 801     long rest;
 802     int i;
 803     for (i=0;num[i+1]!=0;i++){
 804         do {
 805             rest=num[i] % num[i+1];
 806             num[i]=num[i+1]; num[i+1]=rest;
 807         } while (rest!=0);
 808         num[i+1] = num[i];
 809     }
 810 /*    return i==0?num[i]:num[i-1]; */
 811       return num[i];
 812 }
 813
 814 /* run the rpn calculator on all the VDEF and CDEF arguments */
 815 int
 816 data_calc( image_desc_t *im){
 817
 818     int       gdi;
 819     int       dataidx;
 820     long      *steparray, rpi;
 821     int       stepcnt;
 822     time_t    now;
 823     rpnstack_t rpnstack;
 824
 825     rpnstack_init(&rpnstack);
 826
 827     for (gdi=0;gdi<im->gdes_c;gdi++){
 828         /* Look for GF_VDEF and GF_CDEF in the same loop,
 829          * so CDEFs can use VDEFs and vice versa
 830          */
 831         switch (im->gdes[gdi].gf) {
 832             case GF_XPORT:
 833               break;
 834             case GF_SHIFT: {
 835                 graph_desc_t    *vdp = &im->gdes[im->gdes[gdi].vidx];
 836
 837                 /* remove current shift */
 838                 vdp->start -= vdp->shift;
 839                 vdp->end -= vdp->shift;
 840
 841                 /* vdef */
 842                 if (im->gdes[gdi].shidx >= 0)
 843                         vdp->shift = im->gdes[im->gdes[gdi].shidx].vf.val;
 844                 /* constant */
 845                 else
 846                         vdp->shift = im->gdes[gdi].shval;
 847
 848                 /* normalize shift to multiple of consolidated step */
 849                 vdp->shift = (vdp->shift / (long)vdp->step) * (long)vdp->step;
 850
 851                 /* apply shift */
 852                 vdp->start += vdp->shift;
 853                 vdp->end += vdp->shift;
 854                 break;
 855             }
 856             case GF_VDEF:
 857                 /* A VDEF has no DS.  This also signals other parts
 858                  * of rrdtool that this is a VDEF value, not a CDEF.
 859                  */
 860                 im->gdes[gdi].ds_cnt = 0;
 861                 if (vdef_calc(im,gdi)) {
 862                     rrd_set_error("Error processing VDEF '%s'"
 863                         ,im->gdes[gdi].vname
 864                         );
 865                     rpnstack_free(&rpnstack);
 866                     return -1;
 867                 }
 868                 break;
 869             case GF_CDEF:
 870                 im->gdes[gdi].ds_cnt = 1;
 871                 im->gdes[gdi].ds = 0;
 872                 im->gdes[gdi].data_first = 1;
 873                 im->gdes[gdi].start = 0;
 874                 im->gdes[gdi].end = 0;
 875                 steparray=NULL;
 876                 stepcnt = 0;
 877                 dataidx=-1;
 878
 879                 /* Find the variables in the expression.
 880                  * - VDEF variables are substituted by their values
 881                  *   and the opcode is changed into OP_NUMBER.
 882                  * - CDEF variables are analized for their step size,
 883                  *   the lowest common denominator of all the step
 884                  *   sizes of the data sources involved is calculated
 885                  *   and the resulting number is the step size for the
 886                  *   resulting data source.
 887                  */
 888                 for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
 889                     if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE  ||
 890                         im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
 891                         long ptr = im->gdes[gdi].rpnp[rpi].ptr;
 892                         if (im->gdes[ptr].ds_cnt == 0) { /* this is a VDEF data source */
 893 #if 0
 894                             printf("DEBUG: inside CDEF '%s' processing VDEF '%s'\n",
 895                                im->gdes[gdi].vname,
 896                                im->gdes[ptr].vname);
 897                             printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
 898 #endif
 899                             im->gdes[gdi].rpnp[rpi].val = im->gdes[ptr].vf.val;
 900                             im->gdes[gdi].rpnp[rpi].op  = OP_NUMBER;
 901                         } else { /* normal variables and PREF(variables) */
 902
 903                             /* add one entry to the array that keeps track of the step sizes of the
 904                              * data sources going into the CDEF. */
 905                             if ((steparray =
 906                                  rrd_realloc(steparray,
 907                                                          (++stepcnt+1)*sizeof(*steparray)))==NULL){
 908                                  rrd_set_error("realloc steparray");
 909                                  rpnstack_free(&rpnstack);
 910                                  return -1;
 911                             };
 912
 913                             steparray[stepcnt-1] = im->gdes[ptr].step;
 914
 915                             /* adjust start and end of cdef (gdi) so
 916                              * that it runs from the latest start point
 917                              * to the earliest endpoint of any of the
 918                              * rras involved (ptr)
 919                              */
 920
 921                             if(im->gdes[gdi].start < im->gdes[ptr].start)
 922                                 im->gdes[gdi].start = im->gdes[ptr].start;
 923
 924                             if(im->gdes[gdi].end == 0 ||
 925                                         im->gdes[gdi].end > im->gdes[ptr].end)
 926                                 im->gdes[gdi].end = im->gdes[ptr].end;
 927
 928                             /* store pointer to the first element of
 929                              * the rra providing data for variable,
 930                              * further save step size and data source
 931                              * count of this rra
 932                              */
 933                             im->gdes[gdi].rpnp[rpi].data   = im->gdes[ptr].data + im->gdes[ptr].ds;
 934                             im->gdes[gdi].rpnp[rpi].step   = im->gdes[ptr].step;
 935                             im->gdes[gdi].rpnp[rpi].ds_cnt = im->gdes[ptr].ds_cnt;
 936
 937                             /* backoff the *.data ptr; this is done so
 938                              * rpncalc() function doesn't have to treat
 939                              * the first case differently
 940                              */
 941                         } /* if ds_cnt != 0 */
 942                     } /* if OP_VARIABLE */
 943                 } /* loop through all rpi */
 944
 945                 /* move the data pointers to the correct period */
 946                 for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
 947                     if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE ||
 948                         im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
 949                         long ptr  = im->gdes[gdi].rpnp[rpi].ptr;
 950                         long diff = im->gdes[gdi].start - im->gdes[ptr].start;
 951
 952                         if(diff > 0)
 953                             im->gdes[gdi].rpnp[rpi].data += (diff / im->gdes[ptr].step) * im->gdes[ptr].ds_cnt;
 954                      }
 955                 }
 956
 957                 if(steparray == NULL){
 958                     rrd_set_error("rpn expressions without DEF"
 959                                 " or CDEF variables are not supported");
 960                     rpnstack_free(&rpnstack);
 961                     return -1;
 962                 }
 963                 steparray[stepcnt]=0;
 964                 /* Now find the resulting step.  All steps in all
 965                  * used RRAs have to be visited
 966                  */
 967                 im->gdes[gdi].step = lcd(steparray);
 968                 free(steparray);
 969                 if((im->gdes[gdi].data = malloc((
 970                                 (im->gdes[gdi].end-im->gdes[gdi].start)
 971                                     / im->gdes[gdi].step)
 972                                     * sizeof(double)))==NULL){
 973                     rrd_set_error("malloc im->gdes[gdi].data");
 974                     rpnstack_free(&rpnstack);
 975                     return -1;
 976                 }
 977
 978                 /* Step through the new cdef results array and
 979                  * calculate the values
 980                  */
 981                 for (now = im->gdes[gdi].start + im->gdes[gdi].step;
 982                                 now<=im->gdes[gdi].end;
 983                                 now += im->gdes[gdi].step)
 984                 {
 985                     rpnp_t  *rpnp = im -> gdes[gdi].rpnp;
 986
 987                     /* 3rd arg of rpn_calc is for OP_VARIABLE lookups;
 988                      * in this case we are advancing by timesteps;
 989                      * we use the fact that time_t is a synonym for long
 990                      */
 991                     if (rpn_calc(rpnp,&rpnstack,(long) now,
 992                                 im->gdes[gdi].data,++dataidx) == -1) {
 993                         /* rpn_calc sets the error string */
 994                         rpnstack_free(&rpnstack);
 995                         return -1;
 996                     }
 997                 } /* enumerate over time steps within a CDEF */
 998                 break;
 999             default:
1000                 continue;
1001         }
1002     } /* enumerate over CDEFs */
1003     rpnstack_free(&rpnstack);
1004     return 0;
1005 }
1006
1007 /* massage data so, that we get one value for each x coordinate in the graph */
1008 int
1009 data_proc( image_desc_t *im ){
1010     long i,ii;
1011     double pixstep = (double)(im->end-im->start)
1012         /(double)im->xsize; /* how much time
1013                                passes in one pixel */
1014     double paintval;
1015     double minval=DNAN,maxval=DNAN;
1016
1017     unsigned long gr_time;
1018
1019     /* memory for the processed data */
1020     for(i=0;i<im->gdes_c;i++) {
1021         if((im->gdes[i].gf==GF_LINE) ||
1022                 (im->gdes[i].gf==GF_AREA) ||
1023                 (im->gdes[i].gf==GF_TICK)) {
1024             if((im->gdes[i].p_data = malloc((im->xsize +1)
1025                                         * sizeof(rrd_value_t)))==NULL){
1026                 rrd_set_error("malloc data_proc");
1027                 return -1;
1028             }
1029         }
1030     }
1031
1032     for (i=0;i<im->xsize;i++) { /* for each pixel */
1033         long vidx;
1034         gr_time = im->start+pixstep*i; /* time of the current step */
1035         paintval=0.0;
1036
1037         for (ii=0;ii<im->gdes_c;ii++) {
1038             double value;
1039             switch (im->gdes[ii].gf) {
1040                 case GF_LINE:
1041                 case GF_AREA:
1042                 case GF_TICK:
1043                     if (!im->gdes[ii].stack)
1044                         paintval = 0.0;
1045                     value = im->gdes[ii].yrule;
1046                     if (isnan(value) || (im->gdes[ii].gf == GF_TICK)) {
1047                         /* The time of the data doesn't necessarily match
1048                         ** the time of the graph. Beware.
1049                         */
1050                         vidx = im->gdes[ii].vidx;
1051                         if (im->gdes[vidx].gf == GF_VDEF) {
1052                             value = im->gdes[vidx].vf.val;
1053                         } else if (((long int)gr_time >= (long int)im->gdes[vidx].start) &&
1054                                    ((long int)gr_time <= (long int)im->gdes[vidx].end) ) {
1055                             value = im->gdes[vidx].data[
1056                                 (unsigned long) floor(
1057                                     (double)(gr_time - im->gdes[vidx].start)
1058                                                 / im->gdes[vidx].step)
1059                                 * im->gdes[vidx].ds_cnt
1060                                 + im->gdes[vidx].ds
1061                             ];
1062                         } else {
1063                             value = DNAN;
1064                         }
1065                     };
1066
1067                     if (! isnan(value)) {
1068                         paintval += value;
1069                         im->gdes[ii].p_data[i] = paintval;
1070                         /* GF_TICK: the data values are not
1071                         ** relevant for min and max
1072                         */
1073                         if (finite(paintval) && im->gdes[ii].gf != GF_TICK ) {
1074                             if (isnan(minval) || paintval <  minval)
1075                                 minval = paintval;
1076                             if (isnan(maxval) || paintval >  maxval)
1077                                 maxval = paintval;
1078                         }
1079                     } else {
1080                         im->gdes[ii].p_data[i] = DNAN;
1081                     }
1082                     break;
1083                 case GF_STACK:
1084                     rrd_set_error("STACK should already be turned into LINE or AREA here");
1085                     return -1;
1086                     break;
1087                 default:
1088                     break;
1089             }
1090         }
1091     }
1092
1093     /* if min or max have not been asigned a value this is because
1094        there was no data in the graph ... this is not good ...
1095        lets set these to dummy values then ... */
1096
1097     if (isnan(minval)) minval = 0.0;
1098     if (isnan(maxval)) maxval = 1.0;
1099
1100     /* adjust min and max values */
1101     if (isnan(im->minval)
1102         /* don't adjust low-end with log scale */
1103         || ((!im->logarithmic && !im->rigid) && im->minval > minval)
1104         )
1105         im->minval = minval;
1106     if (isnan(im->maxval)
1107         || (!im->rigid && im->maxval < maxval)
1108         ) {
1109         if (im->logarithmic)
1110             im->maxval = maxval * 1.1;
1111         else
1112             im->maxval = maxval;
1113     }
1114     /* make sure min is smaller than max */
1115     if (im->minval > im->maxval) {
1116             im->minval = 0.99 * im->maxval;
1117     }
1118
1119     /* make sure min and max are not equal */
1120     if (im->minval == im->maxval) {
1121         im->maxval *= 1.01;
1122         if (! im->logarithmic) {
1123             im->minval *= 0.99;
1124         }
1125         /* make sure min and max are not both zero */
1126         if (im->maxval == 0.0) {
1127             im->maxval = 1.0;
1128         }
1129     }
1130     return 0;
1131 }
1132
1133
1134
1135 /* identify the point where the first gridline, label ... gets placed */
1136
1137 time_t
1138 find_first_time(
1139     time_t   start, /* what is the initial time */
1140     enum tmt_en baseint,  /* what is the basic interval */
1141     long     basestep /* how many if these do we jump a time */
1142     )
1143 {
1144     struct tm tm;
1145     localtime_r(&start, &tm);
1146     switch(baseint){
1147     case TMT_SECOND:
1148         tm.tm_sec -= tm.tm_sec % basestep; break;
1149     case TMT_MINUTE:
1150         tm.tm_sec=0;
1151         tm.tm_min -= tm.tm_min % basestep;
1152         break;
1153     case TMT_HOUR:
1154         tm.tm_sec=0;
1155         tm.tm_min = 0;
1156         tm.tm_hour -= tm.tm_hour % basestep; break;
1157     case TMT_DAY:
1158         /* we do NOT look at the basestep for this ... */
1159         tm.tm_sec=0;
1160         tm.tm_min = 0;
1161         tm.tm_hour = 0; break;
1162     case TMT_WEEK:
1163         /* we do NOT look at the basestep for this ... */
1164         tm.tm_sec=0;
1165         tm.tm_min = 0;
1166         tm.tm_hour = 0;
1167         tm.tm_mday -= tm.tm_wday -1;    /* -1 because we want the monday */
1168         if (tm.tm_wday==0) tm.tm_mday -= 7; /* we want the *previous* monday */
1169         break;
1170     case TMT_MONTH:
1171         tm.tm_sec=0;
1172         tm.tm_min = 0;
1173         tm.tm_hour = 0;
1174         tm.tm_mday = 1;
1175         tm.tm_mon -= tm.tm_mon % basestep; break;
1176
1177     case TMT_YEAR:
1178         tm.tm_sec=0;
1179         tm.tm_min = 0;
1180         tm.tm_hour = 0;
1181         tm.tm_mday = 1;
1182         tm.tm_mon = 0;
1183         tm.tm_year -= (tm.tm_year+1900) % basestep;
1184
1185     }
1186     return mktime(&tm);
1187 }
1188 /* identify the point where the next gridline, label ... gets placed */
1189 time_t
1190 find_next_time(
1191     time_t   current, /* what is the initial time */
1192     enum tmt_en baseint,  /* what is the basic interval */
1193     long     basestep /* how many if these do we jump a time */
1194     )
1195 {
1196     struct tm tm;
1197     time_t madetime;
1198     localtime_r(&current, &tm);
1199     do {
1200         switch(baseint){
1201         case TMT_SECOND:
1202             tm.tm_sec += basestep; break;
1203         case TMT_MINUTE:
1204             tm.tm_min += basestep; break;
1205         case TMT_HOUR:
1206             tm.tm_hour += basestep; break;
1207         case TMT_DAY:
1208             tm.tm_mday += basestep; break;
1209         case TMT_WEEK:
1210             tm.tm_mday += 7*basestep; break;
1211         case TMT_MONTH:
1212             tm.tm_mon += basestep; break;
1213         case TMT_YEAR:
1214             tm.tm_year += basestep;
1215         }
1216         madetime = mktime(&tm);
1217     } while (madetime == -1); /* this is necessary to skip impssible times
1218                                  like the daylight saving time skips */
1219     return madetime;
1220
1221 }
1222
1223
1224 /* calculate values required for PRINT and GPRINT functions */
1225
1226 int
1227 print_calc(image_desc_t *im, char ***prdata)
1228 {
1229     long i,ii,validsteps;
1230     double printval;
1231     time_t printtime;
1232     int graphelement = 0;
1233     long vidx;
1234     int max_ii;
1235     double magfact = -1;
1236     char *si_symb = "";
1237     char *percent_s;
1238     int prlines = 1;
1239     if (im->imginfo) prlines++;
1240     for(i=0;i<im->gdes_c;i++){
1241         switch(im->gdes[i].gf){
1242         case GF_PRINT:
1243             prlines++;
1244             if(((*prdata) = rrd_realloc((*prdata),prlines*sizeof(char *)))==NULL){
1245                 rrd_set_error("realloc prdata");
1246                 return 0;
1247             }
1248         case GF_GPRINT:
1249             /* PRINT and GPRINT can now print VDEF generated values.
1250              * There's no need to do any calculations on them as these
1251              * calculations were already made.
1252              */
1253             vidx = im->gdes[i].vidx;
1254             if (im->gdes[vidx].gf==GF_VDEF) { /* simply use vals */
1255                 printval = im->gdes[vidx].vf.val;
1256                 printtime = im->gdes[vidx].vf.when;
1257             } else { /* need to calculate max,min,avg etcetera */
1258                 max_ii =((im->gdes[vidx].end
1259                         - im->gdes[vidx].start)
1260                         / im->gdes[vidx].step
1261                         * im->gdes[vidx].ds_cnt);
1262                 printval = DNAN;
1263                 validsteps = 0;
1264                 for(    ii=im->gdes[vidx].ds;
1265                         ii < max_ii;
1266                         ii+=im->gdes[vidx].ds_cnt){
1267                     if (! finite(im->gdes[vidx].data[ii]))
1268                         continue;
1269                     if (isnan(printval)){
1270                         printval = im->gdes[vidx].data[ii];
1271                         validsteps++;
1272                         continue;
1273                     }
1274
1275                     switch (im->gdes[i].cf){
1276                         case CF_HWPREDICT:
1277                         case CF_DEVPREDICT:
1278                         case CF_DEVSEASONAL:
1279                         case CF_SEASONAL:
1280                         case CF_AVERAGE:
1281                             validsteps++;
1282                             printval += im->gdes[vidx].data[ii];
1283                             break;
1284                         case CF_MINIMUM:
1285                             printval = min( printval, im->gdes[vidx].data[ii]);
1286                             break;
1287                         case CF_FAILURES:
1288                         case CF_MAXIMUM:
1289                             printval = max( printval, im->gdes[vidx].data[ii]);
1290                             break;
1291                         case CF_LAST:
1292                             printval = im->gdes[vidx].data[ii];
1293                     }
1294                 }
1295                 if (im->gdes[i].cf==CF_AVERAGE || im->gdes[i].cf > CF_LAST) {
1296                     if (validsteps > 1) {
1297                         printval = (printval / validsteps);
1298                     }
1299                 }
1300             } /* prepare printval */
1301
1302             if (!strcmp(im->gdes[i].format,"%c")) { /* VDEF time print */
1303                 char ctime_buf[128]; /* PS: for ctime_r, must be >= 26 chars */
1304                 int iii=0;
1305                 ctime_r(&printtime,ctime_buf);
1306                 while(isprint(ctime_buf[iii])){iii++;}
1307                 ctime_buf[iii]='\0';
1308                 if (im->gdes[i].gf == GF_PRINT){
1309                     (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
1310                     sprintf((*prdata)[prlines-2],"%s (%lu)",ctime_buf,printtime);
1311                     (*prdata)[prlines-1] = NULL;
1312                 } else {
1313                     sprintf(im->gdes[i].legend,"%s (%lu)",ctime_buf,printtime);
1314                     graphelement = 1;
1315                 }
1316             } else {
1317             if ((percent_s = strstr(im->gdes[i].format,"%S")) != NULL) {
1318                 /* Magfact is set to -1 upon entry to print_calc.  If it
1319                  * is still less than 0, then we need to run auto_scale.
1320                  * Otherwise, put the value into the correct units.  If
1321                  * the value is 0, then do not set the symbol or magnification
1322                  * so next the calculation will be performed again. */
1323                 if (magfact < 0.0) {
1324                     auto_scale(im,&printval,&si_symb,&magfact);
1325                     if (printval == 0.0)
1326                         magfact = -1.0;
1327                 } else {
1328                     printval /= magfact;
1329                 }
1330                 *(++percent_s) = 's';
1331             } else if (strstr(im->gdes[i].format,"%s") != NULL) {
1332                 auto_scale(im,&printval,&si_symb,&magfact);
1333             }
1334
1335             if (im->gdes[i].gf == GF_PRINT){
1336                 (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
1337                 (*prdata)[prlines-1] = NULL;
1338                 if (bad_format(im->gdes[i].format)) {
1339                         rrd_set_error("bad format for PRINT in '%s'", im->gdes[i].format);
1340                         return -1;
1341                 }
1342 #ifdef HAVE_SNPRINTF
1343                 snprintf((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,printval,si_symb);
1344 #else
1345                 sprintf((*prdata)[prlines-2],im->gdes[i].format,printval,si_symb);
1346 #endif
1347             } else {
1348                 /* GF_GPRINT */
1349
1350                 if (bad_format(im->gdes[i].format)) {
1351                         rrd_set_error("bad format for GPRINT in '%s'", im->gdes[i].format);
1352                         return -1;
1353                 }
1354 #ifdef HAVE_SNPRINTF
1355                 snprintf(im->gdes[i].legend,FMT_LEG_LEN-2,im->gdes[i].format,printval,si_symb);
1356 #else
1357                 sprintf(im->gdes[i].legend,im->gdes[i].format,printval,si_symb);
1358 #endif
1359                 graphelement = 1;
1360             }
1361             }
1362             break;
1363         case GF_LINE:
1364         case GF_AREA:
1365         case GF_TICK:
1366         case GF_HRULE:
1367         case GF_VRULE:
1368             graphelement = 1;
1369             break;
1370         case GF_COMMENT:
1371         case GF_DEF:
1372         case GF_CDEF:
1373         case GF_VDEF:
1374 #ifdef WITH_PIECHART
1375         case GF_PART:
1376 #endif
1377         case GF_SHIFT:
1378         case GF_XPORT:
1379             break;
1380         case GF_STACK:
1381             rrd_set_error("STACK should already be turned into LINE or AREA here");
1382             return -1;
1383             break;
1384         }
1385     }
1386     return graphelement;
1387 }
1388
1389
1390 /* place legends with color spots */
1391 int
1392 leg_place(image_desc_t *im)
1393 {
1394     /* graph labels */
1395     int   interleg = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
1396     int   border = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
1397     int   fill=0, fill_last;
1398     int   leg_c = 0;
1399     int   leg_x = border, leg_y = im->yimg;
1400     int   leg_cc;
1401     int   glue = 0;
1402     int   i,ii, mark = 0;
1403     char  prt_fctn; /*special printfunctions */
1404     int  *legspace;
1405
1406   if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
1407     if ((legspace = malloc(im->gdes_c*sizeof(int)))==NULL){
1408        rrd_set_error("malloc for legspace");
1409        return -1;
1410     }
1411
1412     for(i=0;i<im->gdes_c;i++){
1413         fill_last = fill;
1414
1415         /* hid legends for rules which are not displayed */
1416
1417         if(!(im->extra_flags & FORCE_RULES_LEGEND)) {
1418                 if (im->gdes[i].gf == GF_HRULE &&
1419                     (im->gdes[i].yrule < im->minval || im->gdes[i].yrule > im->maxval))
1420                     im->gdes[i].legend[0] = '\0';
1421
1422                 if (im->gdes[i].gf == GF_VRULE &&
1423                     (im->gdes[i].xrule < im->start || im->gdes[i].xrule > im->end))
1424                     im->gdes[i].legend[0] = '\0';
1425         }
1426
1427         leg_cc = strlen(im->gdes[i].legend);
1428
1429         /* is there a controle code ant the end of the legend string ? */
1430         /* and it is not a tab \\t */
1431         if (leg_cc >= 2 && im->gdes[i].legend[leg_cc-2] == '\\' && im->gdes[i].legend[leg_cc-1] != 't') {
1432             prt_fctn = im->gdes[i].legend[leg_cc-1];
1433             leg_cc -= 2;
1434             im->gdes[i].legend[leg_cc] = '\0';
1435         } else {
1436             prt_fctn = '\0';
1437         }
1438         /* remove exess space */
1439         while (prt_fctn=='g' &&
1440                leg_cc > 0 &&
1441                im->gdes[i].legend[leg_cc-1]==' '){
1442            leg_cc--;
1443            im->gdes[i].legend[leg_cc]='\0';
1444         }
1445         if (leg_cc != 0 ){
1446            legspace[i]=(prt_fctn=='g' ? 0 : interleg);
1447
1448            if (fill > 0){
1449                /* no interleg space if string ends in \g */
1450                fill += legspace[i];
1451             }
1452            fill += gfx_get_text_width(im->canvas, fill+border,
1453                                       im->text_prop[TEXT_PROP_LEGEND].font,
1454                                       im->text_prop[TEXT_PROP_LEGEND].size,
1455                                       im->tabwidth,
1456                                       im->gdes[i].legend, 0);
1457             leg_c++;
1458         } else {
1459            legspace[i]=0;
1460         }
1461         /* who said there was a special tag ... ?*/
1462         if (prt_fctn=='g') {
1463            prt_fctn = '\0';
1464         }
1465         if (prt_fctn == '\0') {
1466             if (i == im->gdes_c -1 ) prt_fctn ='l';
1467
1468             /* is it time to place the legends ? */
1469             if (fill > im->ximg - 2*border){
1470                 if (leg_c > 1) {
1471                     /* go back one */
1472                     i--;
1473                     fill = fill_last;
1474                     leg_c--;
1475                     prt_fctn = 'j';
1476                 } else {
1477                     prt_fctn = 'l';
1478                 }
1479
1480             }
1481         }
1482
1483
1484         if (prt_fctn != '\0'){
1485             leg_x = border;
1486             if (leg_c >= 2 && prt_fctn == 'j') {
1487                 glue = (im->ximg - fill - 2* border) / (leg_c-1);
1488             } else {
1489                 glue = 0;
1490             }
1491             if (prt_fctn =='c') leg_x =  (im->ximg - fill) / 2.0;
1492             if (prt_fctn =='r') leg_x =  im->ximg - fill - border;
1493
1494             for(ii=mark;ii<=i;ii++){
1495                 if(im->gdes[ii].legend[0]=='\0')
1496                     continue; /* skip empty legends */
1497                 im->gdes[ii].leg_x = leg_x;
1498                 im->gdes[ii].leg_y = leg_y;
1499                 leg_x +=
1500                  gfx_get_text_width(im->canvas, leg_x,
1501                                       im->text_prop[TEXT_PROP_LEGEND].font,
1502                                       im->text_prop[TEXT_PROP_LEGEND].size,
1503                                       im->tabwidth,
1504                                       im->gdes[ii].legend, 0)
1505                    + legspace[ii]
1506                    + glue;
1507             }
1508             leg_y += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
1509             if (prt_fctn == 's') leg_y -=  im->text_prop[TEXT_PROP_LEGEND].size;
1510             fill = 0;
1511             leg_c = 0;
1512             mark = ii;
1513         }
1514     }
1515     im->yimg = leg_y;
1516     free(legspace);
1517   }
1518   return 0;
1519 }
1520
1521 /* create a grid on the graph. it determines what to do
1522    from the values of xsize, start and end */
1523
1524 /* the xaxis labels are determined from the number of seconds per pixel
1525    in the requested graph */
1526
1527
1528
1529 int
1530 calc_horizontal_grid(image_desc_t   *im)
1531 {
1532     double   range;
1533     double   scaledrange;
1534     int      pixel,i;
1535     int      gridind=0;
1536     int      decimals, fractionals;
1537
1538     im->ygrid_scale.labfact=2;
1539     range =  im->maxval - im->minval;
1540     scaledrange = range / im->magfact;
1541
1542         /* does the scale of this graph make it impossible to put lines
1543            on it? If so, give up. */
1544         if (isnan(scaledrange)) {
1545                 return 0;
1546         }
1547
1548     /* find grid spaceing */
1549     pixel=1;
1550     if(isnan(im->ygridstep)){
1551         if(im->extra_flags & ALTYGRID) {
1552             /* find the value with max number of digits. Get number of digits */
1553             decimals = ceil(log10(max(fabs(im->maxval), fabs(im->minval))*im->viewfactor/im->magfact));
1554             if(decimals <= 0) /* everything is small. make place for zero */
1555                 decimals = 1;
1556
1557             im->ygrid_scale.gridstep = pow((double)10, floor(log10(range*im->viewfactor/im->magfact)))/im->viewfactor*im->magfact;
1558
1559             if(im->ygrid_scale.gridstep == 0) /* range is one -> 0.1 is reasonable scale */
1560                 im->ygrid_scale.gridstep = 0.1;
1561             /* should have at least 5 lines but no more then 15 */
1562             if(range/im->ygrid_scale.gridstep < 5)
1563                 im->ygrid_scale.gridstep /= 10;
1564             if(range/im->ygrid_scale.gridstep > 15)
1565                 im->ygrid_scale.gridstep *= 10;
1566             if(range/im->ygrid_scale.gridstep > 5) {
1567                 im->ygrid_scale.labfact = 1;
1568                 if(range/im->ygrid_scale.gridstep > 8)
1569                     im->ygrid_scale.labfact = 2;
1570             }
1571             else {
1572                 im->ygrid_scale.gridstep /= 5;
1573                 im->ygrid_scale.labfact = 5;
1574             }
1575             fractionals = floor(log10(im->ygrid_scale.gridstep*(double)im->ygrid_scale.labfact*im->viewfactor/im->magfact));
1576             if(fractionals < 0) { /* small amplitude. */
1577                 int len = decimals - fractionals + 1;
1578                 if (im->unitslength < len+2) im->unitslength = len+2;
1579                 sprintf(im->ygrid_scale.labfmt, "%%%d.%df%s", len, -fractionals,(im->symbol != ' ' ? " %c" : ""));
1580             } else {
1581                 int len = decimals + 1;
1582                 if (im->unitslength < len+2) im->unitslength = len+2;
1583                 sprintf(im->ygrid_scale.labfmt, "%%%d.0f%s", len, ( im->symbol != ' ' ? " %c" : "" ));
1584             }
1585         }
1586         else {
1587             for(i=0;ylab[i].grid > 0;i++){
1588                 pixel = im->ysize / (scaledrange / ylab[i].grid);
1589                 gridind = i;
1590                 if (pixel > 7)
1591                     break;
1592             }
1593
1594             for(i=0; i<4;i++) {
1595                if (pixel * ylab[gridind].lfac[i] >=  2.5 * im->text_prop[TEXT_PROP_AXIS].size) {
1596                   im->ygrid_scale.labfact =  ylab[gridind].lfac[i];
1597                   break;
1598                }
1599             }
1600
1601             im->ygrid_scale.gridstep = ylab[gridind].grid * im->magfact;
1602         }
1603     } else {
1604         im->ygrid_scale.gridstep = im->ygridstep;
1605         im->ygrid_scale.labfact = im->ylabfact;
1606     }
1607     return 1;
1608 }
1609
1610 int draw_horizontal_grid(image_desc_t *im)
1611 {
1612     int      i;
1613     double   scaledstep;
1614     char     graph_label[100];
1615     double X0=im->xorigin;
1616     double X1=im->xorigin+im->xsize;
1617
1618     int sgrid = (int)( im->minval / im->ygrid_scale.gridstep - 1);
1619     int egrid = (int)( im->maxval / im->ygrid_scale.gridstep + 1);
1620     double MaxY;
1621     scaledstep = im->ygrid_scale.gridstep/(double)im->magfact*(double)im->viewfactor;
1622     MaxY = scaledstep*(double)egrid;
1623     for (i = sgrid; i <= egrid; i++){
1624        double Y0=ytr(im,im->ygrid_scale.gridstep*i);
1625        if ( Y0 >= im->yorigin-im->ysize
1626                  && Y0 <= im->yorigin){
1627             if(i % im->ygrid_scale.labfact == 0){
1628                 if (im->symbol == ' ') {
1629                     if(im->extra_flags & ALTYGRID) {
1630                         sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i);
1631                     } else {
1632                         if(MaxY < 10) {
1633                            sprintf(graph_label,"%4.1f",scaledstep*(double)i);
1634                         } else {
1635                            sprintf(graph_label,"%4.0f",scaledstep*(double)i);
1636                         }
1637                     }
1638                 }else {
1639                     char sisym = ( i == 0  ? ' ' : im->symbol);
1640                     if(im->extra_flags & ALTYGRID) {
1641                         sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i,sisym);
1642                     } else {
1643                         if(MaxY < 10){
1644                           sprintf(graph_label,"%4.1f %c",scaledstep*(double)i, sisym);
1645                         } else {
1646                           sprintf(graph_label,"%4.0f %c",scaledstep*(double)i, sisym);
1647                         }
1648                     }
1649                 }
1650
1651                gfx_new_text ( im->canvas,
1652                               X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
1653                               im->graph_col[GRC_FONT],
1654                               im->text_prop[TEXT_PROP_AXIS].font,
1655                               im->text_prop[TEXT_PROP_AXIS].size,
1656                               im->tabwidth, 0.0, GFX_H_RIGHT, GFX_V_CENTER,
1657                               graph_label );
1658                gfx_new_dashed_line ( im->canvas,
1659                               X0-2,Y0,
1660                               X1+2,Y0,
1661                               MGRIDWIDTH, im->graph_col[GRC_MGRID],
1662                               im->grid_dash_on, im->grid_dash_off);
1663
1664             } else if (!(im->extra_flags & NOMINOR)) {
1665                gfx_new_dashed_line ( im->canvas,
1666                               X0-1,Y0,
1667                               X1+1,Y0,
1668                               GRIDWIDTH, im->graph_col[GRC_GRID],
1669                               im->grid_dash_on, im->grid_dash_off);
1670
1671             }
1672         }
1673     }
1674     return 1;
1675 }
1676
1677 /* logaritmic horizontal grid */
1678 int
1679 horizontal_log_grid(image_desc_t   *im)
1680 {
1681     double   pixpex;
1682     int      ii,i;
1683     int      minoridx=0, majoridx=0;
1684     char     graph_label[100];
1685     double   X0,X1,Y0;
1686     double   value, pixperstep, minstep;
1687
1688     /* find grid spaceing */
1689     pixpex= (double)im->ysize / (log10(im->maxval) - log10(im->minval));
1690
1691         if (isnan(pixpex)) {
1692                 return 0;
1693         }
1694
1695     for(i=0;yloglab[i][0] > 0;i++){
1696         minstep = log10(yloglab[i][0]);
1697         for(ii=1;yloglab[i][ii+1] > 0;ii++){
1698             if(yloglab[i][ii+2]==0){
1699                 minstep = log10(yloglab[i][ii+1])-log10(yloglab[i][ii]);
1700                 break;
1701             }
1702         }
1703         pixperstep = pixpex * minstep;
1704         if(pixperstep > 5){minoridx = i;}
1705        if(pixperstep > 2 *  im->text_prop[TEXT_PROP_LEGEND].size){majoridx = i;}
1706     }
1707
1708    X0=im->xorigin;
1709    X1=im->xorigin+im->xsize;
1710     /* paint minor grid */
1711     for (value = pow((double)10, log10(im->minval)
1712                           - fmod(log10(im->minval),log10(yloglab[minoridx][0])));
1713          value  <= im->maxval;
1714          value *= yloglab[minoridx][0]){
1715         if (value < im->minval) continue;
1716         i=0;
1717         while(yloglab[minoridx][++i] > 0){
1718            Y0 = ytr(im,value * yloglab[minoridx][i]);
1719            if (Y0 <= im->yorigin - im->ysize) break;
1720            gfx_new_dashed_line ( im->canvas,
1721                           X0-1,Y0,
1722                           X1+1,Y0,
1723                           GRIDWIDTH, im->graph_col[GRC_GRID],
1724                           im->grid_dash_on, im->grid_dash_off);
1725         }
1726     }
1727
1728     /* paint major grid and labels*/
1729     for (value = pow((double)10, log10(im->minval)
1730                           - fmod(log10(im->minval),log10(yloglab[majoridx][0])));
1731          value <= im->maxval;
1732          value *= yloglab[majoridx][0]){
1733         if (value < im->minval) continue;
1734         i=0;
1735         while(yloglab[majoridx][++i] > 0){
1736            Y0 = ytr(im,value * yloglab[majoridx][i]);
1737            if (Y0 <= im->yorigin - im->ysize) break;
1738            gfx_new_dashed_line ( im->canvas,
1739                           X0-2,Y0,
1740                           X1+2,Y0,
1741                           MGRIDWIDTH, im->graph_col[GRC_MGRID],
1742                           im->grid_dash_on, im->grid_dash_off);
1743
1744            sprintf(graph_label,"%3.0e",value * yloglab[majoridx][i]);
1745            gfx_new_text ( im->canvas,
1746                           X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
1747                           im->graph_col[GRC_FONT],
1748                           im->text_prop[TEXT_PROP_AXIS].font,
1749                           im->text_prop[TEXT_PROP_AXIS].size,
1750                           im->tabwidth,0.0, GFX_H_RIGHT, GFX_V_CENTER,
1751                           graph_label );
1752         }
1753     }
1754         return 1;
1755 }
1756
1757
1758 void
1759 vertical_grid(
1760     image_desc_t   *im )
1761 {
1762     int xlab_sel;               /* which sort of label and grid ? */
1763     time_t ti, tilab, timajor;
1764     long factor;
1765     char graph_label[100];
1766     double X0,Y0,Y1; /* points for filled graph and more*/
1767     struct tm tm;
1768
1769     /* the type of time grid is determined by finding
1770        the number of seconds per pixel in the graph */
1771
1772
1773     if(im->xlab_user.minsec == -1){
1774         factor=(im->end - im->start)/im->xsize;
1775         xlab_sel=0;
1776         while ( xlab[xlab_sel+1].minsec != -1
1777                 && xlab[xlab_sel+1].minsec <= factor) { xlab_sel++; }   /* pick the last one */
1778         while ( xlab[xlab_sel-1].minsec == xlab[xlab_sel].minsec
1779                 && xlab[xlab_sel].length > (im->end - im->start)) { xlab_sel--; }       /* go back to the smallest size */
1780         im->xlab_user.gridtm = xlab[xlab_sel].gridtm;
1781         im->xlab_user.gridst = xlab[xlab_sel].gridst;
1782         im->xlab_user.mgridtm = xlab[xlab_sel].mgridtm;
1783         im->xlab_user.mgridst = xlab[xlab_sel].mgridst;
1784         im->xlab_user.labtm = xlab[xlab_sel].labtm;
1785         im->xlab_user.labst = xlab[xlab_sel].labst;
1786         im->xlab_user.precis = xlab[xlab_sel].precis;
1787         im->xlab_user.stst = xlab[xlab_sel].stst;
1788     }
1789
1790     /* y coords are the same for every line ... */
1791     Y0 = im->yorigin;
1792     Y1 = im->yorigin-im->ysize;
1793
1794
1795     /* paint the minor grid */
1796     if (!(im->extra_flags & NOMINOR))
1797     {
1798         for(ti = find_first_time(im->start,
1799                                 im->xlab_user.gridtm,
1800                                 im->xlab_user.gridst),
1801             timajor = find_first_time(im->start,
1802                                 im->xlab_user.mgridtm,
1803                                 im->xlab_user.mgridst);
1804             ti < im->end;
1805             ti = find_next_time(ti,im->xlab_user.gridtm,im->xlab_user.gridst)
1806             ){
1807             /* are we inside the graph ? */
1808             if (ti < im->start || ti > im->end) continue;
1809             while (timajor < ti) {
1810                 timajor = find_next_time(timajor,
1811                         im->xlab_user.mgridtm, im->xlab_user.mgridst);
1812             }
1813             if (ti == timajor) continue; /* skip as falls on major grid line */
1814            X0 = xtr(im,ti);
1815            gfx_new_dashed_line(im->canvas,X0,Y0+1, X0,Y1-1,GRIDWIDTH,
1816                im->graph_col[GRC_GRID],
1817                im->grid_dash_on, im->grid_dash_off);
1818
1819         }
1820     }
1821
1822     /* paint the major grid */
1823     for(ti = find_first_time(im->start,
1824                             im->xlab_user.mgridtm,
1825                             im->xlab_user.mgridst);
1826         ti < im->end;
1827         ti = find_next_time(ti,im->xlab_user.mgridtm,im->xlab_user.mgridst)
1828         ){
1829         /* are we inside the graph ? */
1830         if (ti < im->start || ti > im->end) continue;
1831        X0 = xtr(im,ti);
1832        gfx_new_dashed_line(im->canvas,X0,Y0+3, X0,Y1-2,MGRIDWIDTH,
1833            im->graph_col[GRC_MGRID],
1834            im->grid_dash_on, im->grid_dash_off);
1835
1836     }
1837     /* paint the labels below the graph */
1838     for(ti = find_first_time(im->start - im->xlab_user.precis/2,
1839                             im->xlab_user.labtm,
1840                             im->xlab_user.labst);
1841         ti <= im->end - im->xlab_user.precis/2;
1842         ti = find_next_time(ti,im->xlab_user.labtm,im->xlab_user.labst)
1843         ){
1844         tilab= ti + im->xlab_user.precis/2; /* correct time for the label */
1845         /* are we inside the graph ? */
1846         if (tilab < im->start || tilab > im->end) continue;
1847
1848 #if HAVE_STRFTIME
1849         localtime_r(&tilab, &tm);
1850         strftime(graph_label,99,im->xlab_user.stst, &tm);
1851 #else
1852 # error "your libc has no strftime I guess we'll abort the exercise here."
1853 #endif
1854        gfx_new_text ( im->canvas,
1855                       xtr(im,tilab), Y0+im->text_prop[TEXT_PROP_AXIS].size*1.4+5,
1856                       im->graph_col[GRC_FONT],
1857                       im->text_prop[TEXT_PROP_AXIS].font,
1858                       im->text_prop[TEXT_PROP_AXIS].size,
1859                       im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_BOTTOM,
1860                       graph_label );
1861
1862     }
1863
1864 }
1865
1866
1867 void
1868 axis_paint(
1869    image_desc_t   *im
1870            )
1871 {
1872     /* draw x and y axis */
1873     /* gfx_new_line ( im->canvas, im->xorigin+im->xsize,im->yorigin,
1874                       im->xorigin+im->xsize,im->yorigin-im->ysize,
1875                       GRIDWIDTH, im->graph_col[GRC_AXIS]);
1876
1877        gfx_new_line ( im->canvas, im->xorigin,im->yorigin-im->ysize,
1878                          im->xorigin+im->xsize,im->yorigin-im->ysize,
1879                          GRIDWIDTH, im->graph_col[GRC_AXIS]); */
1880
1881        gfx_new_line ( im->canvas, im->xorigin-4,im->yorigin,
1882                          im->xorigin+im->xsize+4,im->yorigin,
1883                          MGRIDWIDTH, im->graph_col[GRC_AXIS]);
1884
1885        gfx_new_line ( im->canvas, im->xorigin,im->yorigin+4,
1886                          im->xorigin,im->yorigin-im->ysize-4,
1887                          MGRIDWIDTH, im->graph_col[GRC_AXIS]);
1888
1889
1890     /* arrow for X and Y axis direction */
1891     gfx_new_area ( im->canvas,
1892                    im->xorigin+im->xsize+2,  im->yorigin-2,
1893                    im->xorigin+im->xsize+2,  im->yorigin+3,
1894                    im->xorigin+im->xsize+7,  im->yorigin+0.5, /* LINEOFFSET */
1895                    im->graph_col[GRC_ARROW]);
1896
1897     gfx_new_area ( im->canvas,
1898                    im->xorigin-2,  im->yorigin-im->ysize-2,
1899                    im->xorigin+3,  im->yorigin-im->ysize-2,
1900                    im->xorigin+0.5,    im->yorigin-im->ysize-7, /* LINEOFFSET */
1901                    im->graph_col[GRC_ARROW]);
1902
1903 }
1904
1905 void
1906 grid_paint(image_desc_t   *im)
1907 {
1908     long i;
1909     int res=0;
1910     double X0,Y0; /* points for filled graph and more*/
1911     gfx_node_t *node;
1912
1913     /* draw 3d border */
1914     node = gfx_new_area (im->canvas, 0,im->yimg,
1915                                  2,im->yimg-2,
1916                                  2,2,im->graph_col[GRC_SHADEA]);
1917     gfx_add_point( node , im->ximg - 2, 2 );
1918     gfx_add_point( node , im->ximg, 0 );
1919     gfx_add_point( node , 0,0 );
1920 /*    gfx_add_point( node , 0,im->yimg ); */
1921
1922     node =  gfx_new_area (im->canvas, 2,im->yimg-2,
1923                                   im->ximg-2,im->yimg-2,
1924                                   im->ximg - 2, 2,
1925                                  im->graph_col[GRC_SHADEB]);
1926     gfx_add_point( node ,   im->ximg,0);
1927     gfx_add_point( node ,   im->ximg,im->yimg);
1928     gfx_add_point( node ,   0,im->yimg);
1929 /*    gfx_add_point( node , 0,im->yimg ); */
1930
1931
1932     if (im->draw_x_grid == 1 )
1933       vertical_grid(im);
1934
1935     if (im->draw_y_grid == 1){
1936         if(im->logarithmic){
1937                 res = horizontal_log_grid(im);
1938         } else {
1939                 res = draw_horizontal_grid(im);
1940         }
1941
1942         /* dont draw horizontal grid if there is no min and max val */
1943         if (! res ) {
1944           char *nodata = "No Data found";
1945            gfx_new_text(im->canvas,im->ximg/2, (2*im->yorigin-im->ysize) / 2,
1946                         im->graph_col[GRC_FONT],
1947                         im->text_prop[TEXT_PROP_AXIS].font,
1948                         im->text_prop[TEXT_PROP_AXIS].size,
1949                         im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_CENTER,
1950                         nodata );
1951         }
1952     }
1953
1954     /* yaxis unit description */
1955     gfx_new_text( im->canvas,
1956                   10, (im->yorigin - im->ysize/2),
1957                   im->graph_col[GRC_FONT],
1958                   im->text_prop[TEXT_PROP_UNIT].font,
1959                   im->text_prop[TEXT_PROP_UNIT].size, im->tabwidth,
1960                   RRDGRAPH_YLEGEND_ANGLE,
1961                   GFX_H_LEFT, GFX_V_CENTER,
1962                   im->ylegend);
1963
1964     /* graph title */
1965     gfx_new_text( im->canvas,
1966                   im->ximg/2, im->text_prop[TEXT_PROP_TITLE].size*1.3+4,
1967                   im->graph_col[GRC_FONT],
1968                   im->text_prop[TEXT_PROP_TITLE].font,
1969                   im->text_prop[TEXT_PROP_TITLE].size, im->tabwidth, 0.0,
1970                   GFX_H_CENTER, GFX_V_CENTER,
1971                   im->title);
1972     /* rrdtool 'logo' */
1973     gfx_new_text( im->canvas,
1974                   im->ximg-7, 7,
1975                   ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
1976                   im->text_prop[TEXT_PROP_AXIS].font,
1977                   5.5, im->tabwidth, 270,
1978                   GFX_H_RIGHT, GFX_V_TOP,
1979                   "RRDTOOL / TOBI OETIKER");
1980
1981     /* graph labels */
1982     if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
1983             for(i=0;i<im->gdes_c;i++){
1984                     if(im->gdes[i].legend[0] =='\0')
1985                             continue;
1986
1987                     /* im->gdes[i].leg_y is the bottom of the legend */
1988                     X0 = im->gdes[i].leg_x;
1989                     Y0 = im->gdes[i].leg_y;
1990                     gfx_new_text ( im->canvas, X0, Y0,
1991                                    im->graph_col[GRC_FONT],
1992                                    im->text_prop[TEXT_PROP_LEGEND].font,
1993                                    im->text_prop[TEXT_PROP_LEGEND].size,
1994                                    im->tabwidth,0.0, GFX_H_LEFT, GFX_V_BOTTOM,
1995                                    im->gdes[i].legend );
1996                     /* The legend for GRAPH items starts with "M " to have
1997                        enough space for the box */
1998                     if (           im->gdes[i].gf != GF_PRINT &&
1999                                    im->gdes[i].gf != GF_GPRINT &&
2000                                    im->gdes[i].gf != GF_COMMENT) {
2001                             int boxH, boxV;
2002
2003                             boxH = gfx_get_text_width(im->canvas, 0,
2004                                                       im->text_prop[TEXT_PROP_LEGEND].font,
2005                                                       im->text_prop[TEXT_PROP_LEGEND].size,
2006                                                       im->tabwidth,"o", 0) * 1.2;
2007                             boxV = boxH*1.1;
2008
2009                             /* make sure transparent colors show up the same way as in the graph */
2010                              node = gfx_new_area(im->canvas,
2011                                                 X0,Y0-boxV,
2012                                                 X0,Y0,
2013                                                 X0+boxH,Y0,
2014                                                 im->graph_col[GRC_BACK]);
2015                             gfx_add_point ( node, X0+boxH, Y0-boxV );
2016
2017                             node = gfx_new_area(im->canvas,
2018                                                 X0,Y0-boxV,
2019                                                 X0,Y0,
2020                                                 X0+boxH,Y0,
2021                                                 im->gdes[i].col);
2022                             gfx_add_point ( node, X0+boxH, Y0-boxV );
2023                             node = gfx_new_line(im->canvas,
2024                                                 X0,Y0-boxV,
2025                                                 X0,Y0,
2026                                                 1.0,im->graph_col[GRC_FRAME]);
2027                             gfx_add_point(node,X0+boxH,Y0);
2028                             gfx_add_point(node,X0+boxH,Y0-boxV);
2029                             gfx_close_path(node);
2030                     }
2031             }
2032     }
2033 }
2034
2035
2036 /*****************************************************
2037  * lazy check make sure we rely need to create this graph
2038  *****************************************************/
2039
2040 int lazy_check(image_desc_t *im){
2041     FILE *fd = NULL;
2042         int size = 1;
2043     struct stat  imgstat;
2044
2045     if (im->lazy == 0) return 0; /* no lazy option */
2046     if (stat(im->graphfile,&imgstat) != 0)
2047       return 0; /* can't stat */
2048     /* one pixel in the existing graph is more then what we would
2049        change here ... */
2050     if (time(NULL) - imgstat.st_mtime >
2051         (im->end - im->start) / im->xsize)
2052       return 0;
2053     if ((fd = fopen(im->graphfile,"rb")) == NULL)
2054       return 0; /* the file does not exist */
2055     switch (im->canvas->imgformat) {
2056     case IF_PNG:
2057            size = PngSize(fd,&(im->ximg),&(im->yimg));
2058            break;
2059     default:
2060            size = 1;
2061     }
2062     fclose(fd);
2063     return size;
2064 }
2065
2066 #ifdef WITH_PIECHART
2067 void
2068 pie_part(image_desc_t *im, gfx_color_t color,
2069             double PieCenterX, double PieCenterY, double Radius,
2070             double startangle, double endangle)
2071 {
2072     gfx_node_t *node;
2073     double angle;
2074     double step=M_PI/50; /* Number of iterations for the circle;
2075                          ** 10 is definitely too low, more than
2076                          ** 50 seems to be overkill
2077                          */
2078
2079     /* Strange but true: we have to work clockwise or else
2080     ** anti aliasing nor transparency don't work.
2081     **
2082     ** This test is here to make sure we do it right, also
2083     ** this makes the for...next loop more easy to implement.
2084     ** The return will occur if the user enters a negative number
2085     ** (which shouldn't be done according to the specs) or if the
2086     ** programmers do something wrong (which, as we all know, never
2087     ** happens anyway :)
2088     */
2089     if (endangle<startangle) return;
2090
2091     /* Hidden feature: Radius decreases each full circle */
2092     angle=startangle;
2093     while (angle>=2*M_PI) {
2094         angle  -= 2*M_PI;
2095         Radius *= 0.8;
2096     }
2097
2098     node=gfx_new_area(im->canvas,
2099                 PieCenterX+sin(startangle)*Radius,
2100                 PieCenterY-cos(startangle)*Radius,
2101                 PieCenterX,
2102                 PieCenterY,
2103                 PieCenterX+sin(endangle)*Radius,
2104                 PieCenterY-cos(endangle)*Radius,
2105                 color);
2106     for (angle=endangle;angle-startangle>=step;angle-=step) {
2107         gfx_add_point(node,
2108                 PieCenterX+sin(angle)*Radius,
2109                 PieCenterY-cos(angle)*Radius );
2110     }
2111 }
2112
2113 #endif
2114
2115 int
2116 graph_size_location(image_desc_t *im, int elements
2117
2118 #ifdef WITH_PIECHART
2119 , int piechart
2120 #endif
2121
2122  )
2123 {
2124     /* The actual size of the image to draw is determined from
2125     ** several sources.  The size given on the command line is
2126     ** the graph area but we need more as we have to draw labels
2127     ** and other things outside the graph area
2128     */
2129
2130     /* +-+-------------------------------------------+
2131     ** |l|.................title.....................|
2132     ** |e+--+-------------------------------+--------+
2133     ** |b| b|                               |        |
2134     ** |a| a|                               |  pie   |
2135     ** |l| l|          main graph area      | chart  |
2136     ** |.| .|                               |  area  |
2137     ** |t| y|                               |        |
2138     ** |r+--+-------------------------------+--------+
2139     ** |e|  | x-axis labels                 |        |
2140     ** |v+--+-------------------------------+--------+
2141     ** | |..............legends......................|
2142     ** +-+-------------------------------------------+
2143     */
2144     int Xvertical=0,
2145                         Ytitle   =0,
2146         Xylabel  =0,
2147         Xmain    =0,    Ymain    =0,
2148 #ifdef WITH_PIECHART
2149         Xpie     =0,    Ypie     =0,
2150 #endif
2151                         Yxlabel  =0,
2152 #if 0
2153         Xlegend  =0,    Ylegend  =0,
2154 #endif
2155         Xspacing =15,  Yspacing =15;
2156
2157     if (im->extra_flags & ONLY_GRAPH) {
2158         im->xorigin =0;
2159         im->ximg = im->xsize;
2160         im->yimg = im->ysize;
2161         im->yorigin = im->ysize;
2162         ytr(im,DNAN);
2163         return 0;
2164     }
2165
2166     if (im->ylegend[0] != '\0' ) {
2167            Xvertical = im->text_prop[TEXT_PROP_UNIT].size *2;
2168     }
2169
2170
2171     if (im->title[0] != '\0') {
2172         /* The title is placed "inbetween" two text lines so it
2173         ** automatically has some vertical spacing.  The horizontal
2174         ** spacing is added here, on each side.
2175         */
2176         /* don't care for the with of the title
2177                 Xtitle = gfx_get_text_width(im->canvas, 0,
2178                 im->text_prop[TEXT_PROP_TITLE].font,
2179                 im->text_prop[TEXT_PROP_TITLE].size,
2180                 im->tabwidth,
2181                 im->title, 0) + 2*Xspacing; */
2182         Ytitle = im->text_prop[TEXT_PROP_TITLE].size*2.6+10;
2183     }
2184
2185     if (elements) {
2186         Xmain=im->xsize;
2187         Ymain=im->ysize;
2188         if (im->draw_x_grid) {
2189             Yxlabel=im->text_prop[TEXT_PROP_AXIS].size *2.5;
2190         }
2191         if (im->draw_y_grid) {
2192             Xylabel=gfx_get_text_width(im->canvas, 0,
2193                         im->text_prop[TEXT_PROP_AXIS].font,
2194                         im->text_prop[TEXT_PROP_AXIS].size,
2195                         im->tabwidth,
2196                         "0", 0) * im->unitslength;
2197         }
2198     }
2199
2200 #ifdef WITH_PIECHART
2201     if (piechart) {
2202         im->piesize=im->xsize<im->ysize?im->xsize:im->ysize;
2203         Xpie=im->piesize;
2204         Ypie=im->piesize;
2205     }
2206 #endif
2207
2208     /* Now calculate the total size.  Insert some spacing where
2209        desired.  im->xorigin and im->yorigin need to correspond
2210        with the lower left corner of the main graph area or, if
2211        this one is not set, the imaginary box surrounding the
2212        pie chart area. */
2213
2214     /* The legend width cannot yet be determined, as a result we
2215     ** have problems adjusting the image to it.  For now, we just
2216     ** forget about it at all; the legend will have to fit in the
2217     ** size already allocated.
2218     */
2219     im->ximg = Xylabel + Xmain + 2 * Xspacing;
2220
2221 #ifdef WITH_PIECHART
2222     im->ximg  += Xpie;
2223 #endif
2224
2225     if (Xmain) im->ximg += Xspacing;
2226 #ifdef WITH_PIECHART
2227     if (Xpie) im->ximg += Xspacing;
2228 #endif
2229
2230     im->xorigin = Xspacing + Xylabel;
2231
2232     /* the length of the title should not influence with width of the graph
2233        if (Xtitle > im->ximg) im->ximg = Xtitle; */
2234
2235     if (Xvertical) { /* unit description */
2236         im->ximg += Xvertical;
2237         im->xorigin += Xvertical;
2238     }
2239     xtr(im,0);
2240
2241     /* The vertical size is interesting... we need to compare
2242     ** the sum of {Ytitle, Ymain, Yxlabel, Ylegend} with Yvertical
2243     ** however we need to know {Ytitle+Ymain+Yxlabel} in order to
2244     ** start even thinking about Ylegend.
2245     **
2246     ** Do it in three portions: First calculate the inner part,
2247     ** then do the legend, then adjust the total height of the img.
2248     */
2249
2250     /* reserve space for main and/or pie */
2251
2252     im->yimg = Ymain + Yxlabel;
2253
2254 #ifdef WITH_PIECHART
2255     if (im->yimg < Ypie) im->yimg = Ypie;
2256 #endif
2257
2258     im->yorigin = im->yimg - Yxlabel;
2259
2260     /* reserve space for the title *or* some padding above the graph */
2261     if (Ytitle) {
2262         im->yimg += Ytitle;
2263         im->yorigin += Ytitle;
2264     } else {
2265         im->yimg += 1.5*Yspacing;
2266         im->yorigin += 1.5*Yspacing;
2267     }
2268     /* reserve space for padding below the graph */
2269     im->yimg += Yspacing;
2270
2271     /* Determine where to place the legends onto the image.
2272     ** Adjust im->yimg to match the space requirements.
2273     */
2274     if(leg_place(im)==-1)
2275         return -1;
2276
2277
2278 #if 0
2279     if (Xlegend > im->ximg) {
2280         im->ximg = Xlegend;
2281         /* reposition Pie */
2282     }
2283 #endif
2284
2285 #ifdef WITH_PIECHART
2286     /* The pie is placed in the upper right hand corner,
2287     ** just below the title (if any) and with sufficient
2288     ** padding.
2289     */
2290     if (elements) {
2291         im->pie_x = im->ximg - Xspacing - Xpie/2;
2292         im->pie_y = im->yorigin-Ymain+Ypie/2;
2293     } else {
2294         im->pie_x = im->ximg/2;
2295         im->pie_y = im->yorigin-Ypie/2;
2296     }
2297 #endif
2298
2299     ytr(im,DNAN);
2300     return 0;
2301 }
2302
2303 /* from http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm */
2304 /* yes we are loosing precision by doing tos with floats instead of doubles
2305    but it seems more stable this way. */
2306
2307 static int AlmostEqual2sComplement (float A, float B, int maxUlps)
2308 {
2309
2310     int aInt = *(int*)&A;
2311     int bInt = *(int*)&B;
2312     int intDiff;
2313     /* Make sure maxUlps is non-negative and small enough that the
2314        default NAN won't compare as equal to anything.  */
2315
2316     /* assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024); */
2317
2318     /* Make aInt lexicographically ordered as a twos-complement int */
2319
2320     if (aInt < 0)
2321         aInt = 0x80000000l - aInt;
2322
2323     /* Make bInt lexicographically ordered as a twos-complement int */
2324
2325     if (bInt < 0)
2326         bInt = 0x80000000l - bInt;
2327
2328     intDiff = abs(aInt - bInt);
2329
2330     if (intDiff <= maxUlps)
2331         return 1;
2332
2333     return 0;
2334 }
2335
2336 /* draw that picture thing ... */
2337 int
2338 graph_paint(image_desc_t *im, char ***calcpr)
2339 {
2340   int i,ii;
2341   int lazy =     lazy_check(im);
2342 #ifdef WITH_PIECHART
2343   int piechart = 0;
2344   double PieStart=0.0;
2345 #endif
2346   FILE  *fo;
2347   gfx_node_t *node;
2348
2349   double areazero = 0.0;
2350   graph_desc_t *lastgdes = NULL;
2351
2352   /* if we are lazy and there is nothing to PRINT ... quit now */
2353   if (lazy && im->prt_c==0) return 0;
2354
2355   /* pull the data from the rrd files ... */
2356
2357   if(data_fetch(im)==-1)
2358     return -1;
2359
2360   /* evaluate VDEF and CDEF operations ... */
2361   if(data_calc(im)==-1)
2362     return -1;
2363
2364 #ifdef WITH_PIECHART
2365   /* check if we need to draw a piechart */
2366   for(i=0;i<im->gdes_c;i++){
2367     if (im->gdes[i].gf == GF_PART) {
2368       piechart=1;
2369       break;
2370     }
2371   }
2372 #endif
2373
2374   /* calculate and PRINT and GPRINT definitions. We have to do it at
2375    * this point because it will affect the length of the legends
2376    * if there are no graph elements we stop here ...
2377    * if we are lazy, try to quit ...
2378    */
2379   i=print_calc(im,calcpr);
2380   if(i<0) return -1;
2381   if(((i==0)
2382 #ifdef WITH_PIECHART
2383 &&(piechart==0)
2384 #endif
2385 ) || lazy) return 0;
2386
2387 #ifdef WITH_PIECHART
2388   /* If there's only the pie chart to draw, signal this */
2389   if (i==0) piechart=2;
2390 #endif
2391
2392   /* get actual drawing data and find min and max values*/
2393   if(data_proc(im)==-1)
2394     return -1;
2395
2396   if(!im->logarithmic){si_unit(im);}        /* identify si magnitude Kilo, Mega Giga ? */
2397
2398   if(!im->rigid && ! im->logarithmic)
2399     expand_range(im);   /* make sure the upper and lower limit are
2400                            sensible values */
2401
2402   if (!calc_horizontal_grid(im))
2403     return -1;
2404
2405   if (im->gridfit)
2406     apply_gridfit(im);
2407
2408
2409 /**************************************************************
2410  *** Calculating sizes and locations became a bit confusing ***
2411  *** so I moved this into a separate function.              ***
2412  **************************************************************/
2413   if(graph_size_location(im,i
2414 #ifdef WITH_PIECHART
2415 ,piechart
2416 #endif
2417 )==-1)
2418     return -1;
2419
2420   /* the actual graph is created by going through the individual
2421      graph elements and then drawing them */
2422
2423   node=gfx_new_area ( im->canvas,
2424                       0, 0,
2425                       0, im->yimg,
2426                       im->ximg, im->yimg,
2427                       im->graph_col[GRC_BACK]);
2428
2429   gfx_add_point(node,im->ximg, 0);
2430
2431 #ifdef WITH_PIECHART
2432   if (piechart != 2) {
2433 #endif
2434     node=gfx_new_area ( im->canvas,
2435                       im->xorigin,             im->yorigin,
2436                       im->xorigin + im->xsize, im->yorigin,
2437                       im->xorigin + im->xsize, im->yorigin-im->ysize,
2438                       im->graph_col[GRC_CANVAS]);
2439
2440     gfx_add_point(node,im->xorigin, im->yorigin - im->ysize);
2441
2442     if (im->minval > 0.0)
2443       areazero = im->minval;
2444     if (im->maxval < 0.0)
2445       areazero = im->maxval;
2446 #ifdef WITH_PIECHART
2447    }
2448 #endif
2449
2450 #ifdef WITH_PIECHART
2451   if (piechart) {
2452     pie_part(im,im->graph_col[GRC_CANVAS],im->pie_x,im->pie_y,im->piesize*0.5,0,2*M_PI);
2453   }
2454 #endif
2455
2456   for(i=0;i<im->gdes_c;i++){
2457     switch(im->gdes[i].gf){
2458     case GF_CDEF:
2459     case GF_VDEF:
2460     case GF_DEF:
2461     case GF_PRINT:
2462     case GF_GPRINT:
2463     case GF_COMMENT:
2464     case GF_HRULE:
2465     case GF_VRULE:
2466     case GF_XPORT:
2467     case GF_SHIFT:
2468       break;
2469     case GF_TICK:
2470       for (ii = 0; ii < im->xsize; ii++)
2471         {
2472           if (!isnan(im->gdes[i].p_data[ii]) &&
2473               im->gdes[i].p_data[ii] != 0.0)
2474            {
2475               if (im -> gdes[i].yrule > 0 ) {
2476                       gfx_new_line(im->canvas,
2477                                    im -> xorigin + ii, im->yorigin,
2478                                    im -> xorigin + ii, im->yorigin - im -> gdes[i].yrule * im -> ysize,
2479                                    1.0,
2480                                    im -> gdes[i].col );
2481               } else if ( im -> gdes[i].yrule < 0 ) {
2482                       gfx_new_line(im->canvas,
2483                                    im -> xorigin + ii, im->yorigin - im -> ysize,
2484                                    im -> xorigin + ii, im->yorigin - ( 1 - im -> gdes[i].yrule ) * im -> ysize,
2485                                    1.0,
2486                                    im -> gdes[i].col );
2487
2488               }
2489            }
2490         }
2491       break;
2492     case GF_LINE:
2493     case GF_AREA:
2494       /* fix data points at oo and -oo */
2495       for(ii=0;ii<im->xsize;ii++){
2496         if (isinf(im->gdes[i].p_data[ii])){
2497           if (im->gdes[i].p_data[ii] > 0) {
2498             im->gdes[i].p_data[ii] = im->maxval ;
2499           } else {
2500             im->gdes[i].p_data[ii] = im->minval ;
2501           }
2502
2503         }
2504       } /* for */
2505
2506       /* *******************************************************
2507        a           ___. (a,t)
2508                   |   |    ___
2509               ____|   |   |   |
2510               |       |___|
2511        -------|--t-1--t--------------------------------
2512
2513       if we know the value at time t was a then
2514       we draw a square from t-1 to t with the value a.
2515
2516       ********************************************************* */
2517       if (im->gdes[i].col != 0x0){
2518         /* GF_LINE and friend */
2519         if(im->gdes[i].gf == GF_LINE ){
2520           double last_y=0.0;
2521           node = NULL;
2522           for(ii=1;ii<im->xsize;ii++){
2523             if (isnan(im->gdes[i].p_data[ii]) || (im->slopemode==1 && isnan(im->gdes[i].p_data[ii-1]))){
2524                 node = NULL;
2525                 continue;
2526             }
2527             if ( node == NULL ) {
2528                 last_y = ytr(im,im->gdes[i].p_data[ii]);
2529                 if ( im->slopemode == 0 ){
2530                   node = gfx_new_line(im->canvas,
2531                                     ii-1+im->xorigin,last_y,
2532                                     ii+im->xorigin,last_y,
2533                                     im->gdes[i].linewidth,
2534                                     im->gdes[i].col);
2535                 } else {
2536                   node = gfx_new_line(im->canvas,
2537                                     ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii-1]),
2538                                     ii+im->xorigin,last_y,
2539                                     im->gdes[i].linewidth,
2540                                     im->gdes[i].col);
2541                 }
2542              } else {
2543                double new_y = ytr(im,im->gdes[i].p_data[ii]);
2544                if ( im->slopemode==0 && ! AlmostEqual2sComplement(new_y,last_y,4)){
2545                    gfx_add_point(node,ii-1+im->xorigin,new_y);
2546                };
2547                last_y = new_y;
2548                gfx_add_point(node,ii+im->xorigin,new_y);
2549              };
2550
2551           }
2552         } else {
2553           int idxI=-1;
2554           double *foreY=malloc(sizeof(double)*im->xsize*2);
2555           double *foreX=malloc(sizeof(double)*im->xsize*2);
2556           double *backY=malloc(sizeof(double)*im->xsize*2);
2557           double *backX=malloc(sizeof(double)*im->xsize*2);
2558           int drawem = 0;
2559           for(ii=0;ii<=im->xsize;ii++){
2560             double ybase,ytop;
2561             if ( idxI > 0 && ( drawem != 0 || ii==im->xsize)){
2562                int cntI=1;
2563                int lastI=0;
2564                while (cntI < idxI && AlmostEqual2sComplement(foreY[lastI],foreY[cntI],4) && AlmostEqual2sComplement(foreY[lastI],foreY[cntI+1],4)){cntI++;}
2565                node = gfx_new_area(im->canvas,
2566                                 backX[0],backY[0],
2567                                 foreX[0],foreY[0],
2568                                 foreX[cntI],foreY[cntI], im->gdes[i].col);
2569                while (cntI < idxI) {
2570                  lastI = cntI;
2571                  cntI++;
2572                  while ( cntI < idxI && AlmostEqual2sComplement(foreY[lastI],foreY[cntI],4) && AlmostEqual2sComplement(foreY[lastI],foreY[cntI+1],4)){cntI++;}
2573                  gfx_add_point(node,foreX[cntI],foreY[cntI]);
2574                }
2575                gfx_add_point(node,backX[idxI],backY[idxI]);
2576                while (idxI > 1){
2577                  lastI = idxI;
2578                  idxI--;
2579                  while ( idxI > 1 && AlmostEqual2sComplement(backY[lastI], backY[idxI],4) && AlmostEqual2sComplement(backY[lastI],backY[idxI-1],4)){idxI--;}
2580                  gfx_add_point(node,backX[idxI],backY[idxI]);
2581                }
2582                idxI=-1;
2583                drawem = 0;
2584             }
2585             if (drawem != 0){
2586               drawem = 0;
2587               idxI=-1;
2588             }
2589             if (ii == im->xsize) break;
2590
2591             /* keep things simple for now, just draw these bars
2592                do not try to build a big and complex area */
2593
2594
2595             if ( im->slopemode == 0 && ii==0){
2596                 continue;
2597             }
2598             if ( isnan(im->gdes[i].p_data[ii]) ) {
2599                 drawem = 1;
2600                 continue;
2601             }
2602             ytop = ytr(im,im->gdes[i].p_data[ii]);
2603             if ( lastgdes && im->gdes[i].stack ) {
2604                   ybase = ytr(im,lastgdes->p_data[ii]);
2605             } else {
2606                   ybase = ytr(im,areazero);
2607             }
2608             if ( ybase == ytop ){
2609                 drawem = 1;
2610                 continue;
2611             }
2612             /* every area has to be wound clock-wise,
2613                so we have to make sur base remains base  */
2614             if (ybase > ytop){
2615                 double extra = ytop;
2616                 ytop = ybase;
2617                 ybase = extra;
2618             }
2619             if ( im->slopemode == 0 ){
2620                     backY[++idxI] = ybase-0.2;
2621                     backX[idxI] = ii+im->xorigin-1;
2622                     foreY[idxI] = ytop+0.2;
2623                     foreX[idxI] = ii+im->xorigin-1;
2624             }
2625             backY[++idxI] = ybase-0.2;
2626             backX[idxI] = ii+im->xorigin;
2627             foreY[idxI] = ytop+0.2;
2628             foreX[idxI] = ii+im->xorigin;
2629           }
2630           /* close up any remaining area */
2631           free(foreY);
2632           free(foreX);
2633           free(backY);
2634           free(backX);
2635         } /* else GF_LINE */
2636       } /* if color != 0x0 */
2637       /* make sure we do not run into trouble when stacking on NaN */
2638       for(ii=0;ii<im->xsize;ii++){
2639         if (isnan(im->gdes[i].p_data[ii])) {
2640           if (lastgdes && (im->gdes[i].stack)) {
2641             im->gdes[i].p_data[ii] = lastgdes->p_data[ii];
2642           } else {
2643             im->gdes[i].p_data[ii] = areazero;
2644           }
2645         }
2646       }
2647       lastgdes = &(im->gdes[i]);
2648       break;
2649 #ifdef WITH_PIECHART
2650     case GF_PART:
2651       if(isnan(im->gdes[i].yrule)) /* fetch variable */
2652         im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
2653
2654       if (finite(im->gdes[i].yrule)) {  /* even the fetched var can be NaN */
2655         pie_part(im,im->gdes[i].col,
2656                 im->pie_x,im->pie_y,im->piesize*0.4,
2657                 M_PI*2.0*PieStart/100.0,
2658                 M_PI*2.0*(PieStart+im->gdes[i].yrule)/100.0);
2659         PieStart += im->gdes[i].yrule;
2660       }
2661       break;
2662 #endif
2663     case GF_STACK:
2664       rrd_set_error("STACK should already be turned into LINE or AREA here");
2665       return -1;
2666       break;
2667
2668     } /* switch */
2669   }
2670 #ifdef WITH_PIECHART
2671   if (piechart==2) {
2672     im->draw_x_grid=0;
2673     im->draw_y_grid=0;
2674   }
2675 #endif
2676
2677
2678   /* grid_paint also does the text */
2679   if( !(im->extra_flags & ONLY_GRAPH) )
2680     grid_paint(im);
2681
2682
2683   if( !(im->extra_flags & ONLY_GRAPH) )
2684       axis_paint(im);
2685
2686   /* the RULES are the last thing to paint ... */
2687   for(i=0;i<im->gdes_c;i++){
2688
2689     switch(im->gdes[i].gf){
2690     case GF_HRULE:
2691       if(isnan(im->gdes[i].yrule)) { /* fetch variable */
2692         im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
2693       };
2694       if(im->gdes[i].yrule >= im->minval
2695          && im->gdes[i].yrule <= im->maxval)
2696         gfx_new_line(im->canvas,
2697                      im->xorigin,ytr(im,im->gdes[i].yrule),
2698                      im->xorigin+im->xsize,ytr(im,im->gdes[i].yrule),
2699                      1.0,im->gdes[i].col);
2700       break;
2701     case GF_VRULE:
2702       if(im->gdes[i].xrule == 0) { /* fetch variable */
2703         im->gdes[i].xrule = im->gdes[im->gdes[i].vidx].vf.when;
2704       };
2705       if(im->gdes[i].xrule >= im->start
2706          && im->gdes[i].xrule <= im->end)
2707         gfx_new_line(im->canvas,
2708                      xtr(im,im->gdes[i].xrule),im->yorigin,
2709                      xtr(im,im->gdes[i].xrule),im->yorigin-im->ysize,
2710                      1.0,im->gdes[i].col);
2711       break;
2712     default:
2713       break;
2714     }
2715   }
2716
2717
2718   if (strcmp(im->graphfile,"-")==0) {
2719     fo = im->graphhandle ? im->graphhandle : stdout;
2720 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
2721     /* Change translation mode for stdout to BINARY */
2722     _setmode( _fileno( fo ), O_BINARY );
2723 #endif
2724   } else {
2725     if ((fo = fopen(im->graphfile,"wb")) == NULL) {
2726       rrd_set_error("Opening '%s' for write: %s",im->graphfile,
2727                     rrd_strerror(errno));
2728       return (-1);
2729     }
2730   }
2731   gfx_render (im->canvas,im->ximg,im->yimg,0x00000000,fo);
2732   if (strcmp(im->graphfile,"-") != 0)
2733     fclose(fo);
2734   return 0;
2735 }
2736
2737
2738 /*****************************************************
2739  * graph stuff
2740  *****************************************************/
2741
2742 int
2743 gdes_alloc(image_desc_t *im){
2744
2745     im->gdes_c++;
2746     if ((im->gdes = (graph_desc_t *) rrd_realloc(im->gdes, (im->gdes_c)
2747                                            * sizeof(graph_desc_t)))==NULL){
2748         rrd_set_error("realloc graph_descs");
2749         return -1;
2750     }
2751
2752
2753     im->gdes[im->gdes_c-1].step=im->step;
2754     im->gdes[im->gdes_c-1].step_orig=im->step;
2755     im->gdes[im->gdes_c-1].stack=0;
2756     im->gdes[im->gdes_c-1].linewidth=0;
2757     im->gdes[im->gdes_c-1].debug=0;
2758     im->gdes[im->gdes_c-1].start=im->start;
2759     im->gdes[im->gdes_c-1].end=im->end;
2760     im->gdes[im->gdes_c-1].vname[0]='\0';
2761     im->gdes[im->gdes_c-1].data=NULL;
2762     im->gdes[im->gdes_c-1].ds_namv=NULL;
2763     im->gdes[im->gdes_c-1].data_first=0;
2764     im->gdes[im->gdes_c-1].p_data=NULL;
2765     im->gdes[im->gdes_c-1].rpnp=NULL;
2766     im->gdes[im->gdes_c-1].shift=0;
2767     im->gdes[im->gdes_c-1].col = 0x0;
2768     im->gdes[im->gdes_c-1].legend[0]='\0';
2769     im->gdes[im->gdes_c-1].format[0]='\0';
2770     im->gdes[im->gdes_c-1].rrd[0]='\0';
2771     im->gdes[im->gdes_c-1].ds=-1;
2772     im->gdes[im->gdes_c-1].p_data=NULL;
2773     im->gdes[im->gdes_c-1].yrule=DNAN;
2774     im->gdes[im->gdes_c-1].xrule=0;
2775     return 0;
2776 }
2777
2778 /* copies input untill the first unescaped colon is found
2779    or until input ends. backslashes have to be escaped as well */
2780 int
2781 scan_for_col(const char *const input, int len, char *const output)
2782 {
2783     int inp,outp=0;
2784     for (inp=0;
2785          inp < len &&
2786            input[inp] != ':' &&
2787            input[inp] != '\0';
2788          inp++){
2789       if (input[inp] == '\\' &&
2790           input[inp+1] != '\0' &&
2791           (input[inp+1] == '\\' ||
2792            input[inp+1] == ':')){
2793         output[outp++] = input[++inp];
2794       }
2795       else {
2796         output[outp++] = input[inp];
2797       }
2798     }
2799     output[outp] = '\0';
2800     return inp;
2801 }
2802 /* Some surgery done on this function, it became ridiculously big.
2803 ** Things moved:
2804 ** - initializing     now in rrd_graph_init()
2805 ** - options parsing  now in rrd_graph_options()
2806 ** - script parsing   now in rrd_graph_script()
2807 */
2808 int
2809 rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize, FILE *stream, double *ymin, double *ymax)
2810 {
2811     image_desc_t   im;
2812     rrd_graph_init(&im);
2813     im.graphhandle = stream;
2814
2815     rrd_graph_options(argc,argv,&im);
2816     if (rrd_test_error()) {
2817         im_free(&im);
2818         return -1;
2819     }
2820
2821     if (strlen(argv[optind])>=MAXPATH) {
2822         rrd_set_error("filename (including path) too long");
2823         im_free(&im);
2824         return -1;
2825     }
2826     strncpy(im.graphfile,argv[optind],MAXPATH-1);
2827     im.graphfile[MAXPATH-1]='\0';
2828
2829     rrd_graph_script(argc,argv,&im,1);
2830     if (rrd_test_error()) {
2831         im_free(&im);
2832         return -1;
2833     }
2834
2835     /* Everything is now read and the actual work can start */
2836
2837     (*prdata)=NULL;
2838     if (graph_paint(&im,prdata)==-1){
2839         im_free(&im);
2840         return -1;
2841     }
2842
2843     /* The image is generated and needs to be output.
2844     ** Also, if needed, print a line with information about the image.
2845     */
2846
2847     *xsize=im.ximg;
2848     *ysize=im.yimg;
2849     *ymin=im.minval;
2850     *ymax=im.maxval;
2851     if (im.imginfo) {
2852         char *filename;
2853         if (!(*prdata)) {
2854             /* maybe prdata is not allocated yet ... lets do it now */
2855             if ((*prdata = calloc(2,sizeof(char *)))==NULL) {
2856                 rrd_set_error("malloc imginfo");
2857                 return -1;
2858             };
2859         }
2860         if(((*prdata)[0] = malloc((strlen(im.imginfo)+200+strlen(im.graphfile))*sizeof(char)))
2861          ==NULL){
2862             rrd_set_error("malloc imginfo");
2863             return -1;
2864         }
2865         filename=im.graphfile+strlen(im.graphfile);
2866         while(filename > im.graphfile) {
2867             if (*(filename-1)=='/' || *(filename-1)=='\\' ) break;
2868             filename--;
2869         }
2870
2871         sprintf((*prdata)[0],im.imginfo,filename,(long)(im.canvas->zoom*im.ximg),(long)(im.canvas->zoom*im.yimg));
2872     }
2873     im_free(&im);
2874     return 0;
2875 }
2876
2877 void
2878 rrd_graph_init(image_desc_t *im)
2879 {
2880     unsigned int i;
2881
2882 #ifdef HAVE_TZSET
2883     tzset();
2884 #endif
2885 #ifdef HAVE_SETLOCALE
2886     setlocale(LC_TIME,"");
2887 #ifdef HAVE_MBSTOWCS
2888     setlocale(LC_CTYPE,"");
2889 #endif
2890 #endif
2891     im->yorigin=0;
2892     im->xorigin=0;
2893     im->minval=0;
2894     im->xlab_user.minsec = -1;
2895     im->ximg=0;
2896     im->yimg=0;
2897     im->xsize = 400;
2898     im->ysize = 100;
2899     im->step = 0;
2900     im->ylegend[0] = '\0';
2901     im->title[0] = '\0';
2902     im->minval = DNAN;
2903     im->maxval = DNAN;
2904     im->unitsexponent= 9999;
2905     im->unitslength= 6;
2906     im->symbol = ' ';
2907     im->viewfactor = 1.0;
2908     im->extra_flags= 0;
2909     im->rigid = 0;
2910     im->gridfit = 1;
2911     im->imginfo = NULL;
2912     im->lazy = 0;
2913     im->slopemode = 0;
2914     im->logarithmic = 0;
2915     im->ygridstep = DNAN;
2916     im->draw_x_grid = 1;
2917     im->draw_y_grid = 1;
2918     im->base = 1000;
2919     im->prt_c = 0;
2920     im->gdes_c = 0;
2921     im->gdes = NULL;
2922     im->canvas = gfx_new_canvas();
2923     im->grid_dash_on = 1;
2924     im->grid_dash_off = 1;
2925     im->tabwidth = 40.0;
2926
2927     for(i=0;i<DIM(graph_col);i++)
2928         im->graph_col[i]=graph_col[i];
2929
2930 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
2931     {
2932             char *windir;
2933             char rrd_win_default_font[1000];
2934             windir = getenv("windir");
2935             /* %windir% is something like D:\windows or C:\winnt */
2936             if (windir != NULL) {
2937                     strncpy(rrd_win_default_font,windir,999);
2938                     rrd_win_default_font[999] = '\0';
2939                     strcat(rrd_win_default_font,"\\fonts\\");
2940                     strcat(rrd_win_default_font,RRD_DEFAULT_FONT);
2941                     for(i=0;i<DIM(text_prop);i++){
2942                             strncpy(text_prop[i].font,rrd_win_default_font,sizeof(text_prop[i].font)-1);
2943                             text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
2944                      }
2945              }
2946     }
2947 #endif
2948     {
2949             char *deffont;
2950             deffont = getenv("RRD_DEFAULT_FONT");
2951             if (deffont != NULL) {
2952                  for(i=0;i<DIM(text_prop);i++){
2953                         strncpy(text_prop[i].font,deffont,sizeof(text_prop[i].font)-1);
2954                         text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
2955                  }
2956             }
2957     }
2958     for(i=0;i<DIM(text_prop);i++){
2959       im->text_prop[i].size = text_prop[i].size;
2960       strcpy(im->text_prop[i].font,text_prop[i].font);
2961     }
2962 }
2963
2964 void
2965 rrd_graph_options(int argc, char *argv[],image_desc_t *im)
2966 {
2967     int                 stroff;
2968     char                *parsetime_error = NULL;
2969     char                scan_gtm[12],scan_mtm[12],scan_ltm[12],col_nam[12];
2970     time_t              start_tmp=0,end_tmp=0;
2971     long                long_tmp;
2972     struct rrd_time_value       start_tv, end_tv;
2973     gfx_color_t         color;
2974     optind = 0; opterr = 0;  /* initialize getopt */
2975
2976     parsetime("end-24h", &start_tv);
2977     parsetime("now", &end_tv);
2978
2979     while (1){
2980         static struct option long_options[] =
2981         {
2982             {"start",      required_argument, 0,  's'},
2983             {"end",        required_argument, 0,  'e'},
2984             {"x-grid",     required_argument, 0,  'x'},
2985             {"y-grid",     required_argument, 0,  'y'},
2986             {"vertical-label",required_argument,0,'v'},
2987             {"width",      required_argument, 0,  'w'},
2988             {"height",     required_argument, 0,  'h'},
2989             {"interlaced", no_argument,       0,  'i'},
2990             {"upper-limit",required_argument, 0,  'u'},
2991             {"lower-limit",required_argument, 0,  'l'},
2992             {"rigid",      no_argument,       0,  'r'},
2993             {"base",       required_argument, 0,  'b'},
2994             {"logarithmic",no_argument,       0,  'o'},
2995             {"color",      required_argument, 0,  'c'},
2996             {"font",       required_argument, 0,  'n'},
2997             {"title",      required_argument, 0,  't'},
2998             {"imginfo",    required_argument, 0,  'f'},
2999             {"imgformat",  required_argument, 0,  'a'},
3000             {"lazy",       no_argument,       0,  'z'},
3001             {"zoom",       required_argument, 0,  'm'},
3002             {"no-legend",  no_argument,       0,  'g'},
3003             {"force-rules-legend",no_argument,0,  'F'},
3004             {"only-graph", no_argument,       0,  'j'},
3005             {"alt-y-grid", no_argument,       0,  'Y'},
3006             {"no-minor",   no_argument,       0,  'I'},
3007             {"slope-mode", no_argument,       0,  'E'},
3008             {"alt-autoscale", no_argument,    0,  'A'},
3009             {"alt-autoscale-max", no_argument, 0, 'M'},
3010             {"no-gridfit", no_argument,       0,   'N'},
3011             {"units-exponent",required_argument, 0, 'X'},
3012             {"units-length",required_argument, 0, 'L'},
3013             {"step",       required_argument, 0,    'S'},
3014             {"tabwidth",   required_argument, 0,    'T'},
3015             {"font-render-mode", required_argument, 0, 'R'},
3016             {"font-smoothing-threshold", required_argument, 0, 'B'},
3017             {"alt-y-mrtg", no_argument,       0,  1000}, /* this has no effect it is just here to save old apps from crashing when they use it */
3018             {0,0,0,0}};
3019         int option_index = 0;
3020         int opt;
3021         int col_start,col_end;
3022
3023         opt = getopt_long(argc, argv,
3024                          "s:e:x:y:v:w:h:iu:l:rb:oc:n:m:t:f:a:I:zgjFYAMEX:L:S:T:NR:B:",
3025                           long_options, &option_index);
3026
3027         if (opt == EOF)
3028             break;
3029
3030         switch(opt) {
3031         case 'I':
3032             im->extra_flags |= NOMINOR;
3033             break;
3034         case 'Y':
3035             im->extra_flags |= ALTYGRID;
3036             break;
3037         case 'A':
3038             im->extra_flags |= ALTAUTOSCALE;
3039             break;
3040         case 'M':
3041             im->extra_flags |= ALTAUTOSCALE_MAX;
3042             break;
3043         case 'j':
3044            im->extra_flags |= ONLY_GRAPH;
3045            break;
3046         case 'g':
3047             im->extra_flags |= NOLEGEND;
3048             break;
3049         case 'F':
3050             im->extra_flags |= FORCE_RULES_LEGEND;
3051             break;
3052         case 'X':
3053             im->unitsexponent = atoi(optarg);
3054             break;
3055         case 'L':
3056             im->unitslength = atoi(optarg);
3057             break;
3058         case 'T':
3059             im->tabwidth = atof(optarg);
3060             break;
3061         case 'S':
3062             im->step =  atoi(optarg);
3063             break;
3064         case 'N':
3065             im->gridfit = 0;
3066             break;
3067         case 's':
3068             if ((parsetime_error = parsetime(optarg, &start_tv))) {
3069                 rrd_set_error( "start time: %s", parsetime_error );
3070                 return;
3071             }
3072             break;
3073         case 'e':
3074             if ((parsetime_error = parsetime(optarg, &end_tv))) {
3075                 rrd_set_error( "end time: %s", parsetime_error );
3076                 return;
3077             }
3078             break;
3079         case 'x':
3080             if(strcmp(optarg,"none") == 0){
3081               im->draw_x_grid=0;
3082               break;
3083             };
3084
3085             if(sscanf(optarg,
3086                       "%10[A-Z]:%ld:%10[A-Z]:%ld:%10[A-Z]:%ld:%ld:%n",
3087                       scan_gtm,
3088                       &im->xlab_user.gridst,
3089                       scan_mtm,
3090                       &im->xlab_user.mgridst,
3091                       scan_ltm,
3092                       &im->xlab_user.labst,
3093                       &im->xlab_user.precis,
3094                       &stroff) == 7 && stroff != 0){
3095                 strncpy(im->xlab_form, optarg+stroff, sizeof(im->xlab_form) - 1);
3096                 im->xlab_form[sizeof(im->xlab_form)-1] = '\0';
3097                 if((int)(im->xlab_user.gridtm = tmt_conv(scan_gtm)) == -1){
3098                     rrd_set_error("unknown keyword %s",scan_gtm);
3099                     return;
3100                 } else if ((int)(im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
3101                     rrd_set_error("unknown keyword %s",scan_mtm);
3102                     return;
3103                 } else if ((int)(im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
3104                     rrd_set_error("unknown keyword %s",scan_ltm);
3105                     return;
3106                 }
3107                 im->xlab_user.minsec = 1;
3108                 im->xlab_user.stst = im->xlab_form;
3109             } else {
3110                 rrd_set_error("invalid x-grid format");
3111                 return;
3112             }
3113             break;
3114         case 'y':
3115
3116             if(strcmp(optarg,"none") == 0){
3117               im->draw_y_grid=0;
3118               break;
3119             };
3120
3121             if(sscanf(optarg,
3122                       "%lf:%d",
3123                       &im->ygridstep,
3124                       &im->ylabfact) == 2) {
3125                 if(im->ygridstep<=0){
3126                     rrd_set_error("grid step must be > 0");
3127                     return;
3128                 } else if (im->ylabfact < 1){
3129                     rrd_set_error("label factor must be > 0");
3130                     return;
3131                 }
3132             } else {
3133                 rrd_set_error("invalid y-grid format");
3134                 return;
3135             }
3136             break;
3137         case 'v':
3138             strncpy(im->ylegend,optarg,150);
3139             im->ylegend[150]='\0';
3140             break;
3141         case 'u':
3142             im->maxval = atof(optarg);
3143             break;
3144         case 'l':
3145             im->minval = atof(optarg);
3146             break;
3147         case 'b':
3148             im->base = atol(optarg);
3149             if(im->base != 1024 && im->base != 1000 ){
3150                 rrd_set_error("the only sensible value for base apart from 1000 is 1024");
3151                 return;
3152             }
3153             break;
3154         case 'w':
3155             long_tmp = atol(optarg);
3156             if (long_tmp < 10) {
3157                 rrd_set_error("width below 10 pixels");
3158                 return;
3159             }
3160             im->xsize = long_tmp;
3161             break;
3162         case 'h':
3163             long_tmp = atol(optarg);
3164             if (long_tmp < 10) {
3165                 rrd_set_error("height below 10 pixels");
3166                 return;
3167             }
3168             im->ysize = long_tmp;
3169             break;
3170         case 'i':
3171             im->canvas->interlaced = 1;
3172             break;
3173         case 'r':
3174             im->rigid = 1;
3175             break;
3176         case 'f':
3177             im->imginfo = optarg;
3178             break;
3179         case 'a':
3180             if((int)(im->canvas->imgformat = if_conv(optarg)) == -1) {
3181                 rrd_set_error("unsupported graphics format '%s'",optarg);
3182                 return;
3183             }
3184             break;
3185         case 'z':
3186             im->lazy = 1;
3187             break;
3188         case 'E':
3189             im->slopemode = 1;
3190             break;
3191
3192         case 'o':
3193             im->logarithmic = 1;
3194             if (isnan(im->minval))
3195                 im->minval=1;
3196             break;
3197         case 'c':
3198             if(sscanf(optarg,
3199                       "%10[A-Z]#%n%8lx%n",
3200                       col_nam,&col_start,&color,&col_end) == 2){
3201                 int ci;
3202                 int col_len = col_end - col_start;
3203                 switch (col_len){
3204                         case 3:
3205                                 color = (
3206                                         ((color & 0xF00) * 0x110000) |
3207                                         ((color & 0x0F0) * 0x011000) |
3208                                         ((color & 0x00F) * 0x001100) |
3209                                         0x000000FF
3210                                         );
3211                                 break;
3212                         case 4:
3213                                 color = (
3214                                         ((color & 0xF000) * 0x11000) |
3215                                         ((color & 0x0F00) * 0x01100) |
3216                                         ((color & 0x00F0) * 0x00110) |
3217                                         ((color & 0x000F) * 0x00011)
3218                                         );
3219                                 break;
3220                         case 6:
3221                                 color = (color << 8) + 0xff /* shift left by 8 */;
3222                                 break;
3223                         case 8:
3224                                 break;
3225                         default:
3226                                 rrd_set_error("the color format is #RRGGBB[AA]");
3227                                 return;
3228                 }
3229                 if((ci=grc_conv(col_nam)) != -1){
3230                     im->graph_col[ci]=color;
3231                 }  else {
3232                   rrd_set_error("invalid color name '%s'",col_nam);
3233                   return;
3234                 }
3235             } else {
3236                 rrd_set_error("invalid color def format");
3237                 return;
3238             }
3239             break;
3240         case 'n':{
3241             char prop[15];
3242             double size = 1;
3243             char font[1024] = "";
3244
3245             if(sscanf(optarg,
3246                                 "%10[A-Z]:%lf:%1000s",
3247                                 prop,&size,font) >= 2){
3248                 int sindex,propidx;
3249                 if((sindex=text_prop_conv(prop)) != -1){
3250                   for (propidx=sindex;propidx<TEXT_PROP_LAST;propidx++){
3251                       if (size > 0){
3252                           im->text_prop[propidx].size=size;
3253                       }
3254                       if (strlen(font) > 0){
3255                           strcpy(im->text_prop[propidx].font,font);
3256                       }
3257                       if (propidx==sindex && sindex != 0) break;
3258                   }
3259                 } else {
3260                     rrd_set_error("invalid fonttag '%s'",prop);
3261                     return;
3262                 }
3263             } else {
3264                 rrd_set_error("invalid text property format");
3265                 return;
3266             }
3267             break;
3268         }
3269         case 'm':
3270             im->canvas->zoom = atof(optarg);
3271             if (im->canvas->zoom <= 0.0) {
3272                 rrd_set_error("zoom factor must be > 0");
3273                 return;
3274             }
3275           break;
3276         case 't':
3277             strncpy(im->title,optarg,150);
3278             im->title[150]='\0';
3279             break;
3280
3281         case 'R':
3282                 if ( strcmp( optarg, "normal" ) == 0 )
3283                         im->canvas->aa_type = AA_NORMAL;
3284                 else if ( strcmp( optarg, "light" ) == 0 )
3285                         im->canvas->aa_type = AA_LIGHT;
3286                 else if ( strcmp( optarg, "mono" ) == 0 )
3287                         im->canvas->aa_type = AA_NONE;
3288                 else
3289                 {
3290                         rrd_set_error("unknown font-render-mode '%s'", optarg );
3291                         return;
3292                 }
3293                 break;
3294
3295         case 'B':
3296             im->canvas->font_aa_threshold = atof(optarg);
3297                 break;
3298
3299         case '?':
3300             if (optopt != 0)
3301                 rrd_set_error("unknown option '%c'", optopt);
3302             else
3303                 rrd_set_error("unknown option '%s'",argv[optind-1]);
3304             return;
3305         }
3306     }
3307
3308     if (optind >= argc) {
3309        rrd_set_error("missing filename");
3310        return;
3311     }
3312
3313     if (im->logarithmic == 1 && (im->minval <= 0 || isnan(im->minval))){
3314         rrd_set_error("for a logarithmic yaxis you must specify a lower-limit > 0");
3315         return;
3316     }
3317
3318     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
3319         /* error string is set in parsetime.c */
3320         return;
3321     }
3322
3323     if (start_tmp < 3600*24*365*10){
3324         rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
3325         return;
3326     }
3327
3328     if (end_tmp < start_tmp) {
3329         rrd_set_error("start (%ld) should be less than end (%ld)",
3330                start_tmp, end_tmp);
3331         return;
3332     }
3333
3334     im->start = start_tmp;
3335     im->end = end_tmp;
3336     im->step = max((long)im->step, (im->end-im->start)/im->xsize);
3337 }
3338
3339 int
3340 rrd_graph_check_vname(image_desc_t *im, char *varname, char *err)
3341 {
3342     if ((im->gdes[im->gdes_c-1].vidx=find_var(im,varname))==-1) {
3343         rrd_set_error("Unknown variable '%s' in %s",varname,err);
3344         return -1;
3345     }
3346     return 0;
3347 }
3348 int
3349 rrd_graph_color(image_desc_t *im, char *var, char *err, int optional)
3350 {
3351     char *color;
3352     graph_desc_t *gdp=&im->gdes[im->gdes_c-1];
3353
3354     color=strstr(var,"#");
3355     if (color==NULL) {
3356         if (optional==0) {
3357             rrd_set_error("Found no color in %s",err);
3358             return 0;
3359         }
3360         return 0;
3361     } else {
3362         int n=0;
3363         char *rest;
3364         gfx_color_t    col;
3365
3366         rest=strstr(color,":");
3367         if (rest!=NULL)
3368             n=rest-color;
3369         else
3370             n=strlen(color);
3371
3372         switch (n) {
3373             case 7:
3374                 sscanf(color,"#%6lx%n",&col,&n);
3375                 col = (col << 8) + 0xff /* shift left by 8 */;
3376                 if (n!=7) rrd_set_error("Color problem in %s",err);
3377                 break;
3378             case 9:
3379                 sscanf(color,"#%8lx%n",&col,&n);
3380                 if (n==9) break;
3381             default:
3382                 rrd_set_error("Color problem in %s",err);
3383         }
3384         if (rrd_test_error()) return 0;
3385         gdp->col = col;
3386         return n;
3387     }
3388 }
3389
3390
3391 int bad_format(char *fmt) {
3392     char *ptr;
3393     int n=0;
3394     ptr = fmt;
3395     while (*ptr != '\0')
3396         if (*ptr++ == '%') {
3397
3398              /* line cannot end with percent char */
3399              if (*ptr == '\0') return 1;
3400
3401              /* '%s', '%S' and '%%' are allowed */
3402              if (*ptr == 's' || *ptr == 'S' || *ptr == '%') ptr++;
3403
3404              /* %c is allowed (but use only with vdef!) */
3405              else if (*ptr == 'c') {
3406                 ptr++;
3407                 n=1;
3408              }
3409
3410              /* or else '% 6.2lf' and such are allowed */
3411              else {
3412                  /* optional padding character */
3413                  if (*ptr == ' ' || *ptr == '+' || *ptr == '-') ptr++;
3414
3415                  /* This should take care of 'm.n' with all three optional */
3416                  while (*ptr >= '0' && *ptr <= '9') ptr++;
3417                  if (*ptr == '.') ptr++;
3418                  while (*ptr >= '0' && *ptr <= '9') ptr++;
3419
3420                  /* Either 'le', 'lf' or 'lg' must follow here */
3421                  if (*ptr++ != 'l') return 1;
3422                  if (*ptr == 'e' || *ptr == 'f' || *ptr == 'g') ptr++;
3423                  else return 1;
3424                  n++;
3425             }
3426          }
3427
3428       return (n!=1);
3429 }
3430
3431
3432 int
3433 vdef_parse(gdes,str)
3434 struct graph_desc_t *gdes;
3435 const char *const str;
3436 {
3437     /* A VDEF currently is either "func" or "param,func"
3438      * so the parsing is rather simple.  Change if needed.
3439      */
3440     double      param;
3441     char        func[30];
3442     int         n;
3443
3444     n=0;
3445     sscanf(str,"%le,%29[A-Z]%n",&param,func,&n);
3446     if (n== (int)strlen(str)) { /* matched */
3447         ;
3448     } else {
3449         n=0;
3450         sscanf(str,"%29[A-Z]%n",func,&n);
3451         if (n== (int)strlen(str)) { /* matched */
3452             param=DNAN;
3453         } else {
3454             rrd_set_error("Unknown function string '%s' in VDEF '%s'"
3455                 ,str
3456                 ,gdes->vname
3457                 );
3458             return -1;
3459         }
3460     }
3461     if          (!strcmp("PERCENT",func)) gdes->vf.op = VDEF_PERCENT;
3462     else if     (!strcmp("MAXIMUM",func)) gdes->vf.op = VDEF_MAXIMUM;
3463     else if     (!strcmp("AVERAGE",func)) gdes->vf.op = VDEF_AVERAGE;
3464     else if     (!strcmp("MINIMUM",func)) gdes->vf.op = VDEF_MINIMUM;
3465     else if     (!strcmp("TOTAL",  func)) gdes->vf.op = VDEF_TOTAL;
3466     else if     (!strcmp("FIRST",  func)) gdes->vf.op = VDEF_FIRST;
3467     else if     (!strcmp("LAST",   func)) gdes->vf.op = VDEF_LAST;
3468     else if     (!strcmp("LSLSLOPE", func)) gdes->vf.op = VDEF_LSLSLOPE;
3469     else if     (!strcmp("LSLINT",   func)) gdes->vf.op = VDEF_LSLINT;
3470     else if     (!strcmp("LSLCORREL",func)) gdes->vf.op = VDEF_LSLCORREL;
3471     else {
3472         rrd_set_error("Unknown function '%s' in VDEF '%s'\n"
3473             ,func
3474             ,gdes->vname
3475             );
3476         return -1;
3477     };
3478
3479     switch (gdes->vf.op) {
3480         case VDEF_PERCENT:
3481             if (isnan(param)) { /* no parameter given */
3482                 rrd_set_error("Function '%s' needs parameter in VDEF '%s'\n"
3483                     ,func
3484                     ,gdes->vname
3485                     );
3486                 return -1;
3487             };
3488             if (param>=0.0 && param<=100.0) {
3489                 gdes->vf.param = param;
3490                 gdes->vf.val   = DNAN;  /* undefined */
3491                 gdes->vf.when  = 0;     /* undefined */
3492             } else {
3493                 rrd_set_error("Parameter '%f' out of range in VDEF '%s'\n"
3494                     ,param
3495                     ,gdes->vname
3496                     );
3497                 return -1;
3498             };
3499             break;
3500         case VDEF_MAXIMUM:
3501         case VDEF_AVERAGE:
3502         case VDEF_MINIMUM:
3503         case VDEF_TOTAL:
3504         case VDEF_FIRST:
3505         case VDEF_LAST:
3506         case VDEF_LSLSLOPE:
3507         case VDEF_LSLINT:
3508         case VDEF_LSLCORREL:
3509             if (isnan(param)) {
3510                 gdes->vf.param = DNAN;
3511                 gdes->vf.val   = DNAN;
3512                 gdes->vf.when  = 0;
3513             } else {
3514                 rrd_set_error("Function '%s' needs no parameter in VDEF '%s'\n"
3515                     ,func
3516                     ,gdes->vname
3517                     );
3518                 return -1;
3519             };
3520             break;
3521     };
3522     return 0;
3523 }
3524
3525
3526 int
3527 vdef_calc(im,gdi)
3528 image_desc_t *im;
3529 int gdi;
3530 {
3531     graph_desc_t        *src,*dst;
3532     rrd_value_t         *data;
3533     long                step,steps;
3534
3535     dst = &im->gdes[gdi];
3536     src = &im->gdes[dst->vidx];
3537     data = src->data + src->ds;
3538     steps = (src->end - src->start) / src->step;
3539
3540 #if 0
3541 printf("DEBUG: start == %lu, end == %lu, %lu steps\n"
3542     ,src->start
3543     ,src->end
3544     ,steps
3545     );
3546 #endif
3547
3548     switch (dst->vf.op) {
3549         case VDEF_PERCENT: {
3550                 rrd_value_t *   array;
3551                 int             field;
3552
3553
3554                 if ((array = malloc(steps*sizeof(double)))==NULL) {
3555                     rrd_set_error("malloc VDEV_PERCENT");
3556                     return -1;
3557                 }
3558                 for (step=0;step < steps; step++) {
3559                     array[step]=data[step*src->ds_cnt];
3560                 }
3561                 qsort(array,step,sizeof(double),vdef_percent_compar);
3562
3563                 field = (steps-1)*dst->vf.param/100;
3564                 dst->vf.val  = array[field];
3565                 dst->vf.when = 0;       /* no time component */
3566                 free(array);
3567 #if 0
3568 for(step=0;step<steps;step++)
3569 printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
3570 #endif
3571             }
3572             break;
3573         case VDEF_MAXIMUM:
3574             step=0;
3575             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3576             if (step == steps) {
3577                 dst->vf.val  = DNAN;
3578                 dst->vf.when = 0;
3579             } else {
3580                 dst->vf.val  = data[step*src->ds_cnt];
3581                 dst->vf.when = src->start + (step+1)*src->step;
3582             }
3583             while (step != steps) {
3584                 if (finite(data[step*src->ds_cnt])) {
3585                     if (data[step*src->ds_cnt] > dst->vf.val) {
3586                         dst->vf.val  = data[step*src->ds_cnt];
3587                         dst->vf.when = src->start + (step+1)*src->step;
3588                     }
3589                 }
3590                 step++;
3591             }
3592             break;
3593         case VDEF_TOTAL:
3594         case VDEF_AVERAGE: {
3595             int cnt=0;
3596             double sum=0.0;
3597             for (step=0;step<steps;step++) {
3598                 if (finite(data[step*src->ds_cnt])) {
3599                     sum += data[step*src->ds_cnt];
3600                     cnt ++;
3601                 };
3602             }
3603             if (cnt) {
3604                 if (dst->vf.op == VDEF_TOTAL) {
3605                     dst->vf.val  = sum*src->step;
3606                     dst->vf.when = cnt*src->step;       /* not really "when" */
3607                 } else {
3608                     dst->vf.val = sum/cnt;
3609                     dst->vf.when = 0;   /* no time component */
3610                 };
3611             } else {
3612                 dst->vf.val  = DNAN;
3613                 dst->vf.when = 0;
3614             }
3615             }
3616             break;
3617         case VDEF_MINIMUM:
3618             step=0;
3619             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3620             if (step == steps) {
3621                 dst->vf.val  = DNAN;
3622                 dst->vf.when = 0;
3623             } else {
3624                 dst->vf.val  = data[step*src->ds_cnt];
3625                 dst->vf.when = src->start + (step+1)*src->step;
3626             }
3627             while (step != steps) {
3628                 if (finite(data[step*src->ds_cnt])) {
3629                     if (data[step*src->ds_cnt] < dst->vf.val) {
3630                         dst->vf.val  = data[step*src->ds_cnt];
3631                         dst->vf.when = src->start + (step+1)*src->step;
3632                     }
3633                 }
3634                 step++;
3635             }
3636             break;
3637         case VDEF_FIRST:
3638             /* The time value returned here is one step before the
3639              * actual time value.  This is the start of the first
3640              * non-NaN interval.
3641              */
3642             step=0;
3643             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3644             if (step == steps) { /* all entries were NaN */
3645                 dst->vf.val  = DNAN;
3646                 dst->vf.when = 0;
3647             } else {
3648                 dst->vf.val  = data[step*src->ds_cnt];
3649                 dst->vf.when = src->start + step*src->step;
3650             }
3651             break;
3652         case VDEF_LAST:
3653             /* The time value returned here is the
3654              * actual time value.  This is the end of the last
3655              * non-NaN interval.
3656              */
3657             step=steps-1;
3658             while (step >= 0 && isnan(data[step*src->ds_cnt])) step--;
3659             if (step < 0) { /* all entries were NaN */
3660                 dst->vf.val  = DNAN;
3661                 dst->vf.when = 0;
3662             } else {
3663                 dst->vf.val  = data[step*src->ds_cnt];
3664                 dst->vf.when = src->start + (step+1)*src->step;
3665             }
3666             break;
3667         case VDEF_LSLSLOPE:
3668         case VDEF_LSLINT:
3669         case VDEF_LSLCORREL:{
3670             /* Bestfit line by linear least squares method */
3671
3672             int cnt=0;
3673             double SUMx, SUMy, SUMxy, SUMxx, SUMyy, slope, y_intercept, correl ;
3674             SUMx = 0; SUMy = 0; SUMxy = 0; SUMxx = 0; SUMyy = 0;
3675
3676             for (step=0;step<steps;step++) {
3677                 if (finite(data[step*src->ds_cnt])) {
3678                     cnt++;
3679                     SUMx  += step;
3680                     SUMxx += step * step;
3681                     SUMxy += step * data[step*src->ds_cnt];
3682                     SUMy  += data[step*src->ds_cnt];
3683                     SUMyy  += data[step*src->ds_cnt]*data[step*src->ds_cnt];
3684                 };
3685             }
3686
3687             slope = ( SUMx*SUMy - cnt*SUMxy ) / ( SUMx*SUMx - cnt*SUMxx );
3688             y_intercept = ( SUMy - slope*SUMx ) / cnt;
3689             correl = (SUMxy - (SUMx*SUMy)/cnt) / sqrt((SUMxx - (SUMx*SUMx)/cnt)*(SUMyy - (SUMy*SUMy)/cnt));
3690
3691             if (cnt) {
3692                     if (dst->vf.op == VDEF_LSLSLOPE) {
3693                         dst->vf.val  = slope;
3694                         dst->vf.when = cnt*src->step;
3695                     } else if (dst->vf.op == VDEF_LSLINT)  {
3696                         dst->vf.val = y_intercept;
3697                         dst->vf.when = cnt*src->step;
3698                     } else if (dst->vf.op == VDEF_LSLCORREL)  {
3699                         dst->vf.val = correl;
3700                         dst->vf.when = cnt*src->step;
3701                     };
3702
3703             } else {
3704                 dst->vf.val  = DNAN;
3705                 dst->vf.when = 0;
3706             }
3707             }
3708             break;
3709     }
3710     return 0;
3711 }
3712
3713 /* NaN < -INF < finite_values < INF */
3714 int
3715 vdef_percent_compar(a,b)
3716 const void *a,*b;
3717 {
3718     /* Equality is not returned; this doesn't hurt except
3719      * (maybe) for a little performance.
3720      */
3721
3722     /* First catch NaN values. They are smallest */
3723     if (isnan( *(double *)a )) return -1;
3724     if (isnan( *(double *)b )) return  1;
3725
3726     /* NaN doesn't reach this part so INF and -INF are extremes.
3727      * The sign from isinf() is compatible with the sign we return
3728      */
3729     if (isinf( *(double *)a )) return isinf( *(double *)a );
3730     if (isinf( *(double *)b )) return isinf( *(double *)b );
3731
3732     /* If we reach this, both values must be finite */
3733     if ( *(double *)a < *(double *)b ) return -1; else return 1;
3734 }