src/rrd_rpncalc.c

   1 /****************************************************************************
   2  * RRDtool 1.0.28  Copyright Tobias Oetiker, 1997 - 2002
   3  ****************************************************************************
   4  * rrd_rpncalc.c  RPN calculator functions
   5  ****************************************************************************/
   6
   7 #include "rrd_tool.h"
   8 #include "rrd_rpncalc.h"
   9 #include <limits.h>
  10
  11 short addop2str(enum op_en op, enum op_en op_type, char *op_str,
  12             char **result_str, unsigned short *offset);
  13 int tzoffset(time_t); /* used to implement LTIME */
  14
  15 short rpn_compact(rpnp_t *rpnp, rpn_cdefds_t **rpnc, short *count)
  16 {
  17     short i;
  18     *count = 0;
  19     /* count the number of rpn nodes */
  20     while(rpnp[*count].op != OP_END) (*count)++;
  21     if (++(*count) > DS_CDEF_MAX_RPN_NODES) {
  22         rrd_set_error("Maximum %d RPN nodes permitted",
  23                       DS_CDEF_MAX_RPN_NODES);
  24         return -1;
  25     }
  26
  27     /* allocate memory */
  28     *rpnc = (rpn_cdefds_t *) calloc(*count,sizeof(rpn_cdefds_t));
  29     for (i = 0; rpnp[i].op != OP_END; i++)
  30     {
  31         (*rpnc)[i].op = (char) rpnp[i].op;
  32         if (rpnp[i].op == OP_NUMBER) {
  33             /* rpnp.val is a double, rpnc.val is a short */
  34             double temp = floor(rpnp[i].val);
  35             if (temp < SHRT_MIN || temp > SHRT_MAX) {
  36                 rrd_set_error(
  37                     "constants must be integers in the interval (%d, %d)",
  38                     SHRT_MIN, SHRT_MAX);
  39                 free(*rpnc);
  40                 return -1;
  41             }
  42             (*rpnc)[i].val = (short) temp;
  43         } else if (rpnp[i].op == OP_VARIABLE) {
  44             (*rpnc)[i].val = (short) rpnp[i].ptr;
  45         }
  46     }
  47     /* terminate the sequence */
  48     (*rpnc)[(*count) - 1].op = OP_END;
  49     return 0;
  50 }
  51
  52 rpnp_t * rpn_expand(rpn_cdefds_t *rpnc)
  53 {
  54     short i;
  55     rpnp_t *rpnp;
  56
  57     /* DS_CDEF_MAX_RPN_NODES is small, so at the expense of some wasted
  58      * memory we avoid any reallocs */
  59     rpnp = (rpnp_t *) calloc(DS_CDEF_MAX_RPN_NODES,sizeof(rpnp_t));
  60     if (rpnp == NULL) return NULL;
  61     for (i = 0; rpnc[i].op != OP_END; ++i)
  62     {
  63         rpnp[i].op = (long) rpnc[i].op;
  64         if (rpnp[i].op == OP_NUMBER) {
  65             rpnp[i].val = (double) rpnc[i].val;
  66         } else if (rpnp[i].op == OP_VARIABLE) {
  67             rpnp[i].ptr = (long) rpnc[i].val;
  68         }
  69     }
  70     /* terminate the sequence */
  71     rpnp[i].op = OP_END;
  72     return rpnp;
  73 }
  74
  75 /* rpn_compact2str: convert a compact sequence of RPN operator nodes back
  76  * into a CDEF string. This function is used by rrd_dump.
  77  * arguments:
  78  *  rpnc: an array of compact RPN operator nodes
  79  *  ds_def: a pointer to the data source definition section of an RRD header
  80  *   for lookup of data source names by index
  81  *  str: out string, memory is allocated by the function, must be freed by the
  82  *   the caller */
  83 void rpn_compact2str(rpn_cdefds_t *rpnc,ds_def_t *ds_def,char **str)
  84 {
  85     unsigned short i,offset = 0;
  86     char buffer[7]; /* short as a string */
  87
  88     for (i = 0; rpnc[i].op != OP_END; i++)
  89     {
  90         if (i > 0) (*str)[offset++] = ',';
  91
  92 #define add_op(VV,VVV) \
  93           if (addop2str(rpnc[i].op, VV, VVV, str, &offset) == 1) continue;
  94
  95         if (rpnc[i].op == OP_NUMBER) {
  96             /* convert a short into a string */
  97 #ifdef WIN32
  98             _itoa(rpnc[i].val,buffer,10);
  99 #else
 100             sprintf(buffer,"%d",rpnc[i].val);
 101 #endif
 102             add_op(OP_NUMBER,buffer)
 103                 }
 104
 105         if (rpnc[i].op == OP_VARIABLE) {
 106             char *ds_name = ds_def[rpnc[i].val].ds_nam;
 107             add_op(OP_VARIABLE, ds_name)
 108                 }
 109 #undef add_op
 110
 111 #define add_op(VV,VVV) \
 112           if (addop2str(rpnc[i].op, VV, #VVV, str, &offset) == 1) continue;
 113
 114           add_op(OP_ADD,+)
 115           add_op(OP_SUB,-)
 116           add_op(OP_MUL,*)
 117           add_op(OP_DIV,/)
 118           add_op(OP_MOD,%)
 119           add_op(OP_SIN,SIN)
 120           add_op(OP_COS,COS)
 121           add_op(OP_LOG,LOG)
 122           add_op(OP_FLOOR,FLOOR)
 123           add_op(OP_CEIL,CEIL)
 124           add_op(OP_EXP,EXP)
 125           add_op(OP_DUP,DUP)
 126           add_op(OP_EXC,EXC)
 127           add_op(OP_POP,POP)
 128           add_op(OP_LT,LT)
 129           add_op(OP_LE,LE)
 130           add_op(OP_GT,GT)
 131           add_op(OP_GE,GE)
 132           add_op(OP_EQ,EQ)
 133           add_op(OP_IF,IF)
 134           add_op(OP_MIN,MIN)
 135           add_op(OP_MAX,MAX)
 136           add_op(OP_LIMIT,LIMIT)
 137           add_op(OP_UNKN,UNKN)
 138           add_op(OP_UN,UN)
 139           add_op(OP_NEGINF,NEGINF)
 140           add_op(OP_NE,NE)
 141           add_op(OP_PREV,PREV)
 142           add_op(OP_INF,INF)
 143           add_op(OP_ISINF,ISINF)
 144           add_op(OP_NOW,NOW)
 145           add_op(OP_LTIME,LTIME)
 146           add_op(OP_TIME,TIME)
 147
 148 #undef add_op
 149               }
 150     (*str)[offset] = '\0';
 151
 152 }
 153
 154 short addop2str(enum op_en op, enum op_en op_type, char *op_str,
 155                 char **result_str, unsigned short *offset)
 156 {
 157     if (op == op_type) {
 158         short op_len;
 159         op_len = strlen(op_str);
 160         *result_str =  (char *) rrd_realloc(*result_str,
 161                                             (op_len + 1 + *offset)*sizeof(char));
 162         if (*result_str == NULL) {
 163             rrd_set_error("failed to alloc memory in addop2str");
 164             return -1;
 165         }
 166         strncpy(&((*result_str)[*offset]),op_str,op_len);
 167         *offset += op_len;
 168         return 1;
 169     }
 170     return 0;
 171 }
 172
 173 void parseCDEF_DS(char *def,rrd_t *rrd, int ds_idx)
 174 {
 175     rpnp_t *rpnp = NULL;
 176     rpn_cdefds_t *rpnc = NULL;
 177     short count, i;
 178
 179     rpnp = rpn_parse((void*) rrd, def, &lookup_DS);
 180     if (rpnp == NULL) {
 181         rrd_set_error("failed to parse computed data source %s", def);
 182         return;
 183     }
 184     /* Check for OP nodes not permitted in COMPUTE DS.
 185      * Moved this check from within rpn_compact() because it really is
 186      * COMPUTE DS specific. This is less efficient, but creation doesn't
 187      * occur too often. */
 188     for (i = 0; rpnp[i].op != OP_END; i++) {
 189         if (rpnp[i].op == OP_TIME || rpnp[i].op == OP_LTIME ||
 190             rpnp[i].op == OP_PREV)
 191         {
 192             rrd_set_error(
 193                 "operators time, ltime and prev not supported with DS COMPUTE");
 194             free(rpnp);
 195             return;
 196         }
 197     }
 198     if (rpn_compact(rpnp,&rpnc,&count) == -1) {
 199         free(rpnp);
 200         return;
 201     }
 202     /* copy the compact rpn representation over the ds_def par array */
 203     memcpy((void*) &(rrd -> ds_def[ds_idx].par[DS_cdef]),
 204            (void*) rpnc, count*sizeof(rpn_cdefds_t));
 205     free(rpnp);
 206     free(rpnc);
 207 }
 208
 209 /* lookup a data source name in the rrd struct and return the index,
 210  * should use ds_match() here except:
 211  * (1) need a void * pointer to the rrd
 212  * (2) error handling is left to the caller
 213  */
 214 long lookup_DS(void *rrd_vptr,char *ds_name)
 215 {
 216     int i;
 217     rrd_t *rrd;
 218
 219     rrd = (rrd_t *) rrd_vptr;
 220
 221     for (i = 0; i < rrd -> stat_head -> ds_cnt; ++i)
 222     {
 223         if(strcmp(ds_name,rrd -> ds_def[i].ds_nam) == 0)
 224             return i;
 225     }
 226     /* the caller handles a bad data source name in the rpn string */
 227     return -1;
 228 }
 229
 230 /* rpn_parse : parse a string and generate a rpnp array; modified
 231  * str2rpn() originally included in rrd_graph.c
 232  * arguments:
 233  * key_hash: a transparent argument passed to lookup(); conceptually this
 234  *    is a hash object for lookup of a numeric key given a variable name
 235  * expr: the string RPN expression, including variable names
 236  * lookup(): a function that retrieves a numeric key given a variable name
 237  */
 238 rpnp_t *
 239 rpn_parse(void *key_hash,char *expr,long (*lookup)(void *,char*)){
 240     int pos=0;
 241     long steps=-1;
 242     rpnp_t  *rpnp;
 243     char vname[30];
 244
 245     rpnp=NULL;
 246
 247     while(*expr){
 248         if ((rpnp = (rpnp_t *) rrd_realloc(rpnp, (++steps + 2)*
 249                                        sizeof(rpnp_t)))==NULL){
 250             return NULL;
 251         }
 252
 253         else if((sscanf(expr,"%lf%n",&rpnp[steps].val,&pos) == 1) && (expr[pos] == ',')){
 254             rpnp[steps].op = OP_NUMBER;
 255             expr+=pos;
 256         }
 257
 258 #define match_op(VV,VVV) \
 259         else if (strncmp(expr, #VVV, strlen(#VVV))==0){ \
 260             rpnp[steps].op = VV; \
 261             expr+=strlen(#VVV); \
 262         }
 263
 264         match_op(OP_ADD,+)
 265         match_op(OP_SUB,-)
 266         match_op(OP_MUL,*)
 267         match_op(OP_DIV,/)
 268         match_op(OP_MOD,%)
 269         match_op(OP_SIN,SIN)
 270         match_op(OP_COS,COS)
 271         match_op(OP_LOG,LOG)
 272         match_op(OP_FLOOR,FLOOR)
 273         match_op(OP_CEIL,CEIL)
 274         match_op(OP_EXP,EXP)
 275         match_op(OP_DUP,DUP)
 276         match_op(OP_EXC,EXC)
 277         match_op(OP_POP,POP)
 278         match_op(OP_LT,LT)
 279         match_op(OP_LE,LE)
 280         match_op(OP_GT,GT)
 281         match_op(OP_GE,GE)
 282         match_op(OP_EQ,EQ)
 283         match_op(OP_IF,IF)
 284         match_op(OP_MIN,MIN)
 285         match_op(OP_MAX,MAX)
 286         match_op(OP_LIMIT,LIMIT)
 287           /* order is important here ! .. match longest first */
 288         match_op(OP_UNKN,UNKN)
 289         match_op(OP_UN,UN)
 290         match_op(OP_NEGINF,NEGINF)
 291         match_op(OP_NE,NE)
 292         match_op(OP_PREV,PREV)
 293         match_op(OP_INF,INF)
 294         match_op(OP_ISINF,ISINF)
 295         match_op(OP_NOW,NOW)
 296         match_op(OP_LTIME,LTIME)
 297         match_op(OP_TIME,TIME)
 298
 299 #undef match_op
 300
 301
 302             else if ((sscanf(expr,"%29[_A-Za-z0-9]%n",
 303                              vname,&pos) == 1)
 304                      && ((rpnp[steps].ptr = (*lookup)(key_hash,vname)) != -1)){
 305                 rpnp[steps].op = OP_VARIABLE;
 306                 expr+=pos;
 307             }
 308
 309         else {
 310             free(rpnp);
 311             return NULL;
 312         }
 313         if (*expr == 0)
 314             break;
 315         if (*expr == ',')
 316             expr++;
 317         else {
 318             free(rpnp);
 319             return NULL;
 320         }
 321     }
 322     rpnp[steps+1].op = OP_END;
 323     return rpnp;
 324 }
 325
 326 void
 327 rpnstack_init(rpnstack_t *rpnstack)
 328 {
 329     rpnstack -> s = NULL;
 330     rpnstack -> dc_stacksize = 0;
 331     rpnstack -> dc_stackblock = 100;
 332 }
 333
 334 void
 335 rpnstack_free(rpnstack_t *rpnstack)
 336 {
 337    if (rpnstack -> s != NULL)
 338           free(rpnstack -> s);
 339    rpnstack -> dc_stacksize = 0;
 340 }
 341
 342 /* rpn_calc: run the RPN calculator; also performs variable substitution;
 343  * moved and modified from data_calc() originally included in rrd_graph.c
 344  * arguments:
 345  * rpnp : an array of RPN operators (including variable references)
 346  * rpnstack : the initialized stack
 347  * data_idx : when data_idx is a multiple of rpnp.step, the rpnp.data pointer
 348  *   is advanced by rpnp.ds_cnt; used only for variable substitution
 349  * output : an array of output values; OP_PREV assumes this array contains
 350  *   the "previous" value at index position output_idx-1; the definition of
 351  *   "previous" depends on the calling environment
 352  * output_idx : an index into the output array in which to store the output
 353  *   of the RPN calculator
 354  * returns: -1 if the computation failed (also calls rrd_set_error)
 355  *           0 on success
 356  */
 357 short
 358 rpn_calc(rpnp_t *rpnp, rpnstack_t *rpnstack, long data_idx,
 359                 rrd_value_t *output, int output_idx)
 360 {
 361     int rpi;
 362     long stptr = -1;
 363
 364     /* process each op from the rpn in turn */
 365     for (rpi=0; rpnp[rpi].op != OP_END; rpi++){
 366         /* allocate or grow the stack */
 367         if (stptr + 5 > rpnstack -> dc_stacksize){
 368             /* could move this to a separate function */
 369             rpnstack -> dc_stacksize += rpnstack -> dc_stackblock;
 370             rpnstack -> s = rrd_realloc(rpnstack -> s,
 371                         (rpnstack -> dc_stacksize)*sizeof(*(rpnstack -> s)));
 372             if (rpnstack -> s == NULL){
 373                 rrd_set_error("RPN stack overflow");
 374                 return -1;
 375             }
 376         }
 377         switch (rpnp[rpi].op){
 378             case OP_NUMBER:
 379                 rpnstack -> s[++stptr] = rpnp[rpi].val;
 380                 break;
 381             case OP_VARIABLE:
 382                 /* Sanity check: VDEFs shouldn't make it here */
 383                 if (rpnp[rpi].ds_cnt == 0) {
 384                     rrd_set_error("VDEF made it into rpn_calc... aborting");
 385                     return -1;
 386                 } else {
 387                     /* make sure we pull the correct value from
 388                      * the *.data array. Adjust the pointer into
 389                      * the array acordingly. Advance the ptr one
 390                      * row in the rra (skip over non-relevant
 391                      * data sources)
 392                      */
 393                     if (data_idx % rpnp[rpi].step == 0){
 394                         rpnp[rpi].data += rpnp[rpi].ds_cnt;
 395                     }
 396                     rpnstack -> s[++stptr] =  *(rpnp[rpi].data);
 397                 }
 398                 break;
 399             case OP_PREV:
 400                 if ((output_idx-1) <= 0) {
 401                     rpnstack -> s[++stptr] = DNAN;
 402                 } else {
 403                     rpnstack -> s[++stptr] = output[output_idx-1];
 404                 }
 405                 break;
 406        case OP_UNKN:
 407            rpnstack -> s[++stptr] = DNAN;
 408            break;
 409        case OP_INF:
 410            rpnstack -> s[++stptr] = DINF;
 411            break;
 412        case OP_NEGINF:
 413            rpnstack -> s[++stptr] = -DINF;
 414            break;
 415        case OP_NOW:
 416            rpnstack -> s[++stptr] = (double)time(NULL);
 417            break;
 418        case OP_TIME:
 419            /* HACK: this relies on the data_idx being the time,
 420             * which the within-function scope is unaware of */
 421            rpnstack -> s[++stptr] = (double) data_idx;
 422            break;
 423        case OP_LTIME:
 424            rpnstack -> s[++stptr] = (double) tzoffset(data_idx) + (double)data_idx;
 425            break;
 426        case OP_ADD:
 427            if(stptr<1){
 428                rrd_set_error("RPN stack underflow");
 429                return -1;
 430            }
 431            rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1]
 432                + rpnstack -> s[stptr];
 433            stptr--;
 434            break;
 435        case OP_SUB:
 436            if(stptr<1){
 437                rrd_set_error("RPN stack underflow");
 438                return -1;
 439            }
 440            rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] - rpnstack -> s[stptr];
 441            stptr--;
 442            break;
 443        case OP_MUL:
 444            if(stptr<1){
 445                rrd_set_error("RPN stack underflow");
 446                return -1;
 447            }
 448            rpnstack -> s[stptr-1] = (rpnstack -> s[stptr-1]) * (rpnstack -> s[stptr]);
 449            stptr--;
 450            break;
 451        case OP_DIV:
 452            if(stptr<1){
 453                rrd_set_error("RPN stack underflow");
 454                return -1;
 455            }
 456            rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] / rpnstack -> s[stptr];
 457            stptr--;
 458            break;
 459        case OP_MOD:
 460            if(stptr<1){
 461                rrd_set_error("RPN stack underflow");
 462                return -1;
 463            }
 464            rpnstack -> s[stptr-1] = fmod(rpnstack -> s[stptr-1],rpnstack -> s[stptr]);
 465            stptr--;
 466            break;
 467        case OP_SIN:
 468            if(stptr<0){
 469                rrd_set_error("RPN stack underflow");
 470                return -1;
 471            }
 472            rpnstack -> s[stptr] = sin(rpnstack -> s[stptr]);
 473            break;
 474        case OP_COS:
 475            if(stptr<0){
 476                rrd_set_error("RPN stack underflow");
 477                return -1;
 478            }
 479            rpnstack -> s[stptr] = cos(rpnstack -> s[stptr]);
 480            break;
 481        case OP_CEIL:
 482            if(stptr<0){
 483                rrd_set_error("RPN stack underflow");
 484                return -1;
 485            }
 486            rpnstack -> s[stptr] = ceil(rpnstack -> s[stptr]);
 487            break;
 488        case OP_FLOOR:
 489            if(stptr<0){
 490                rrd_set_error("RPN stack underflow");
 491                return -1;
 492            }
 493            rpnstack -> s[stptr] = floor(rpnstack -> s[stptr]);
 494            break;
 495        case OP_LOG:
 496            if(stptr<0){
 497                rrd_set_error("RPN stack underflow");
 498                return -1;
 499            }
 500            rpnstack -> s[stptr] = log(rpnstack -> s[stptr]);
 501            break;
 502        case OP_DUP:
 503            if(stptr<0){
 504                rrd_set_error("RPN stack underflow");
 505                return -1;
 506            }
 507            rpnstack -> s[stptr+1] = rpnstack -> s[stptr];
 508            stptr++;
 509            break;
 510        case OP_POP:
 511            if(stptr<0){
 512                rrd_set_error("RPN stack underflow");
 513                return -1;
 514            }
 515            stptr--;
 516            break;
 517        case OP_EXC:
 518            if(stptr<1){
 519                rrd_set_error("RPN stack underflow");
 520                return -1;
 521            } else {
 522                double dummy;
 523                dummy = rpnstack -> s[stptr] ;
 524                rpnstack -> s[stptr] = rpnstack -> s[stptr-1];
 525                rpnstack -> s[stptr-1] = dummy;
 526            }
 527            break;
 528        case OP_EXP:
 529            if(stptr<0){
 530                rrd_set_error("RPN stack underflow");
 531                return -1;
 532            }
 533            rpnstack -> s[stptr] = exp(rpnstack -> s[stptr]);
 534            break;
 535        case OP_LT:
 536            if(stptr<1){
 537                rrd_set_error("RPN stack underflow");
 538                return -1;
 539            }
 540            if (isnan(rpnstack -> s[stptr-1]))
 541                ;
 542            else if (isnan(rpnstack -> s[stptr]))
 543                rpnstack -> s[stptr-1] = rpnstack -> s[stptr];
 544            else
 545                rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] < rpnstack -> s[stptr] ? 1.0 : 0.0;
 546            stptr--;
 547            break;
 548        case OP_LE:
 549            if(stptr<1){
 550                rrd_set_error("RPN stack underflow");
 551                return -1;
 552            }
 553            if (isnan(rpnstack -> s[stptr-1]))
 554                ;
 555            else if (isnan(rpnstack -> s[stptr]))
 556                rpnstack -> s[stptr-1] = rpnstack -> s[stptr];
 557            else
 558                rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] <= rpnstack -> s[stptr] ? 1.0 : 0.0;
 559            stptr--;
 560            break;
 561        case OP_GT:
 562            if(stptr<1){
 563                rrd_set_error("RPN stack underflow");
 564                return -1;
 565            }
 566            if (isnan(rpnstack -> s[stptr-1]))
 567                ;
 568            else if (isnan(rpnstack -> s[stptr]))
 569                rpnstack -> s[stptr-1] = rpnstack -> s[stptr];
 570            else
 571                rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] > rpnstack -> s[stptr] ? 1.0 : 0.0;
 572            stptr--;
 573            break;
 574        case OP_GE:
 575            if(stptr<1){
 576                rrd_set_error("RPN stack underflow");
 577                return -1;
 578            }
 579            if (isnan(rpnstack -> s[stptr-1]))
 580                ;
 581            else if (isnan(rpnstack -> s[stptr]))
 582                rpnstack -> s[stptr-1] = rpnstack -> s[stptr];
 583            else
 584                rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] >= rpnstack -> s[stptr] ? 1.0 : 0.0;
 585            stptr--;
 586            break;
 587         case OP_NE:
 588             if(stptr<1){
 589                 rrd_set_error("RPN stack underflow");
 590                 return -1;
 591             }
 592             if (isnan(rpnstack -> s[stptr-1]))
 593                 ;
 594             else if (isnan(rpnstack -> s[stptr]))
 595                 rpnstack -> s[stptr-1] = rpnstack -> s[stptr];
 596             else
 597                 rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] == rpnstack -> s[stptr] ? 0.0 : 1.0;
 598             stptr--;
 599             break;
 600        case OP_EQ:
 601            if(stptr<1){
 602                rrd_set_error("RPN stack underflow");
 603                return -1;
 604            }
 605            if (isnan(rpnstack -> s[stptr-1]))
 606                ;
 607            else if (isnan(rpnstack -> s[stptr]))
 608                rpnstack -> s[stptr-1] = rpnstack -> s[stptr];
 609            else
 610                rpnstack -> s[stptr-1] = rpnstack -> s[stptr-1] == rpnstack -> s[stptr] ? 1.0 : 0.0;
 611            stptr--;
 612            break;
 613        case OP_IF:
 614            if(stptr<2){
 615                rrd_set_error("RPN stack underflow");
 616                return -1;
 617            }
 618            rpnstack->s[stptr-2] = rpnstack->s[stptr-2] != 0.0 ? rpnstack->s[stptr-1] : rpnstack->s[stptr];
 619            stptr--;
 620            stptr--;
 621            break;
 622        case OP_MIN:
 623            if(stptr<1){
 624                rrd_set_error("RPN stack underflow");
 625                return -1;
 626            }
 627            if (isnan(rpnstack->s[stptr-1]))
 628                ;
 629            else if (isnan(rpnstack->s[stptr]))
 630                rpnstack->s[stptr-1] = rpnstack->s[stptr];
 631            else if (rpnstack->s[stptr-1] > rpnstack->s[stptr])
 632                rpnstack->s[stptr-1] = rpnstack->s[stptr];
 633            stptr--;
 634            break;
 635        case OP_MAX:
 636            if(stptr<1){
 637                rrd_set_error("RPN stack underflow");
 638                return -1;
 639            }
 640            if (isnan(rpnstack->s[stptr-1]))
 641                ;
 642            else if (isnan(rpnstack->s[stptr]))
 643                rpnstack->s[stptr-1] = rpnstack->s[stptr];
 644            else if (rpnstack->s[stptr-1] < rpnstack->s[stptr])
 645                rpnstack->s[stptr-1] = rpnstack->s[stptr];
 646            stptr--;
 647            break;
 648        case OP_LIMIT:
 649            if(stptr<2){
 650                rrd_set_error("RPN stack underflow");
 651                free(rpnstack->s);
 652                return -1;
 653            }
 654            if (isnan(rpnstack->s[stptr-2]))
 655                ;
 656            else if (isnan(rpnstack->s[stptr-1]))
 657                rpnstack->s[stptr-2] = rpnstack->s[stptr-1];
 658            else if (isnan(rpnstack->s[stptr]))
 659                rpnstack->s[stptr-2] = rpnstack->s[stptr];
 660            else if (rpnstack->s[stptr-2] < rpnstack->s[stptr-1])
 661                rpnstack->s[stptr-2] = DNAN;
 662            else if (rpnstack->s[stptr-2] > rpnstack->s[stptr])
 663                rpnstack->s[stptr-2] = DNAN;
 664            stptr-=2;
 665            break;
 666        case OP_UN:
 667            if(stptr<0){
 668                rrd_set_error("RPN stack underflow");
 669                return -1;
 670            }
 671            rpnstack->s[stptr] = isnan(rpnstack->s[stptr]) ? 1.0 : 0.0;
 672            break;
 673         case OP_ISINF:
 674             if(stptr<0){
 675                 rrd_set_error("RPN stack underflow");
 676                 return -1;
 677             }
 678             rpnstack->s[stptr] = isinf(rpnstack->s[stptr]) ? 1.0 : 0.0;
 679             break;
 680        case OP_END:
 681             break;
 682        }
 683    }
 684    if(stptr!=0){
 685        rrd_set_error("RPN final stack size != 1");
 686        return -1;
 687    }
 688
 689    output[output_idx] = rpnstack->s[0];
 690    return 0;
 691 }
 692
 693 /* figure out what the local timezone offset for any point in
 694    time was. Return it in seconds */
 695 int
 696 tzoffset( time_t now ){
 697     int gm_sec, gm_min, gm_hour, gm_yday, gm_year,
 698         l_sec, l_min, l_hour, l_yday, l_year;
 699     struct tm *t;
 700     int off;
 701     t = gmtime(&now);
 702     gm_sec = t->tm_sec;
 703     gm_min = t->tm_min;
 704     gm_hour = t->tm_hour;
 705     gm_yday = t->tm_yday;
 706     gm_year = t->tm_year;
 707     t = localtime(&now);
 708     l_sec = t->tm_sec;
 709     l_min = t->tm_min;
 710     l_hour = t->tm_hour;
 711     l_yday = t->tm_yday;
 712     l_year = t->tm_year;
 713     off = (l_sec-gm_sec)+(l_min-gm_min)*60+(l_hour-gm_hour)*3600;
 714     if ( l_yday > gm_yday || l_year > gm_year){
 715         off += 24*3600;
 716     } else if ( l_yday < gm_yday || l_year < gm_year){
 717         off -= 24*3600;
 718     }
 719    return off;
 720 }
 721