src/rrd_graph_helper.c

   1 /****************************************************************************
   2  * RRDtool 1.2.2  Copyright by Tobi Oetiker, 1997-2005
   3  ****************************************************************************
   4  * rrd_graph_helper.c  commandline parser functions
   5  *                     this code initially written by Alex van den Bogaerdt
   6  ****************************************************************************/
   7
   8 #include "rrd_graph.h"
   9
  10 #define dprintf if (gdp->debug) printf
  11
  12 /* Define prototypes for the parsing methods.
  13   Inputs:
  14    char *line         - pointer to base of input source
  15    unsigned int eaten - index to next input character (INPUT/OUTPUT)
  16    graph_desc_t *gdp  - pointer to a graph description
  17    image_desc_t *im   - pointer to an image description
  18 */
  19
  20 int rrd_parse_find_gf (char *, unsigned int *, graph_desc_t *);
  21 int rrd_parse_legend  (char *, unsigned int *, graph_desc_t *);
  22 int rrd_parse_color   (char *, graph_desc_t *);
  23 int rrd_parse_CF      (char *, unsigned int *, graph_desc_t *, enum cf_en *);
  24 int rrd_parse_print   (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  25 int rrd_parse_shift   (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  26 int rrd_parse_xport   (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  27 int rrd_parse_PVHLAST (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  28 int rrd_parse_vname   (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  29 int rrd_parse_def     (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  30 int rrd_parse_vdef    (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  31 int rrd_parse_cdef    (char *, unsigned int *, graph_desc_t *, image_desc_t *);
  32
  33
  34
  35 int
  36 rrd_parse_find_gf(char *line, unsigned int *eaten, graph_desc_t *gdp) {
  37     char funcname[11],c1=0;
  38     int i=0;
  39
  40     /* start an argument with DEBUG to be able to see how it is parsed */
  41     sscanf(&line[*eaten], "DEBUG%n", &i);
  42     if (i) {
  43         gdp->debug=1;
  44         (*eaten)+=i;
  45         i=0;
  46         dprintf("Scanning line '%s'\n",&line[*eaten]);
  47     }
  48     sscanf(&line[*eaten], "%10[A-Z]%n%c", funcname, &i, &c1);
  49     if (!i) {
  50         rrd_set_error("Could not make sense out of '%s'",line);
  51         return 1;
  52     }
  53     if ((int)(gdp->gf=gf_conv(funcname)) == -1) {
  54         rrd_set_error("'%s' is not a valid function name", funcname);
  55         return 1;
  56     } else {
  57         dprintf("- found function name '%s'\n",funcname);
  58     }
  59
  60     if (gdp->gf == GF_LINE) {
  61         if (c1 == ':') {
  62             gdp->linewidth=1;
  63             dprintf("- - using default width of 1\n");
  64         } else {
  65             double width;
  66             (*eaten)+=i;
  67             if (sscanf(&line[*eaten],"%lf%n:",&width,&i)) {
  68                 if (width < 0 || isnan(width) || isinf(width) ) {
  69                     rrd_set_error("LINE width is %lf. It must be finite and >= 0 though",width);
  70                     return 1;
  71                 }
  72                 gdp->linewidth=width;
  73                 dprintf("- - using width %f\n",width);
  74             } else {
  75                 rrd_set_error("LINE width: %s",line);
  76                 return 1;
  77             }
  78         }
  79     } else {
  80         if (c1 != ':') {
  81             rrd_set_error("Malformed %s command: %s",funcname,line);
  82             return 1;
  83         }
  84     }
  85     (*eaten)+=++i;
  86     return 0;
  87 }
  88
  89 int
  90 rrd_parse_legend(char *line, unsigned int *eaten, graph_desc_t *gdp) {
  91     int i;
  92
  93     if (line[*eaten]=='\0' || line[*eaten]==':') {
  94         dprintf("- no (or: empty) legend found\n");
  95         return 0;
  96     }
  97
  98     i=scan_for_col(&line[*eaten],FMT_LEG_LEN,gdp->legend);
  99
 100     (*eaten)+=i;
 101
 102     if (line[*eaten]!='\0' && line[*eaten]!=':') {
 103         rrd_set_error("Legend too long");
 104         return 1;
 105     } else {
 106         return 0;
 107     }
 108 }
 109
 110 int
 111 rrd_parse_color(char *string, graph_desc_t *gdp) {
 112     unsigned int r=0,g=0,b=0,a=0,i;
 113
 114     /* matches the following formats:
 115     ** RGB
 116     ** RGBA
 117     ** RRGGBB
 118     ** RRGGBBAA
 119     */
 120
 121     i=0;
 122     while (string[i] && isxdigit(string[i])) i++;
 123     if (string[i] != '\0') return 1; /* garbage follows hexdigits */
 124     switch (i) {
 125         case 3:
 126         case 4:
 127             sscanf(string, "%1x%1x%1x%1x",&r,&g,&b,&a);
 128             r *= 0x11;
 129             g *= 0x11;
 130             b *= 0x11;
 131             a *= 0x11;
 132             if (i==3) a=0xFF;
 133             break;
 134         case 6:
 135         case 8:
 136             sscanf(string, "%02x%02x%02x%02x",&r,&g,&b,&a);
 137             if (i==6) a=0xFF;
 138             break;
 139         default:
 140             return 1;   /* wrong number of digits */
 141     }
 142     gdp->col = r<<24|g<<16|b<<8|a;
 143     return 0;
 144 }
 145
 146 int
 147 rrd_parse_CF(char *line, unsigned int *eaten, graph_desc_t *gdp, enum cf_en *cf) {
 148     char                symname[CF_NAM_SIZE];
 149     int                 i=0;
 150
 151     sscanf(&line[*eaten], CF_NAM_FMT "%n", symname,&i);
 152     if ((!i)||((line[(*eaten)+i]!='\0')&&(line[(*eaten)+i]!=':'))) {
 153         rrd_set_error("Cannot parse CF in '%s'",line);
 154         return 1;
 155     }
 156     (*eaten)+=i;
 157     dprintf("- using CF '%s'\n",symname);
 158
 159     if ((int)(*cf = cf_conv(symname))==-1) {
 160         rrd_set_error("Unknown CF '%s' in '%s'",symname,line);
 161         return 1;
 162     }
 163
 164     if (line[*eaten]!='\0') (*eaten)++;
 165     return 0;
 166 }
 167
 168 /* Parsing old-style xPRINT and new-style xPRINT */
 169 int
 170 rrd_parse_print(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 171     /* vname:CF:format in case of DEF-based vname
 172     ** vname:CF:format in case of CDEF-based vname
 173     ** vname:format in case of VDEF-based vname
 174     */
 175     char tmpstr[MAX_VNAME_LEN+1];
 176     int i=0;
 177
 178     sscanf(&line[*eaten], DEF_NAM_FMT ":%n", tmpstr,&i);
 179     if (!i) {
 180         rrd_set_error("Could not parse line '%s'",line);
 181         return 1;
 182     }
 183     (*eaten)+=i;
 184     dprintf("- Found candidate vname '%s'\n",tmpstr);
 185
 186     if ((gdp->vidx=find_var(im,tmpstr))<0) {
 187         rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 188         return 1;
 189     }
 190     switch (im->gdes[gdp->vidx].gf) {
 191         case GF_DEF:
 192         case GF_CDEF:
 193             dprintf("- vname is of type DEF or CDEF, looking for CF\n");
 194             if (rrd_parse_CF(line,eaten,gdp,&gdp->cf)) return 1;
 195             break;
 196         case GF_VDEF:
 197             dprintf("- vname is of type VDEF\n");
 198             break;
 199         default:
 200             rrd_set_error("Encountered unknown type variable '%s'",tmpstr);
 201             return 1;
 202     }
 203
 204     if (rrd_parse_legend(line,eaten,gdp)) return 1;
 205     /* for *PRINT the legend itself gets rendered later. We only
 206        get the format at this juncture */
 207     strcpy(gdp->format,gdp->legend);
 208     gdp->legend[0]='\0';
 209     return 0;
 210 }
 211
 212 int
 213 rrd_parse_shift(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 214         char    *l = strdup(line + *eaten), *p;
 215         int     rc = 1;
 216
 217         p = strchr(l, ':');
 218         if (p == NULL) {
 219                 rrd_set_error("Invalid SHIFT syntax");
 220                 goto out;
 221         }
 222         *p++ = '\0';
 223
 224         if ((gdp->vidx=find_var(im,l))<0) {
 225                 rrd_set_error("Not a valid vname: %s in line %s",l,line);
 226                 goto out;
 227         }
 228
 229         /* constant will parse; otherwise, must be VDEF reference */
 230         if (sscanf(p, "%ld", &gdp->shval) != 1) {
 231                 graph_desc_t    *vdp;
 232
 233                 if ((gdp->shidx=find_var(im, p))<0) {
 234                         rrd_set_error("invalid offset vname: %s", p);
 235                         goto out;
 236                 }
 237
 238                 vdp = &im->gdes[gdp->shidx];
 239                 if (vdp->gf != GF_VDEF) {
 240                         rrd_set_error("offset must specify value or VDEF");
 241                         goto out;
 242                 }
 243         } else {
 244                 gdp->shidx = -1;
 245         }
 246
 247         *eaten = strlen(line);
 248         rc = 0;
 249
 250  out:
 251         free(l);
 252         return rc;
 253 }
 254
 255 int
 256 rrd_parse_xport(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 257         char    *l = strdup(line + *eaten), *p;
 258         int     rc = 1;
 259
 260         p = strchr(l, ':');
 261         if (p != NULL)
 262                 *p++ = '\0';
 263         else
 264                 p = "";
 265
 266         if ((gdp->vidx=find_var(im, l))==-1){
 267                 rrd_set_error("unknown variable '%s'",l);
 268                 goto out;
 269         }
 270
 271         if (strlen(p) >= FMT_LEG_LEN)
 272                 *(p + FMT_LEG_LEN) = '\0';
 273
 274         strcpy(gdp->legend, p);
 275         *eaten = strlen(line);
 276         rc = 0;
 277
 278  out:
 279         free(l);
 280         return rc;
 281 }
 282
 283 /* Parsing of PART, VRULE, HRULE, LINE, AREA, STACK and TICK
 284 ** is done in one function.
 285 **
 286 ** Stacking PART, VRULE, HRULE or TICK is not allowed.
 287 **
 288 ** If a number (which is valid to enter) is more than a
 289 ** certain amount of characters, it is caught as an error.
 290 ** While this is arguable, so is entering fixed numbers
 291 ** with more than MAX_VNAME_LEN significant digits.
 292 */
 293 int
 294 rrd_parse_PVHLAST(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 295     int i,j,k;
 296     int colorfound=0;
 297     char tmpstr[MAX_VNAME_LEN + 10];    /* vname#RRGGBBAA\0 */
 298
 299     dprintf("- parsing '%s'\n",&line[*eaten]);
 300
 301     i=scan_for_col(&line[*eaten],MAX_VNAME_LEN+9,tmpstr);
 302     if (line[*eaten+i]!='\0' && line[*eaten+i]!=':') {
 303         rrd_set_error("Cannot parse line '%s'",line);
 304         return 1;
 305     }
 306
 307     j=i; while (j>0 && tmpstr[j]!='#') j--;
 308
 309     if (j) {
 310         tmpstr[j]='\0';
 311     }
 312
 313     dprintf("- examining value '%s'\n",tmpstr);
 314     k=0;
 315     if (gdp->gf == GF_VRULE) {
 316         sscanf(tmpstr,"%li%n",&gdp->xrule,&k);
 317         if (k) dprintf("- found time: %li\n",gdp->xrule);
 318     } else {
 319         sscanf(tmpstr,"%lf%n",&gdp->yrule,&k);
 320         if (k) dprintf("- found number: %f\n",gdp->yrule);
 321     }
 322     if (!k) {
 323         if ((gdp->vidx=find_var(im,tmpstr))<0) {
 324             rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 325             return 1;
 326         }
 327         dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 328     }
 329
 330     if (j) {
 331         j++;
 332         dprintf("- examining color '%s'\n",&tmpstr[j]);
 333         if (rrd_parse_color(&tmpstr[j],gdp)) {
 334             rrd_set_error("Could not parse color in '%s'",&tmpstr[j]);
 335             return 1;
 336         }
 337         dprintf("- parsed color 0x%08x\n",(unsigned int)gdp->col);
 338         colorfound=1;
 339     } else {
 340         dprintf("- no color present in '%s'\n",tmpstr);
 341     }
 342
 343     (*eaten) += i; /* after vname#color */
 344     if (line[*eaten]!='\0') {
 345         (*eaten)++;     /* after colon */
 346     }
 347
 348     if (gdp->gf == GF_TICK) {
 349         dprintf("- parsing '%s'\n",&line[*eaten]);
 350         dprintf("- looking for optional TICK number\n");
 351         j=0;
 352         sscanf(&line[*eaten],"%lf%n",&gdp->yrule,&j);
 353         if (j) {
 354             if (line[*eaten+j]!='\0' && line[*eaten+j]!=':') {
 355                 rrd_set_error("Cannot parse TICK fraction '%s'",line);
 356                 return 1;
 357             }
 358             dprintf("- found number %f\n",gdp->yrule);
 359             if (gdp->yrule > 1.0 || gdp->yrule < -1.0) {
 360                 rrd_set_error("Tick factor should be <= 1.0");
 361                 return 1;
 362             }
 363             (*eaten)+=j;
 364         } else {
 365             dprintf("- not found, defaulting to 0.1\n");
 366             gdp->yrule=0.1;
 367         }
 368         if (line[*eaten] == '\0') {
 369             dprintf("- done parsing line\n");
 370             return 0;
 371         } else { if (line[*eaten] == ':') {
 372                     (*eaten)++;
 373                  } else {
 374                      rrd_set_error("Can't make sense of that TICK line");
 375                    return 1;
 376                  }
 377         }
 378     }
 379
 380     dprintf("- parsing '%s'\n",&line[*eaten]);
 381
 382     /* Legend is next.  A legend without a color is an error.
 383     ** Stacking an item without having a legend is OK however
 384     ** then an empty legend should be specified.
 385     **   LINE:val#color:STACK   means legend is string "STACK"
 386     **   LINE:val#color::STACK  means no legend, and do STACK
 387     **   LINE:val:STACK         is an error (legend but no color)
 388     **   LINE:val::STACK        means no legend, and do STACK
 389     */
 390     if (colorfound) {
 391         char c1,c2;
 392         int err=0;
 393         char *linecp = strdup(line);
 394         dprintf("- looking for optional legend\n");
 395
 396         /* The legend needs to be prefixed with "m ". This then gets
 397         ** replaced by the color box. */
 398
 399         dprintf("- examining '%s'\n",&line[*eaten]);
 400
 401         (*eaten)--;
 402         linecp[*eaten]=' ';
 403         (*eaten)--;
 404         linecp[*eaten]='m';
 405
 406         if (rrd_parse_legend(linecp, eaten, gdp)) err=1;
 407
 408         free(linecp);
 409         if (err) return 1;
 410
 411         dprintf("- found legend '%s'\n", &gdp->legend[2]);
 412     } else {
 413         dprintf("- skipping empty legend\n");
 414         if (line[*eaten] != '\0' && line[*eaten] != ':') {
 415             rrd_set_error("Legend set but no color: %s",&line[*eaten]);
 416             return 1;
 417         }
 418     }
 419     if (line[*eaten]=='\0') {
 420         dprintf("- done parsing line\n");
 421         return 0;
 422     }
 423     (*eaten)++; /* after colon */
 424
 425     /* PART, HRULE, VRULE and TICK cannot be stacked. */
 426     if (   (gdp->gf == GF_HRULE)
 427         || (gdp->gf == GF_VRULE)
 428 #ifdef WITH_PIECHART
 429         || (gdp->gf == GF_PART)
 430 #endif
 431         || (gdp->gf == GF_TICK)
 432         ) return 0;
 433
 434     dprintf("- parsing '%s'\n",&line[*eaten]);
 435     if (line[*eaten]!='\0') {
 436         dprintf("- still more, should be STACK\n");
 437         j=scan_for_col(&line[*eaten],5,tmpstr);
 438         if (line[*eaten+j]!='\0' && line[*eaten+j]!=':') {
 439             /* not 5 chars */
 440             rrd_set_error("Garbage found where STACK expected");
 441             return 1;
 442         }
 443         if (!strcmp("STACK",tmpstr)) {
 444             dprintf("- found STACK\n");
 445             gdp->stack=1;
 446             (*eaten)+=j;
 447         } else {
 448             rrd_set_error("Garbage found where STACK expected");
 449             return 1;
 450         }
 451     }
 452     if (line[*eaten]=='\0') {
 453         dprintf("- done parsing line\n");
 454         return 0;
 455     }
 456     (*eaten)++;
 457     dprintf("- parsing '%s'\n",&line[*eaten]);
 458
 459     /* have simpler code in the drawing section */
 460     if ( gdp->gf == GF_STACK ){
 461             gdp->stack=1;
 462     }
 463     return 0;
 464 }
 465
 466 int
 467 rrd_parse_vname(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 468     char tmpstr[MAX_VNAME_LEN + 10];
 469     int i=0;
 470
 471     sscanf(&line[*eaten], DEF_NAM_FMT "=%n", tmpstr,&i);
 472     if (!i) {
 473         rrd_set_error("Cannot parse vname from '%s'",line);
 474         return 1;
 475     }
 476     dprintf("- found candidate '%s'\n",tmpstr);
 477
 478     if ((gdp->vidx=find_var(im,tmpstr))>=0) {
 479         rrd_set_error("Attempting to reuse '%s'",im->gdes[gdp->vidx].vname);
 480         return 1;
 481     }
 482     strcpy(gdp->vname,tmpstr);
 483     dprintf("- created vname '%s' vidx %lu\n", gdp->vname,im->gdes_c-1);
 484     (*eaten)+=i;
 485     return 0;
 486 }
 487
 488 int
 489 rrd_parse_def(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 490     int                 i=0;
 491     char                command[7]; /* step, start, end, reduce */
 492     char                tmpstr[256];
 493     struct rrd_time_value       start_tv,end_tv;
 494     time_t              start_tmp=0,end_tmp=0;
 495     char                *parsetime_error=NULL;
 496
 497     start_tv.type   = end_tv.type=ABSOLUTE_TIME;
 498     start_tv.offset = end_tv.offset=0;
 499     localtime_r(&gdp->start, &start_tv.tm);
 500     localtime_r(&gdp->end, &end_tv.tm);
 501
 502     dprintf("- parsing '%s'\n",&line[*eaten]);
 503     dprintf("- from line '%s'\n",line);
 504
 505     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 506     i=scan_for_col(&line[*eaten],254,gdp->rrd);
 507     if (line[*eaten+i]!=':') {
 508         rrd_set_error("Problems reading database name");
 509         return 1;
 510     }
 511     (*eaten)+=++i;
 512     dprintf("- using file '%s'\n",gdp->rrd);
 513
 514     i=0;
 515     sscanf(&line[*eaten], DS_NAM_FMT ":%n", gdp->ds_nam,&i);
 516     if (!i) {
 517         rrd_set_error("Cannot parse DS in '%s'",line);
 518         return 1;
 519     }
 520     (*eaten)+=i;
 521     dprintf("- using DS '%s'\n",gdp->ds_nam);
 522
 523     if (rrd_parse_CF(line,eaten,gdp,&gdp->cf)) return 1;
 524     gdp->cf_reduce = gdp->cf;
 525
 526     if (line[*eaten]=='\0') return 0;
 527
 528     while (1) {
 529         dprintf("- optional parameter follows: %s\n", &line[*eaten]);
 530         i=0;
 531         sscanf(&line[*eaten], "%6[a-z]=%n", command, &i);
 532         if (!i) {
 533             rrd_set_error("Parse error in '%s'",line);
 534             return 1;
 535         }
 536         (*eaten)+=i;
 537         dprintf("- processing '%s'\n",command);
 538         if (!strcmp("reduce",command)) {
 539           if (rrd_parse_CF(line,eaten,gdp,&gdp->cf_reduce)) return 1;
 540           if (line[*eaten] != '\0')
 541               (*eaten)--;
 542         } else if (!strcmp("step",command)) {
 543             i=0;
 544             sscanf(&line[*eaten],"%lu%n",&gdp->step,&i);
 545             (*eaten)+=i;
 546             dprintf("- using step %lu\n",gdp->step);
 547         } else if (!strcmp("start",command)) {
 548             i=scan_for_col(&line[*eaten],255,tmpstr);
 549             (*eaten)+=i;
 550             if ((parsetime_error = parsetime(tmpstr, &start_tv))) {
 551                 rrd_set_error( "start time: %s", parsetime_error );
 552                 return 1;
 553             }
 554             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 555         } else if (!strcmp("end",command)) {
 556             i=scan_for_col(&line[*eaten],255,tmpstr);
 557             (*eaten)+=i;
 558             if ((parsetime_error = parsetime(tmpstr, &end_tv))) {
 559                 rrd_set_error( "end time: %s", parsetime_error );
 560                 return 1;
 561             }
 562             dprintf("- done parsing:  '%s'\n",&line[*eaten]);
 563         } else {
 564             rrd_set_error("Parse error in '%s'",line);
 565             return 1;
 566         }
 567         if (line[*eaten]=='\0') break;
 568         if (line[*eaten]!=':') {
 569             dprintf("- Expected to see end of string but got '%s'\n",\
 570                                                          &line[*eaten]);
 571             rrd_set_error("Parse error in '%s'",line);
 572             return 1;
 573         }
 574         (*eaten)++;
 575     }
 576     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
 577         /* error string is set in parsetime.c */
 578         return 1;
 579     }
 580     if (start_tmp < 3600*24*365*10) {
 581         rrd_set_error("the first entry to fetch should be "
 582                         "after 1980 (%ld)",start_tmp);
 583         return 1;
 584     }
 585
 586     if (end_tmp < start_tmp) {
 587         rrd_set_error("start (%ld) should be less than end (%ld)",
 588                         start_tmp, end_tmp);
 589         return 1;
 590     }
 591
 592     gdp->start = start_tmp;
 593     gdp->end = end_tmp;
 594
 595     dprintf("- start time %lu\n",gdp->start);
 596     dprintf("- end   time %lu\n",gdp->end);
 597
 598     return 0;
 599 }
 600
 601 int
 602 rrd_parse_vdef(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 603     char tmpstr[MAX_VNAME_LEN+1];       /* vname\0 */
 604     int i=0;
 605
 606     dprintf("- parsing '%s'\n",&line[*eaten]);
 607     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 608
 609     sscanf(&line[*eaten], DEF_NAM_FMT ",%n", tmpstr,&i);
 610     if (!i) {
 611         rrd_set_error("Cannot parse line '%s'",line);
 612         return 1;
 613     }
 614     if ((gdp->vidx=find_var(im,tmpstr))<0) {
 615         rrd_set_error("Not a valid vname: %s in line %s",tmpstr,line);
 616         return 1;
 617     }
 618     if (   im->gdes[gdp->vidx].gf != GF_DEF
 619         && im->gdes[gdp->vidx].gf != GF_CDEF) {
 620         rrd_set_error("variable '%s' not DEF nor "
 621                         "CDEF in VDEF '%s'", tmpstr,gdp->vname);
 622         return 1;
 623     }
 624     dprintf("- found vname: '%s' vidx %li\n",tmpstr,gdp->vidx);
 625     (*eaten)+=i;
 626
 627     dprintf("- calling vdef_parse with param '%s'\n",&line[*eaten]);
 628     vdef_parse(gdp,&line[*eaten]);
 629     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 630         (*eaten)++;
 631
 632     return 0;
 633 }
 634
 635 int
 636 rrd_parse_cdef(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
 637     dprintf("- parsing '%s'\n",&line[*eaten]);
 638     if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
 639     if ((gdp->rpnp = rpn_parse(
 640         (void *)im,
 641         &line[*eaten],
 642         &find_var_wrapper)
 643     )==NULL) {
 644         rrd_set_error("invalid rpn expression in: %s",&line[*eaten]);
 645         return 1;
 646     };
 647     while (line[*eaten]!='\0'&&line[*eaten]!=':')
 648         (*eaten)++;
 649     return 0;
 650 }
 651
 652 void
 653 rrd_graph_script(int argc, char *argv[], image_desc_t *im, int optno) {
 654     int i;
 655
 656     for (i=optind+optno;i<argc;i++) {
 657         graph_desc_t *gdp;
 658         unsigned int eaten=0;
 659
 660         if (gdes_alloc(im)) return; /* the error string is already set */
 661         gdp = &im->gdes[im->gdes_c-1];
 662 #ifdef DEBUG
 663         gdp->debug = 1;
 664 #endif
 665
 666         if (rrd_parse_find_gf(argv[i],&eaten,gdp)) return;
 667
 668         switch (gdp->gf) {
 669             case GF_SHIFT:      /* vname:value */
 670                 if (rrd_parse_shift(argv[i],&eaten,gdp,im)) return;
 671                 break;
 672             case GF_XPORT:
 673                 if (rrd_parse_xport(argv[i],&eaten,gdp,im)) return;
 674                 break;
 675             case GF_PRINT:      /* vname:CF:format -or- vname:format */
 676             case GF_GPRINT:     /* vname:CF:format -or- vname:format */
 677                 if (rrd_parse_print(argv[i],&eaten,gdp,im)) return;
 678                 break;
 679             case GF_COMMENT:    /* text */
 680                 if (rrd_parse_legend(argv[i],&eaten,gdp)) return;
 681                 break;
 682             case GF_STACK:      /* vname-or-value[#color[:legend]] */
 683 #ifdef WITH_PIECHART
 684             case GF_PART:       /* value[#color[:legend]] */
 685 #endif
 686             case GF_VRULE:      /* value#color[:legend] */
 687             case GF_HRULE:      /* value#color[:legend] */
 688             case GF_LINE:       /* vname-or-value[#color[:legend]][:STACK] */
 689             case GF_AREA:       /* vname-or-value[#color[:legend]][:STACK] */
 690             case GF_TICK:       /* vname#color[:num[:legend]] */
 691                 if (rrd_parse_PVHLAST(argv[i],&eaten,gdp,im)) return;
 692                 break;
 693         /* data acquisition */
 694             case GF_DEF:        /* vname=x:DS:CF:[:step=#][:start=#][:end=#] */
 695                 if (rrd_parse_def(argv[i],&eaten,gdp,im)) return;
 696                 break;
 697             case GF_CDEF:       /* vname=rpn-expression */
 698                 if (rrd_parse_cdef(argv[i],&eaten,gdp,im)) return;
 699                 break;
 700             case GF_VDEF:       /* vname=rpn-expression */
 701                 if (rrd_parse_vdef(argv[i],&eaten,gdp,im)) return;
 702                 break;
 703         }
 704         if (gdp->debug) {
 705             dprintf("used %i out of %i chars\n",eaten,strlen(argv[i]));
 706             dprintf("parsed line: '%s'\n",argv[i]);
 707             dprintf("remaining: '%s'\n",&argv[i][eaten]);
 708             if (eaten >= strlen(argv[i]))
 709                 dprintf("Command finished successfully\n");
 710         }
 711         if (eaten < strlen(argv[i])) {
 712             rrd_set_error("Garbage '%s' after command:\n%s",
 713                         &argv[i][eaten],argv[i]);
 714             return;
 715         }
 716     }
 717 }